482 lines
22 KiB
C++
482 lines
22 KiB
C++
#include "world.h"
|
|
#include <uf/utils/time/time.h>
|
|
#include <uf/utils/io/iostream.h>
|
|
#include <uf/utils/math/vector.h>
|
|
#include <uf/utils/math/transform.h>
|
|
#include <uf/utils/window/window.h>
|
|
#include <uf/gl/gbuffer/gbuffer.h>
|
|
#include "../ext.h"
|
|
#include "./light/light.h"
|
|
#include "./gui/gui.h"
|
|
|
|
#include <uf/utils/audio/audio.h>
|
|
#include <uf/utils/thread/thread.h>
|
|
|
|
namespace {
|
|
uf::Camera* camera;
|
|
uf::GeometryBuffer light;
|
|
}
|
|
namespace {
|
|
std::function<uf::Entity*(uf::Entity*, const std::string&)> findByName = [&]( uf::Entity* parent, const std::string& name ) {
|
|
for ( uf::Entity* entity : parent->getChildren() ) {
|
|
if ( entity->getName() == name ) return entity;
|
|
uf::Entity* p = findByName(entity, name);
|
|
if ( p ) return p;
|
|
}
|
|
return (uf::Entity*) NULL;
|
|
};
|
|
std::function<uf::Entity*(uf::Entity*, uint)> findByUid = [&]( uf::Entity* parent, uint id ) {
|
|
for ( uf::Entity* entity : parent->getChildren() ) {
|
|
if ( entity->getUid() == id ) return entity;
|
|
uf::Entity* p = findByUid(entity, id);
|
|
if ( p ) return p;
|
|
}
|
|
return (uf::Entity*) NULL;
|
|
};
|
|
}
|
|
|
|
void ext::World::initialize() {
|
|
uf::Entity::initialize();
|
|
|
|
this->m_name = "World";
|
|
|
|
this->load();
|
|
}
|
|
|
|
void ext::World::tick() {
|
|
uf::Entity::tick();
|
|
|
|
/* Calibrates Polyfill */ {
|
|
static float x = 2.98986, y = 24.7805;
|
|
if ( uf::Window::isKeyPressed("L") ) x += 0.01;
|
|
if ( uf::Window::isKeyPressed("J") ) x -= 0.01;
|
|
if ( uf::Window::isKeyPressed("I") ) y += 0.01;
|
|
if ( uf::Window::isKeyPressed("K") ) y -= 0.01;
|
|
if ( uf::Window::isKeyPressed("O") ) std::cout << x << ", " << y << std::endl;
|
|
glPolygonOffset(x, y);
|
|
}
|
|
/* Print World Tree */ {
|
|
static uf::Timer<long long> timer(false);
|
|
if ( !timer.running() ) timer.start();
|
|
if ( uf::Window::isKeyPressed("U") && timer.elapsed().asDouble() >= 1 ) { timer.reset();
|
|
std::function<void(const uf::Entity*, int)> recurse = [&]( const uf::Entity* parent, int indent ) {
|
|
for ( const uf::Entity* entity : parent->getChildren() ) {
|
|
for ( int i = 0; i < indent; ++i ) std::cout<<"\t";
|
|
std::cout<<entity->getName()<<": "<<entity->getUid();
|
|
if ( entity->hasComponent<pod::Transform<>>() ) {
|
|
const pod::Transform<>& t = uf::transform::flatten(entity->getComponent<pod::Transform<>>());
|
|
std::cout << " (" << t.position.x << ", " << t.position.y << ", " << t.position.z << ")";
|
|
}
|
|
std::cout<<std::endl;
|
|
recurse(entity, indent + 1);
|
|
}
|
|
}; recurse(this, 0);
|
|
}
|
|
}
|
|
/* Print Entity Information */ {
|
|
static uf::Timer<long long> timer(false);
|
|
if ( !timer.running() ) timer.start();
|
|
if ( uf::Window::isKeyPressed("U") && timer.elapsed().asDouble() >= 1 ) { timer.reset();
|
|
std::cout << "Current size: " << uf::Entity::entities.size() << " | UIDs: " << uf::Entity::uids << std::endl;
|
|
uint i = 0; for ( uf::Entity* e : uf::Entity::entities ) {
|
|
if ( e && !e->hasParent() ) {
|
|
++i;
|
|
std::cout << "Orphan: " << e->getName() << ": " << e << std::endl;
|
|
}
|
|
}
|
|
std::cout << "Orphans: " << i << std::endl;
|
|
}
|
|
}
|
|
|
|
/* Updates Sound Listener */ {
|
|
ext::Player& player = this->getPlayer();
|
|
pod::Transform<>& transform = player.getComponent<pod::Transform<>>();
|
|
|
|
ext::oal.listener( "POSITION", { transform.position.x, transform.position.y, transform.position.z } );
|
|
ext::oal.listener( "VELOCITY", { 0, 0, 0 } );
|
|
ext::oal.listener( "ORIENTATION", { 0, 0, 1, 1, 0, 0 } );
|
|
}
|
|
|
|
static bool first = false; if ( !first ) { first = true;
|
|
uf::thread::add( uf::thread::has("Main") ? uf::thread::get("Main") : uf::thread::create( "Main", false, true ), [&]() -> int {
|
|
ext::Terrain* terrain = (ext::Terrain*) findByName(this, "Terrain");
|
|
if ( !terrain ) return 0;
|
|
uf::Serializer& metadata = terrain->getComponent<uf::Serializer>();
|
|
pod::Vector3 position = { 0, 32, 0 };
|
|
/* Element */ {
|
|
ext::Gui* gui = (ext::Gui*) findByName(this, "Gui Manager");
|
|
if ( !gui ) return 0;
|
|
uf::Entity* element = new ext::Gui;
|
|
ext::Gui& guiElement = *((ext::Gui*) element);
|
|
std::string config = "./terrain/moon/config.json";
|
|
if ( !guiElement.load(config) ) { uf::iostream << "Error loading `" << config << "!" << "\n"; delete element; return 0; } {
|
|
gui->addChild(*element);
|
|
uf::Serializer& gMetadata = element->getComponent<uf::Serializer>();
|
|
element->initialize();
|
|
pod::Transform<>& transform = element->getComponent<pod::Transform<>>();
|
|
position = transform.position;
|
|
}
|
|
|
|
if ( !metadata["moon"]["light"]["should"].asBool() ) return 0;
|
|
|
|
uf::Entity* entity = new ext::Light;
|
|
if ( !((ext::Object*) entity)->load("./light/config.json") ) { uf::iostream << "Error loading `" << "./light/config.json" << "!" << "\n"; delete entity; return 0; } {
|
|
terrain->addChild(*entity);
|
|
entity->getComponent<uf::Serializer>()["light"] = metadata["moon"]["light"];
|
|
entity->getComponent<uf::Serializer>()["camera"] = metadata["moon"]["camera"];
|
|
entity->initialize();
|
|
|
|
pod::Transform<>& transform = entity->getComponent<pod::Transform<>>();
|
|
transform = uf::transform::initialize( transform );
|
|
transform.position = position;
|
|
uf::transform::rotate( transform, transform.right, 1.5708 * 1 );
|
|
entity->getComponent<uf::Camera>().update(true);
|
|
}
|
|
}
|
|
return 0;}, true );
|
|
}
|
|
}
|
|
|
|
|
|
uf::Camera& ext::World::getCamera() {
|
|
return *::camera;
|
|
}
|
|
|
|
void ext::World::render() {
|
|
uf::GeometryBuffer& buffer = this->getComponent<uf::GeometryBuffer>();
|
|
uf::Serializer& metadata = this->getComponent<uf::Serializer>();
|
|
|
|
{
|
|
::camera = this->getPlayer().getComponentPointer<uf::Camera>();
|
|
::camera->update(true);
|
|
}
|
|
|
|
/* Prepare Geometry Buffer */ {
|
|
buffer.bind();
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
/* Render entities (normal pass) */ {
|
|
metadata["state"] = 0;
|
|
uf::Entity::render();
|
|
}
|
|
|
|
/* Prepare deferred pass */ {
|
|
metadata["state"] = 1;
|
|
|
|
/* */ {
|
|
::light.bind();
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
buffer.unbind();
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
}
|
|
|
|
std::vector<ext::Light*> lights;
|
|
/* Light pass */ {
|
|
std::function<void(uf::Entity*, int)> recurse = [&]( uf::Entity* parent, int indent ) {
|
|
for ( uf::Entity* entity : parent->getChildren() ) {
|
|
if ( entity->getName() == "Light" ) lights.push_back( (ext::Light*) entity );
|
|
recurse(entity, indent + 1);
|
|
}
|
|
};
|
|
recurse(this, 0);
|
|
/* Sort by closest to farthest */ {
|
|
const ext::World& world = this->getRootParent<ext::World>();
|
|
const ext::Player& player = world.getPlayer();
|
|
const pod::Vector3& position = player.getComponent<pod::Transform<>>().position;
|
|
std::sort( lights.begin(), lights.end(), [&]( const uf::Entity* l, const uf::Entity* r ){
|
|
if ( !l ) return false;
|
|
if ( !r ) return true;
|
|
if ( !l->hasComponent<pod::Transform<>>() ) return false;
|
|
if ( !r->hasComponent<pod::Transform<>>() ) return true;
|
|
return uf::vector::magnitude( uf::vector::subtract( l->getComponent<pod::Transform<>>().position, position ) ) > uf::vector::magnitude( uf::vector::subtract( r->getComponent<pod::Transform<>>().position, position ) );
|
|
} );
|
|
}
|
|
if ( uf::Window::isKeyPressed("G") ) {
|
|
::camera->update(true);
|
|
::camera->update(true);
|
|
}
|
|
|
|
for ( ext::Light* entity : lights ) {
|
|
ext::Light& light = *entity;
|
|
uf::Serializer& lMetadata = light.getComponent<uf::Serializer>();
|
|
if ( !lMetadata["light"]["render"].asBool() ) continue;
|
|
uf::GeometryBuffer& lightBuffer = lMetadata["light"]["dedicated"].asBool() ? light.getComponent<uf::GeometryBuffer>() : ::light;
|
|
uf::Camera& lightCam = light.getComponent<uf::Camera>();
|
|
if ( !light.hasComponent<uf::GeometryBuffer>() || lMetadata["light"]["render_state"].asInt() == 0 ){
|
|
lightBuffer.bind();
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
::camera = light.getComponentPointer<uf::Camera>();
|
|
glViewport( 0, 0, ::camera->getSize().x, ::camera->getSize().y );
|
|
glEnable(GL_POLYGON_OFFSET_FILL);
|
|
glDisable(GL_CULL_FACE);
|
|
// ::camera->update(true);
|
|
uf::Entity::render();
|
|
glDisable(GL_POLYGON_OFFSET_FILL);
|
|
glEnable(GL_CULL_FACE);
|
|
::camera = this->getPlayer().getComponentPointer<uf::Camera>();
|
|
glViewport( 0, 0, ::camera->getSize().x, ::camera->getSize().y );
|
|
}
|
|
if ( (lMetadata["light"]["render_state"]=lMetadata["light"]["render_state"].asInt()+1).asInt()-1 >= lMetadata["light"]["rate"].asInt() ) lMetadata["light"]["render_state"]= 0;
|
|
{
|
|
metadata["buffer"]["lightmap"].asBool() ? ::light.bind() : buffer.unbind();
|
|
|
|
if ( lMetadata["light"]["blend"] != Json::nullValue ) {
|
|
glEnable(GL_BLEND);
|
|
GLenum parameters[4] = {
|
|
GL_ONE,
|
|
GL_ONE,
|
|
GL_ONE,
|
|
GL_ONE,
|
|
};
|
|
for ( int i = 0; i < lMetadata["light"]["blend"].size(); ++i ) {
|
|
if ( lMetadata["light"]["blend"][i] == "ZERO" || lMetadata["light"]["blend"][i] == "GL_ZERO" ) parameters[i] = GL_ZERO;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE" || lMetadata["light"]["blend"][i] == "GL_ONE" ) parameters[i] = GL_ONE;
|
|
if ( lMetadata["light"]["blend"][i] == "SRC_COLOR" || lMetadata["light"]["blend"][i] == "GL_SRC_COLOR" ) parameters[i] = GL_SRC_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_SRC_COLOR" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_SRC_COLOR" ) parameters[i] = GL_ONE_MINUS_SRC_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "DST_COLOR" || lMetadata["light"]["blend"][i] == "GL_DST_COLOR" ) parameters[i] = GL_DST_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_DST_COLOR" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_DST_COLOR" ) parameters[i] = GL_ONE_MINUS_DST_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "SRC_ALPHA" || lMetadata["light"]["blend"][i] == "GL_SRC_ALPHA" ) parameters[i] = GL_SRC_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_SRC_ALPHA" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_SRC_ALPHA" ) parameters[i] = GL_ONE_MINUS_SRC_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "DST_ALPHA" || lMetadata["light"]["blend"][i] == "GL_DST_ALPHA" ) parameters[i] = GL_DST_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_DST_ALPHA" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_DST_ALPHA" ) parameters[i] = GL_ONE_MINUS_DST_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "CONSTANT_COLOR" || lMetadata["light"]["blend"][i] == "GL_CONSTANT_COLOR" ) parameters[i] = GL_CONSTANT_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_CONSTANT_COLOR" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_CONSTANT_COLOR" ) parameters[i] = GL_ONE_MINUS_CONSTANT_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "CONSTANT_ALPHA" || lMetadata["light"]["blend"][i] == "GL_CONSTANT_ALPHA" ) parameters[i] = GL_CONSTANT_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_CONSTANT_ALPHA" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_CONSTANT_ALPHA" ) parameters[i] = GL_ONE_MINUS_CONSTANT_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "SRC_ALPHA_SATURATE" || lMetadata["light"]["blend"][i] == "GL_SRC_ALPHA_SATURATE" ) parameters[i] = GL_SRC_ALPHA_SATURATE;
|
|
if ( lMetadata["light"]["blend"][i] == "SRC1_COLOR" || lMetadata["light"]["blend"][i] == "GL_SRC1_COLOR" ) parameters[i] = GL_SRC1_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_SRC_COLOR" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_SRC_COLOR" ) parameters[i] = GL_ONE_MINUS_SRC_COLOR;
|
|
if ( lMetadata["light"]["blend"][i] == "SRC1_ALPHA" || lMetadata["light"]["blend"][i] == "GL_SRC1_ALPHA" ) parameters[i] = GL_SRC1_ALPHA;
|
|
if ( lMetadata["light"]["blend"][i] == "ONE_MINUS_SRC_ALPHA" || lMetadata["light"]["blend"][i] == "GL_ONE_MINUS_SRC_ALPHA" ) parameters[i] = GL_ONE_MINUS_SRC_ALPHA;
|
|
}
|
|
|
|
if ( lMetadata["light"]["blend"].size() == 2 ) {
|
|
glBlendEquation(GL_FUNC_ADD);
|
|
glBlendFunc(parameters[0], parameters[1]);
|
|
} else if ( lMetadata["light"]["blend"].size() == 4 ) {
|
|
glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
|
|
glBlendFuncSeparate(parameters[0], parameters[1], parameters[2], parameters[3]);
|
|
}
|
|
}
|
|
|
|
uf::Shader& shader = light.getComponent<uf::Shader>();
|
|
uf::Mesh& mesh = buffer.getComponent<uf::Mesh>();
|
|
pod::Transform<>& lightTransform = light.getComponent<pod::Transform<>>();
|
|
|
|
shader.bind(); { int i = 0; for ( auto& texture : buffer.getBuffers() ) {
|
|
texture.bind(i);
|
|
shader.push("buffers.geom_"+texture.getName(), i++);
|
|
} for ( auto& texture : lightBuffer.getBuffers() ) {
|
|
texture.bind(i);
|
|
shader.push("buffers.light_"+texture.getName(), i++);
|
|
}
|
|
|
|
shader.push("matrices.view", this->getPlayer().getComponent<uf::Camera>().getView());
|
|
shader.push("matrices.projection", this->getPlayer().getComponent<uf::Camera>().getProjection());
|
|
shader.push("matrices.projectionInverse", uf::matrix::inverse(this->getPlayer().getComponent<uf::Camera>().getProjection()));
|
|
|
|
if ( lMetadata["light"]["color"] != Json::nullValue ) shader.push("parameters.color", {lMetadata["light"]["color"][0].asFloat(),lMetadata["light"]["color"][1].asFloat(),lMetadata["light"]["color"][2].asFloat()});//light.getColor());
|
|
if ( lMetadata["light"]["attenuation"] != Json::nullValue ) shader.push("parameters.attenuation", lMetadata["light"]["attenuation"].asFloat());//light.getAttenuation());
|
|
if ( lMetadata["light"]["power"] != Json::nullValue ) shader.push("parameters.power", lMetadata["light"]["power"].asFloat());//light.getPower());
|
|
if ( lMetadata["light"]["specular"] != Json::nullValue ) shader.push("parameters.specular", {lMetadata["light"]["specular"][0].asFloat(),lMetadata["light"]["specular"][1].asFloat(),lMetadata["light"]["specular"][2].asFloat()});//light.getColor());
|
|
shader.push("parameters.position", lightTransform.position);
|
|
|
|
shader.push("parameters.view", lightCam.getView());
|
|
shader.push("parameters.projection", lightCam.getProjection());
|
|
}
|
|
mesh.render();
|
|
glDisable(GL_BLEND);
|
|
}
|
|
}
|
|
if ( metadata["buffer"]["lightmap"].asBool() ) {
|
|
buffer.unbind();
|
|
uf::Shader& shader = buffer.getComponent<uf::Shader>();
|
|
uf::Camera& camera = this->getCamera();
|
|
uf::Mesh& mesh = buffer.getComponent<uf::Mesh>();
|
|
shader.bind(); { int i = 0; for ( auto& texture : buffer.getBuffers() ) {
|
|
texture.bind(i);
|
|
shader.push("buffers.geom_"+texture.getName(), i++);
|
|
} for ( auto& texture : ::light.getBuffers() ) {
|
|
texture.bind(i);
|
|
shader.push("buffers.light_"+texture.getName(), i++);
|
|
}
|
|
|
|
shader.push("matrices.view", camera.getView());
|
|
shader.push("matrices.projection", camera.getProjection());
|
|
shader.push("matrices.projectionInverse", uf::matrix::inverse(this->getPlayer().getComponent<uf::Camera>().getProjection()));
|
|
|
|
shader.push("parameters.light", !lights.empty());
|
|
}
|
|
mesh.render();
|
|
}
|
|
}
|
|
/* GUI pass */ {
|
|
metadata["state"] = 2;
|
|
glEnable(GL_BLEND);
|
|
glDisable(GL_DEPTH_TEST);
|
|
glBlendEquation(GL_FUNC_ADD);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
for ( uf::Entity* entity : this->getChildren() ) if ( entity->getName() == "Gui Manager" ) entity->render();
|
|
glDisable(GL_BLEND);
|
|
glEnable(GL_DEPTH_TEST);
|
|
}
|
|
buffer.unbind();
|
|
}
|
|
|
|
ext::Player& ext::World::getPlayer() {
|
|
std::function<uf::Entity*(uf::Entity*, int)> recurse = [&]( uf::Entity* parent, int indent ) {
|
|
for ( uf::Entity* entity : parent->getChildren() ) {
|
|
if ( entity->getName() == "Player" ) return entity;
|
|
uf::Entity* p = recurse(entity, indent + 1);
|
|
if ( p ) return p;
|
|
}
|
|
return (uf::Entity*) NULL;
|
|
};
|
|
uf::Entity* pointer = recurse(this, 0);
|
|
return *((ext::Player*) pointer);
|
|
}
|
|
const ext::Player& ext::World::getPlayer() const {
|
|
std::function<const uf::Entity*(const uf::Entity*, int)> recurse = [&]( const uf::Entity* parent, int indent ) {
|
|
for ( const uf::Entity* entity : parent->getChildren() ) {
|
|
if ( entity->getName() == "Player" ) return entity;
|
|
const uf::Entity* p = recurse(entity, indent + 1);
|
|
if ( p ) return p;
|
|
}
|
|
return (const uf::Entity*) NULL;
|
|
};
|
|
const uf::Entity* pointer = recurse(this, 0); return
|
|
*((const ext::Player*) pointer);
|
|
}
|
|
|
|
bool ext::World::load() {
|
|
uf::Serializer& metadata = this->getComponent<uf::Serializer>();
|
|
struct { uf::Serializer base; uf::Serializer shader; } config;
|
|
/* Load entity file */ {
|
|
struct { bool exists = false; std::string filename = "./entities/world/config.json"; } file;
|
|
/* Read from file */ if ( !(file.exists = config.base.readFromFile(file.filename)) ) { uf::iostream << "Error loading `" << file.filename << "!" << "\n"; return false; }
|
|
metadata = config.base;
|
|
for ( uint i = 0; i < config.base["entities"].size(); ++i ) {
|
|
std::string json = config.base["entities"][i].asString();
|
|
std::string type = ""; {
|
|
std::string root = "./entities/" + uf::string::directory(json);
|
|
struct { uf::Serializer base; } config;
|
|
/* Load entity file */ {
|
|
struct { bool exists = false; std::string filename; } file;
|
|
file.filename = root + uf::string::filename(json);
|
|
/* Read from file */ if ( !(file.exists = config.base.readFromFile(file.filename)) ) { uf::iostream << "Error loading `" << file.filename << "!" << "\n"; return false; }
|
|
type = config.base["type"].asString();
|
|
}
|
|
if ( config.base["ignore"].asBool() ) continue;
|
|
}
|
|
uf::Entity* entity;
|
|
if ( type == "Terrain" ) entity = new ext::Terrain;
|
|
else if ( type == "Player" ) entity = new ext::Player;
|
|
else if ( type == "Craeture" ) entity = new ext::Craeture;
|
|
else if ( type == "Light" ) entity = new ext::Light;
|
|
else if ( type == "Gui" ) entity = new ext::Gui;
|
|
else entity = new ext::Object;
|
|
|
|
if ( !((ext::Object*) entity)->load(json) ) { uf::iostream << "Error loading `" << json << "!" << "\n"; delete entity; return false; }
|
|
this->addChild(*entity); entity->initialize();
|
|
}
|
|
/* Geometry Buffer */ {
|
|
/* Generate default light shadowmap */ {
|
|
uf::GeometryBuffer& buffer = ::light;
|
|
this->getComponent<uf::Hooks>().addHook( "window:Resized", [&](const std::string& event)->std::string{
|
|
uf::Serializer json = event;
|
|
|
|
// Update persistent window sized (size stored to JSON file)
|
|
pod::Vector2ui size; {
|
|
size.x = json["window"]["size"]["x"].asUInt64();
|
|
size.y = json["window"]["size"]["y"].asUInt64();
|
|
}
|
|
size *= metadata["buffer"]["scale"].asDouble();
|
|
if ( size.x == buffer.getSize().x && size.y == buffer.getSize().y ) return "false";
|
|
|
|
auto& buffers = buffer.getBuffers();
|
|
buffers.clear();
|
|
uint i = 0;
|
|
buffers.push_back( spec::ogl::GeometryTexture() );
|
|
buffers.push_back( spec::ogl::GeometryTexture() );
|
|
spec::ogl::GeometryTexture& light = buffers[i++];
|
|
spec::ogl::GeometryTexture& depth = buffers[i++];
|
|
light.setSize(size); light.setName("light"); light.setType({ GL_COLOR_ATTACHMENT0, GL_FLOAT, GL_RGBA, GL_RGBA16F });
|
|
depth.setSize(size); depth.setName("depth"); depth.setType({ GL_DEPTH_ATTACHMENT, GL_FLOAT, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT });
|
|
buffer.setSize(size);
|
|
buffer.generate();
|
|
return "true";
|
|
} );
|
|
}
|
|
uf::GeometryBuffer& buffer = this->getComponent<uf::GeometryBuffer>(); {
|
|
this->getComponent<uf::Hooks>().addHook( "window:Resized", [&](const std::string& event)->std::string{
|
|
uf::Serializer json = event;
|
|
|
|
// Update persistent window sized (size stored to JSON file)
|
|
pod::Vector2ui size; {
|
|
size.x = json["window"]["size"]["x"].asUInt64();
|
|
size.y = json["window"]["size"]["y"].asUInt64();
|
|
}
|
|
size *= metadata["buffer"]["scale"].asDouble();
|
|
if ( size.x == buffer.getSize().x && size.y == buffer.getSize().y ) return "false";
|
|
|
|
auto& buffers = buffer.getBuffers();
|
|
buffers.clear();
|
|
uint i = 0;
|
|
buffers.push_back( spec::ogl::GeometryTexture() );
|
|
buffers.push_back( spec::ogl::GeometryTexture() );
|
|
buffers.push_back( spec::ogl::GeometryTexture() );
|
|
// buffers.push_back( spec::ogl::GeometryTexture() );
|
|
|
|
spec::ogl::GeometryTexture& color = buffers[i++];
|
|
spec::ogl::GeometryTexture& normal = buffers[i++];
|
|
// spec::ogl::GeometryTexture& position = buffers[i++];
|
|
spec::ogl::GeometryTexture& depth = buffers[i++];
|
|
|
|
color.setSize(size); color.setName("color"); color.setType({ GL_COLOR_ATTACHMENT0, GL_FLOAT, GL_RGBA, GL_RGBA16F });
|
|
normal.setSize(size); normal.setName("normal"); normal.setType({ GL_COLOR_ATTACHMENT1, GL_FLOAT, GL_RGB, GL_RGB16F });
|
|
// position.setSize(size); position.setName("position"); position.setType({ GL_COLOR_ATTACHMENT2, GL_FLOAT, GL_RGB, GL_RGB16F });
|
|
depth.setSize(size); depth.setName("depth"); depth.setType({ GL_DEPTH_ATTACHMENT, GL_FLOAT, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT });
|
|
|
|
buffer.setSize(size);
|
|
buffer.generate();
|
|
return "true";
|
|
} );
|
|
}
|
|
|
|
uf::Shader& shader = buffer.getComponent<uf::Shader>();
|
|
/* Shader */ if ( config.base["shader"] != Json::nullValue ) {
|
|
struct {
|
|
bool exists = false;
|
|
std::string directory;
|
|
std::string localFilename;
|
|
std::string filename;
|
|
} file;
|
|
std::string root = "./entities/world/";
|
|
file.directory = root + uf::string::directory(config.base["shader"].asString());
|
|
file.localFilename = uf::string::filename(config.base["shader"].asString());
|
|
file.filename = file.directory + file.localFilename;
|
|
file.exists = config.shader.readFromFile(file.filename);
|
|
/* Read from file */ if ( !file.exists ) { uf::iostream << "Error loading `" << file.filename << "!" << "\n"; return false; }
|
|
/* Load shaders */ {
|
|
bool fromFile = config.shader["source"] == "file";
|
|
// Vertex
|
|
std::string vertex = file.directory + config.shader["shaders"]["vertex"].asString();
|
|
shader.add( uf::Shader::Component( vertex, GL_VERTEX_SHADER, fromFile ) );
|
|
// Fragment
|
|
std::string fragment = file.directory + config.shader["shaders"]["fragment"].asString();
|
|
shader.add( uf::Shader::Component( fragment, GL_FRAGMENT_SHADER, fromFile ) );
|
|
}
|
|
|
|
shader.compile();
|
|
shader.link();
|
|
for ( std::size_t i = 0; i < config.shader["attributes"].size(); ++i ) shader.bindAttribute( i, config.shader["attributes"][(int) i].asString() );
|
|
for ( std::size_t i = 0; i < config.shader["fragmentData"].size(); ++i ) shader.bindFragmentData( i, config.shader["fragmentData"][(int) i].asString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
} |