Engine.cpp

Go to the documentation of this file.

#include <tdme/engine/Engine.h>
 
#include <algorithm>
#include <map>
#include <string>
 
#include <tdme/tdme.h>
#include <tdme/application/Application.h>
#include <tdme/engine/fileio/textures/PNGTextureWriter.h>
#include <tdme/engine/fileio/textures/Texture.h>
#include <tdme/engine/fileio/textures/TextureReader.h>
#include <tdme/engine/model/Color4.h>
#include <tdme/engine/model/Node.h>
#include <tdme/engine/physics/CollisionDetection.h>
#include <tdme/engine/primitives/BoundingBox.h>
#include <tdme/engine/primitives/LineSegment.h>
#include <tdme/engine/subsystems/earlyzrejection/EZRShader.h>
#include <tdme/engine/subsystems/environmentmapping/EnvironmentMappingRenderer.h>
#include <tdme/engine/subsystems/framebuffer/DeferredLightingRenderShader.h>
#include <tdme/engine/subsystems/framebuffer/FrameBufferRenderShader.h>
#include <tdme/engine/subsystems/lighting/LightingShader.h>
#include <tdme/engine/subsystems/lines/LinesShader.h>
#include <tdme/engine/subsystems/manager/MeshManager.h>
#include <tdme/engine/subsystems/manager/TextureManager.h>
#include <tdme/engine/subsystems/manager/VBOManager.h>
#include <tdme/engine/subsystems/particlesystem/ParticlesShader.h>
#include <tdme/engine/subsystems/postprocessing/PostProcessing.h>
#include <tdme/engine/subsystems/postprocessing/PostProcessingProgram.h>
#include <tdme/engine/subsystems/postprocessing/PostProcessingShader.h>
#include <tdme/engine/subsystems/renderer/Renderer.h>
#include <tdme/engine/subsystems/rendering/EntityRenderer.h>
#include <tdme/engine/subsystems/rendering/EntityRenderer_InstancedRenderFunctionParameters.h>
#include <tdme/engine/subsystems/rendering/Object3DBase_TransformedFacesIterator.h>
#include <tdme/engine/subsystems/rendering/Object3DNodeMesh.h>
#include <tdme/engine/subsystems/rendering/ObjectBuffer.h>
#include <tdme/engine/subsystems/rendering/TransparentRenderFacesPool.h>
#include <tdme/engine/subsystems/shadowmapping/ShadowMap.h>
#include <tdme/engine/subsystems/shadowmapping/ShadowMapping.h>
#include <tdme/engine/subsystems/shadowmapping/ShadowMapCreationShader.h>
#include <tdme/engine/subsystems/shadowmapping/ShadowMapRenderShader.h>
#include <tdme/engine/subsystems/skinning/SkinningShader.h>
#include <tdme/engine/subsystems/texture2D/Texture2DRenderShader.h>
#include <tdme/engine/Camera.h>
#include <tdme/engine/Entity.h>
#include <tdme/engine/EntityHierarchy.h>
#include <tdme/engine/EntityPickingFilter.h>
#include <tdme/engine/EnvironmentMapping.h>
#include <tdme/engine/FogParticleSystem.h>
#include <tdme/engine/FrameBuffer.h>
#include <tdme/engine/GeometryBuffer.h>
#include <tdme/engine/ImposterObject3D.h>
#include <tdme/engine/Light.h>
#include <tdme/engine/LinesObject3D.h>
#include <tdme/engine/LODObject3D.h>
#include <tdme/engine/LODObject3DImposter.h>
#include <tdme/engine/Object3D.h>
#include <tdme/engine/Object3DRenderGroup.h>
#include <tdme/engine/ObjectParticleSystem.h>
#include <tdme/engine/OctTreePartition.h>
#include <tdme/engine/ParticleSystemEntity.h>
#include <tdme/engine/ParticleSystemGroup.h>
#include <tdme/engine/Partition.h>
#include <tdme/engine/PointsParticleSystem.h>
#include <tdme/engine/ShaderParameter.h>
#include <tdme/engine/Timing.h>
#include <tdme/gui/renderer/GUIRenderer.h>
#include <tdme/gui/renderer/GUIShader.h>
#include <tdme/gui/GUI.h>
#include <tdme/gui/GUIParser.h>
#include <tdme/math/Math.h>
#include <tdme/math/Matrix4x4.h>
#include <tdme/math/Vector2.h>
#include <tdme/math/Vector3.h>
#include <tdme/math/Vector4.h>
#include <tdme/os/filesystem/FileSystem.h>
#include <tdme/os/filesystem/FileSystemInterface.h>
#include <tdme/os/threading/Queue.h>
#include <tdme/os/threading/Thread.h>
#include <tdme/utilities/ByteBuffer.h>
#include <tdme/utilities/Console.h>
#include <tdme/utilities/Float.h>
#include <tdme/utilities/VectorIteratorMultiple.h>
 
using std::map;
using std::remove;
using std::string;
using std::to_string;
 
using tdme::application::Application;
using tdme::engine::fileio::textures::PNGTextureWriter;
using tdme::engine::fileio::textures::Texture;
using tdme::engine::fileio::textures::TextureReader;
using tdme::engine::model::Color4;
using tdme::engine::model::Node;
using tdme::engine::physics::CollisionDetection;
using tdme::engine::primitives::BoundingBox;
using tdme::engine::primitives::LineSegment;
using tdme::engine::subsystems::earlyzrejection::EZRShader;
using tdme::engine::subsystems::environmentmapping::EnvironmentMappingRenderer;
using tdme::engine::subsystems::framebuffer::DeferredLightingRenderShader;
using tdme::engine::subsystems::framebuffer::FrameBufferRenderShader;
using tdme::engine::subsystems::lighting::LightingShader;
using tdme::engine::subsystems::lines::LinesShader;
using tdme::engine::subsystems::manager::MeshManager;
using tdme::engine::subsystems::manager::TextureManager;
using tdme::engine::subsystems::manager::VBOManager;
using tdme::engine::subsystems::particlesystem::ParticlesShader;
using tdme::engine::subsystems::postprocessing::PostProcessing;
using tdme::engine::subsystems::postprocessing::PostProcessingProgram;
using tdme::engine::subsystems::postprocessing::PostProcessingShader;
using tdme::engine::subsystems::renderer::Renderer;
using tdme::engine::subsystems::rendering::EntityRenderer;
using tdme::engine::subsystems::rendering::EntityRenderer_InstancedRenderFunctionParameters;
using tdme::engine::subsystems::rendering::Object3DBase_TransformedFacesIterator;
using tdme::engine::subsystems::rendering::ObjectBuffer;
using tdme::engine::subsystems::rendering::TransparentRenderFacesPool;
using tdme::engine::subsystems::shadowmapping::ShadowMap;
using tdme::engine::subsystems::shadowmapping::ShadowMapping;
using tdme::engine::subsystems::shadowmapping::ShadowMapCreationShader;
using tdme::engine::subsystems::shadowmapping::ShadowMapRenderShader;
using tdme::engine::subsystems::skinning::SkinningShader;
using tdme::engine::subsystems::texture2D::Texture2DRenderShader;
using tdme::engine::Camera;
using tdme::engine::Engine;
using tdme::engine::Entity;
using tdme::engine::EntityHierarchy;
using tdme::engine::EntityPickingFilter;
using tdme::engine::FogParticleSystem;
using tdme::engine::FrameBuffer;
using tdme::engine::GeometryBuffer;
using tdme::engine::ImposterObject3D;
using tdme::engine::Light;
using tdme::engine::LinesObject3D;
using tdme::engine::LODObject3D;
using tdme::engine::LODObject3DImposter;
using tdme::engine::Object3D;
using tdme::engine::Object3DRenderGroup;
using tdme::engine::ObjectParticleSystem;
using tdme::engine::OctTreePartition;
using tdme::engine::ParticleSystemEntity;
using tdme::engine::ParticleSystemGroup;
using tdme::engine::Partition;
using tdme::engine::PointsParticleSystem;
using tdme::engine::ShaderParameter;
using tdme::engine::Timing;
using tdme::gui::renderer::GUIRenderer;
using tdme::gui::renderer::GUIShader;
using tdme::gui::GUI;
using tdme::gui::GUIParser;
using tdme::math::Math;
using tdme::math::Matrix4x4;
using tdme::math::Vector2;
using tdme::math::Vector3;
using tdme::math::Vector4;
using tdme::os::filesystem::FileSystem;
using tdme::os::filesystem::FileSystemInterface;
using tdme::os::threading::Queue;
using tdme::os::threading::Thread;
using tdme::utilities::ByteBuffer;
using tdme::utilities::Console;
using tdme::utilities::Float;
 
Engine* Engine::instance = nullptr;
Renderer* Engine::renderer = nullptr;
TextureManager* Engine::textureManager = nullptr;
VBOManager* Engine::vboManager = nullptr;
MeshManager* Engine::meshManager = nullptr;
GUIRenderer* Engine::guiRenderer = nullptr;
FrameBufferRenderShader* Engine::frameBufferRenderShader = nullptr;
DeferredLightingRenderShader* Engine::deferredLightingRenderShader = nullptr;
PostProcessing* Engine::postProcessing = nullptr;
PostProcessingShader* Engine::postProcessingShader = nullptr;
Texture2DRenderShader* Engine::texture2DRenderShader = nullptr;
Engine::AnimationProcessingTarget Engine::animationProcessingTarget = Engine::AnimationProcessingTarget::CPU;
EZRShader* Engine::ezrShader = nullptr;
ShadowMapCreationShader* Engine::shadowMappingShaderPre = nullptr;
ShadowMapRenderShader* Engine::shadowMappingShaderRender = nullptr;
LightingShader* Engine::lightingShader = nullptr;
ParticlesShader* Engine::particlesShader = nullptr;
LinesShader* Engine::linesShader = nullptr;
SkinningShader* Engine::skinningShader = nullptr;
GUIShader* Engine::guiShader = nullptr;
Engine* Engine::currentEngine = nullptr;
bool Engine::skinningShaderEnabled = false;
int Engine::threadCount = 0;
bool Engine::have4K = false;
float Engine::animationBlendingTime = 250.0f;
int32_t Engine::shadowMapWidth = 0;
int32_t Engine::shadowMapHeight = 0;
int32_t Engine::shadowMapRenderLookUps = 0;
int32_t Engine::environmentMappingWidth = 1024;
int32_t Engine::environmentMappingHeight = 1024;
float Engine::transformationsComputingReduction1Distance = 25.0f;
float Engine::transformationsComputingReduction2Distance = 50.0f;
map<string, Engine::Shader> Engine::shaders;
unordered_map<string, uint8_t> Engine::uniqueShaderIds;
 
vector<Engine::EngineThread*> Engine::engineThreads;
Queue<Engine::EngineThreadQueueElement>* Engine::engineThreadsQueue = nullptr;
Engine::EngineThreadQueueElementPool Engine::engineThreadQueueElementPool;
 
Engine::EngineThread::EngineThread(int idx, Queue<EngineThreadQueueElement>* queue):
    Thread("enginethread"),
    idx(idx),
    queue(queue) {
    //
    transparentRenderFacesPool = new TransparentRenderFacesPool();
}
 
void Engine::EngineThread::run() {
    Console::println("EngineThread::" + string(__FUNCTION__) + "()[" + to_string(idx) + "]: INIT");
    while (isStopRequested() == false) {
        auto element = queue->getElement();
        if (element == nullptr) continue;
        switch(element->type) {
            case EngineThreadQueueElement::TYPE_NONE:
                break;
            case EngineThreadQueueElement::TYPE_PRERENDER:
                element->engine->preRenderFunction(
                    element->objects,
                    idx
                );
                element->objects.clear();
                elementsProcessed++;
                break;
            case EngineThreadQueueElement::TYPE_TRANSFORMATIONS:
                element->engine->computeTransformationsFunction(
                    element->objects,
                    idx
                );
                element->objects.clear();
                elementsProcessed++;
                break;
            case EngineThreadQueueElement::TYPE_RENDERING:
                element->engine->entityRenderer->renderFunction(
                    idx,
                    element->rendering.renderPass,
                    element->objects,
                    objectsByShadersAndModels,
                    element->rendering.collectTransparentFaces,
                    element->rendering.renderTypes,
                    transparentRenderFacesPool
                );
                element->objects.clear();
                elementsProcessed++;
                break;
        }
    }
    Console::println("EngineThread::" + string(__FUNCTION__) + "()[" + to_string(idx) + "]: DONE");
}
 
Engine::Engine() {
    timing = new Timing();
    camera = nullptr;
    sceneColor.set(0.0f, 0.0f, 0.0f, 1.0f);
    frameBuffer = nullptr;
    // shadow mapping
    shadowMappingEnabled = false;
    shadowMapping = nullptr;
    // render process state
    renderingInitiated = false;
    renderingComputedTransformations = false;
    //
    initialized = false;
    // post processing frame buffers
    postProcessingFrameBuffer1 = nullptr;
    postProcessingFrameBuffer2 = nullptr;
    postProcessingTemporaryFrameBuffer = nullptr;
    //
    isUsingPostProcessingTemporaryFrameBuffer = false;
    //
    effectPassFrameBuffers.fill(nullptr);
    effectPassSkip.fill(false);
}
 
Engine::~Engine() {
    delete timing;
    delete camera;
    delete gui;
    delete partition;
    if (frameBuffer != nullptr) delete frameBuffer;
    if (postProcessingFrameBuffer1 != nullptr) delete postProcessingFrameBuffer1;
    if (postProcessingFrameBuffer2 != nullptr) delete postProcessingFrameBuffer2;
    if (postProcessingTemporaryFrameBuffer != nullptr) delete postProcessingTemporaryFrameBuffer;
    if (shadowMapping != nullptr) delete shadowMapping;
    delete entityRenderer;
    if (instance == this) {
        delete renderer;
        delete textureManager;
        delete vboManager;
        delete meshManager;
        delete guiRenderer;
        delete lightingShader;
        delete particlesShader;
        delete linesShader;
        delete frameBufferRenderShader;
        delete deferredLightingRenderShader;
        delete postProcessing;
        delete postProcessingShader;
        delete texture2DRenderShader;
        delete guiShader;
        delete ezrShader;
        delete shadowMappingShaderPre;
        delete shadowMappingShaderRender;
    }
    // set current engine
    if (currentEngine == this) currentEngine = nullptr;
}
 
Engine* Engine::createOffScreenInstance(int32_t width, int32_t height, bool enableShadowMapping, bool enableDepthBuffer, bool enableGeometryBuffer)
{
    if (instance == nullptr || instance->initialized == false) {
        Console::println(string("Engine::createOffScreenInstance(): Engine not created or not initialized."));
        return nullptr;
    }
    // create off screen engine
    auto offScreenEngine = new Engine();
    offScreenEngine->initialized = true;
    // create GUI
    offScreenEngine->gui = new GUI(offScreenEngine, guiRenderer);
    // create object 3d vbo renderer
    offScreenEngine->entityRenderer = new EntityRenderer(offScreenEngine, renderer);
    offScreenEngine->entityRenderer->initialize();
    // TODO: geometry buffer
    // create framebuffers
    offScreenEngine->frameBuffer = new FrameBuffer(width, height, (enableDepthBuffer == true?FrameBuffer::FRAMEBUFFER_DEPTHBUFFER:0) | FrameBuffer::FRAMEBUFFER_COLORBUFFER);
    offScreenEngine->frameBuffer->initialize();
    // create camera, frustum partition
    offScreenEngine->camera = new Camera(renderer);
    offScreenEngine->partition = new OctTreePartition();
    // create lights
    for (auto i = 0; i < offScreenEngine->lights.size(); i++) {
        offScreenEngine->lights[i] = Light(renderer, i);
        offScreenEngine->lights[i].setSourceTexture(TextureReader::read("resources/engine/textures", "sun.png"));
    }
    // create shadow mapping
    if (instance->shadowMappingEnabled == true && enableShadowMapping == true) {
        offScreenEngine->shadowMapping = new ShadowMapping(offScreenEngine, renderer, offScreenEngine->entityRenderer);
    }
    // geometry buffer
    if (renderer->isDeferredShadingAvailable() == true && enableGeometryBuffer == true) {
        offScreenEngine->geometryBuffer = new GeometryBuffer(width, height);
        offScreenEngine->geometryBuffer->initialize();
    }
    //
    offScreenEngine->reshape(width, height);
    return offScreenEngine;
}
 
const string Engine::getGraphicsVendor() {
    return renderer->getVendor();
}
 
const string Engine::getGraphicsRenderer() {
    return renderer->getRenderer();
}
 
void Engine::setPartition(Partition* partition)
{
    if (this->partition != nullptr && this->partition != partition) delete this->partition;
    this->partition = partition;
}
 
void Engine::addEntity(Entity* entity)
{
    {
        auto entityByIdIt = entitiesById.find(entity->getId());
        if (entityByIdIt != entitiesById.end()) {
            // check if we want to add this entity a second time
            if (entity == entityByIdIt->second) {
                Console::println("Engine::addEntity(): " + entity->getId() + ": entity already added!");
                return;
            }
            // dispose old entity if any did exist in engine with same id
            removeEntity(entity->getId());
        }
    }
 
    // init entity
    entity->setEngine(this);
    entity->setRenderer(renderer);
    entity->initialize();
    entitiesById[entity->getId()] = entity;
 
    // add to partition if enabled and frustum culling requested
    if (entity->isFrustumCulling() == true && entity->isEnabled() == true) partition->addEntity(entity);
 
    // update
    registerEntity(entity);
}
 
void Engine::deregisterEntity(Entity* entity) {
    //
    noFrustumCullingEntities.erase(entity);
    visibleDecomposedEntities.noFrustumCullingEntities.erase(
        remove(
            visibleDecomposedEntities.noFrustumCullingEntities.begin(),
            visibleDecomposedEntities.noFrustumCullingEntities.end(), entity
        ),
        visibleDecomposedEntities.noFrustumCullingEntities.end());
    autoEmitParticleSystemEntities.erase(entity);
    needsComputeTransformationsEntities.erase(entity);
    needsPreRenderEntities.erase(entity);
}
 
void Engine::registerEntity(Entity* entity) {
    //
    noFrustumCullingEntities.erase(entity);
    visibleDecomposedEntities.noFrustumCullingEntities.erase(
        remove(
            visibleDecomposedEntities.noFrustumCullingEntities.begin(),
            visibleDecomposedEntities.noFrustumCullingEntities.end(),
            entity
        ),
        visibleDecomposedEntities.noFrustumCullingEntities.end()
    );
    autoEmitParticleSystemEntities.erase(entity);
 
    // add to no frustum culling
    if (entity->isFrustumCulling() == false && entity->getParentEntity() == nullptr) {
        // otherwise add to no frustum culling entities
        noFrustumCullingEntities.insert(entity);
        visibleDecomposedEntities.noFrustumCullingEntities.push_back(entity);
    }
 
    // add to auto emit particle system entities
    auto particleSystemEntity = dynamic_cast<ParticleSystemEntity*>(entity);
    if (particleSystemEntity != nullptr && particleSystemEntity->isAutoEmit() == true) {
        autoEmitParticleSystemEntities.insert(particleSystemEntity);
    }
 
    // decompose to Object3D instances to do pre render
    DecomposedEntities decomposedEntities;
    decomposeEntityType(entity, decomposedEntities, true);
    array<vector<Object3D*>, 5> objectsArray = {
        decomposedEntities.ezrObjects,
        decomposedEntities.objects,
        decomposedEntities.objectsForwardShading,
        decomposedEntities.objectsNoDepthTest,
        decomposedEntities.objectsPostPostProcessing,
    };
    for (auto& objects: objectsArray) {
        for (auto object3D: objects) {
            object3D->preRender(renderer->CONTEXTINDEX_DEFAULT);
            if (object3D->isNeedsPreRender() == true) needsPreRenderEntities.insert(object3D);
            if (object3D->isNeedsComputeTransformations() == true) needsComputeTransformationsEntities.insert(object3D);
        }
    }
}
 
bool Engine::removeEntity(const string& id)
{
    // get entity and remove if we have any
    auto entityByIdIt = entitiesById.find(id);
    if (entityByIdIt == entitiesById.end()) return false;
 
    //
    auto entity = entityByIdIt->second;
 
    //
    entitiesById.erase(entityByIdIt);
    autoEmitParticleSystemEntities.erase(entity);
    noFrustumCullingEntities.erase(entity);
    needsPreRenderEntities.erase(entity);
    needsComputeTransformationsEntities.erase(entity);
 
    // remove from partition if enabled and frustum culling requested
    if (entity->isFrustumCulling() == true && entity->isEnabled() == true) partition->removeEntity(entity);
 
    //
    removeEntityFromLists(entity);
 
    // dispose entity
    entity->dispose();
    entity->setEngine(nullptr);
    entity->setRenderer(nullptr);
    delete entity;
 
    //
    return true;
}
 
inline void Engine::removeFromDecomposedEntities(DecomposedEntities& decomposedEntities, Entity* entity) {
    // delete from lists
    decomposedEntities.objects.erase(
        remove(
            decomposedEntities.objects.begin(),
            decomposedEntities.objects.end(),
            entity
        ),
        decomposedEntities.objects.end()
    );
    decomposedEntities.objectsForwardShading.erase(
        remove(
            decomposedEntities.objectsForwardShading.begin(),
            decomposedEntities.objectsForwardShading.end(),
            entity
        ),
        decomposedEntities.objectsForwardShading.end()
    );
    decomposedEntities.objectsPostPostProcessing.erase(
        remove(
            decomposedEntities.objectsPostPostProcessing.begin(),
            decomposedEntities.objectsPostPostProcessing.end(),
            entity
        ),
        decomposedEntities.objectsPostPostProcessing.end()
    );
    decomposedEntities.objectsNoDepthTest.erase(
        remove(
            decomposedEntities.objectsNoDepthTest.begin(),
            decomposedEntities.objectsNoDepthTest.end(),
            entity
        ),
        decomposedEntities.objectsNoDepthTest.end()
    );
    decomposedEntities.lodObjects.erase(
        remove(
            decomposedEntities.lodObjects.begin(),
            decomposedEntities.lodObjects.end(),
            entity
        ),
        decomposedEntities.lodObjects.end()
    );
    decomposedEntities.opses.erase(
        remove(
            decomposedEntities.opses.begin(),
            decomposedEntities.opses.end(),
            entity
        ),
        decomposedEntities.opses.end()
    );
    decomposedEntities.ppses.erase(
        remove(
            decomposedEntities.ppses.begin(),
            decomposedEntities.ppses.end(),
            entity
        ),
        decomposedEntities.ppses.end()
    );
    decomposedEntities.psgs.erase(
        remove(
            decomposedEntities.psgs.begin(),
            decomposedEntities.psgs.end(),
            entity
        ),
        decomposedEntities.psgs.end()
    );
    decomposedEntities.linesObjects.erase(
        remove(
            decomposedEntities.linesObjects.begin(),
            decomposedEntities.linesObjects.end(),
            entity
        ),
        decomposedEntities.linesObjects.end()
    );
    decomposedEntities.objectRenderGroups.erase(
        remove(
            decomposedEntities.objectRenderGroups.begin(),
            decomposedEntities.objectRenderGroups.end(),
            entity
        ),
        decomposedEntities.objectRenderGroups.end()
    );
    decomposedEntities.entityHierarchies.erase(
        remove(
            decomposedEntities.entityHierarchies.begin(),
            decomposedEntities.entityHierarchies.end(),
            entity
        ),
        decomposedEntities.entityHierarchies.end()
    );
    decomposedEntities.ezrObjects.erase(
        remove(
            decomposedEntities.ezrObjects.begin(),
            decomposedEntities.ezrObjects.end(),
            entity
        ),
        decomposedEntities.ezrObjects.end()
    );
    decomposedEntities.noFrustumCullingEntities.erase(
        remove(
            decomposedEntities.noFrustumCullingEntities.begin(),
            decomposedEntities.noFrustumCullingEntities.end(),
            entity
        ),
        decomposedEntities.noFrustumCullingEntities.end()
    );
    decomposedEntities.environmentMappingEntities.erase(
        remove(
            decomposedEntities.environmentMappingEntities.begin(),
            decomposedEntities.environmentMappingEntities.end(),
            entity
        ),
        decomposedEntities.environmentMappingEntities.end()
    );
    decomposedEntities.needsPreRenderEntities.erase(
        remove(
            decomposedEntities.needsPreRenderEntities.begin(),
            decomposedEntities.needsPreRenderEntities.end(),
            entity
        ),
        decomposedEntities.needsPreRenderEntities.end()
    );
    decomposedEntities.needsComputeTransformationsEntities.erase(
        remove(
            decomposedEntities.needsComputeTransformationsEntities.begin(),
            decomposedEntities.needsComputeTransformationsEntities.end(),
            entity
        ),
        decomposedEntities.needsComputeTransformationsEntities.end()
    );
}
 
void Engine::removeEntityFromLists(Entity* entity)
{
    if (entity == nullptr) return;
    //
    removeFromDecomposedEntities(visibleDecomposedEntities, entity);
    if (entity->getEntityType() == Entity::ENTITYTYPE_OBJECT3DRENDERGROUP) {
        removeEntityFromLists(static_cast<Object3DRenderGroup*>(entity)->getEntity());
    } else
    if (entity->getEntityType() == Entity::ENTITYTYPE_OBJECTPARTICLESYSTEM) {
        auto ops = static_cast<ObjectParticleSystem*>(entity);
        for (auto subEntity: ops->getObjects()) {
            removeEntityFromLists(subEntity);
        }
    } else
    if (entity->getEntityType() == Entity::ENTITYTYPE_ENTITYHIERARCHY) {
        auto eh = static_cast<EntityHierarchy*>(entity);
        for (auto subEntity: eh->getEntities()) {
            removeEntityFromLists(subEntity);
        }
    } else
    if (entity->getEntityType() == Entity::ENTITYTYPE_LODOBJECT3D) {
        auto lob3d = static_cast<LODObject3D*>(entity);
        removeEntityFromLists(lob3d->getLOD1Object());
        removeEntityFromLists(lob3d->getLOD2Object());
        removeEntityFromLists(lob3d->getLOD3Object());
    } else
    if (entity->getEntityType() == Entity::ENTITYTYPE_IMPOSTEROBJECT3D) {
        auto io3d = static_cast<ImposterObject3D*>(entity);
        for (auto subEntity: io3d->getBillboardObjects()) removeEntityFromLists(subEntity);
    } else
    if (entity->getEntityType() == Entity::ENTITYTYPE_LODOBJECT3DIMPOSTER) {
        auto lob3dImposter = static_cast<LODObject3DImposter*>(entity);
        removeEntityFromLists(lob3dImposter->getLOD1Object());
        for (auto subEntity: lob3dImposter->getLOD2Object()->getBillboardObjects()) removeEntityFromLists(subEntity);
    }
}
 
void Engine::reset()
{
    vector<string> entitiesToRemove;
    for (auto it: entitiesById) {
        auto entityKey = it.first;
        entitiesToRemove.push_back(entityKey);
    }
    for (auto entityKey: entitiesToRemove) {
        removeEntity(entityKey);
    }
    partition->reset();
    entityRenderer->reset();
    if (skinningShaderEnabled == true) skinningShader->reset();
    // TODO: reset engine thread queue element pool
}
 
void Engine::initialize()
{
    // set current engine
    currentEngine = this;
 
    // exit if already initialized like a offscreen engine instance
    if (initialized == true)
        return;
 
    //
    renderer = Application::getRenderer();
    if (renderer == nullptr) {
        initialized = false;
        Console::println("No renderer: Exiting!");
        Application::exit(0);
        return;
    }
 
    shadowMappingEnabled = true;
    if (getShadowMapWidth() == 0 || getShadowMapHeight() == 0) setShadowMapSize(2048, 2048);
    if (getShadowMapRenderLookUps() == 0) setShadowMapRenderLookUps(8);
    shadowMappingEnabled = renderer->isBufferObjectsAvailable() == true && renderer->isDepthTextureAvailable() == true;
    animationProcessingTarget = renderer->isGLCLAvailable() == true || renderer->isComputeShaderAvailable() == true?Engine::AnimationProcessingTarget::GPU:Engine::AnimationProcessingTarget::CPU;
 
    // determine if we have the skinning compute shader or OpenCL program
    skinningShaderEnabled = renderer->isComputeShaderAvailable() == true || renderer->isGLCLAvailable() == true;
    animationProcessingTarget = skinningShaderEnabled == true?Engine::AnimationProcessingTarget::GPU:Engine::AnimationProcessingTarget::CPU;
 
    // engine thread count
    if (renderer->isSupportingMultithreadedRendering() == true) {
        if (threadCount == 0) threadCount = Math::clamp(Thread::getHardwareThreadCount() == 0?3:Thread::getHardwareThreadCount() / 2, 2, 3);
    } else {
        threadCount = 1;
    }
 
    Console::println(string("TDME2::Thread count: ") + to_string(threadCount));
 
    // initialize object buffers
    ObjectBuffer::initialize();
 
    // create manager
    textureManager = new TextureManager(renderer);
    vboManager = new VBOManager(renderer);
    meshManager = new MeshManager();
 
    // init
    initialized = true;
    renderer->initialize();
    renderer->initializeFrame();
 
    // graphics device
    Console::println(string("TDME2::Renderer::Graphics Vendor: ") + renderer->getVendor());
    Console::println(string("TDME2::Renderer::Graphics Renderer: ") + renderer->getRenderer());
 
    // create object 3d renderer
    entityRenderer = new EntityRenderer(this, renderer);
    entityRenderer->initialize();
    GUIParser::initialize();
 
    // create GUI
    guiRenderer = new GUIRenderer(renderer);
    guiRenderer->initialize();
    gui = new GUI(this, guiRenderer);
    gui->initialize();
 
    // create camera
    camera = new Camera(renderer);
 
    // create lights
    for (auto i = 0; i < lights.size(); i++) {
        lights[i] = Light(renderer, i);
        lights[i].setSourceTexture(TextureReader::read("resources/engine/textures", "sun.png"));
    }
 
    // create partition
    partition = new OctTreePartition();
 
    // create lighting shader
    lightingShader = new LightingShader(renderer);
    lightingShader->initialize();
 
    // create particles shader
    particlesShader = new ParticlesShader(this, renderer);
    particlesShader->initialize();
 
    // create particles shader
    linesShader = new LinesShader(this, renderer);
    linesShader->initialize();
 
    // create gui shader
    guiShader = new GUIShader(renderer);
    guiShader->initialize();
 
    // create frame buffer render shader
    frameBufferRenderShader = new FrameBufferRenderShader(renderer);
    frameBufferRenderShader->initialize();
 
    // deferred lighting render shader
    if (renderer->isDeferredShadingAvailable() == true) {
        deferredLightingRenderShader = new DeferredLightingRenderShader(renderer);
        deferredLightingRenderShader->initialize();
    }
 
    // create post processing shader
    postProcessingShader = new PostProcessingShader(renderer);
    postProcessingShader->initialize();
 
    // create post processing
    postProcessing = new PostProcessing();
 
    // create post processing shader
    texture2DRenderShader = new Texture2DRenderShader(renderer);
    texture2DRenderShader->initialize();
 
    // check if VBOs are available
    if (renderer->isBufferObjectsAvailable()) {
        Console::println("TDME2::VBOs are available.");
    } else {
        Console::println("TDME2::VBOs are not available! Engine will not work!");
        initialized = false;
    }
 
    // check FBO support
    if (true == false/*glContext->hasBasicFBOSupport() == false*/) {
        Console::println("TDME2::Basic FBOs are not available!");
        shadowMappingEnabled = false;
    } else {
        Console::println("TDME2::Basic FBOs are available.");
    }
 
    // TODO: make this configurable
    ezrShader = new EZRShader(renderer);
    ezrShader->initialize();
 
    // initialize shadow mapping
    if (shadowMappingEnabled == true) {
        Console::println("TDME2::Using shadow mapping");
        shadowMappingShaderPre = new ShadowMapCreationShader(renderer);
        shadowMappingShaderPre->initialize();
        shadowMappingShaderRender = new ShadowMapRenderShader(renderer);
        shadowMappingShaderRender->initialize();
        shadowMapping = new ShadowMapping(this, renderer, entityRenderer);
    } else {
        Console::println("TDME2::Not using shadow mapping");
    }
 
    // initialize skinning shader
    if (skinningShaderEnabled == true) {
        Console::println("TDME2::Using skinning compute shader");
        skinningShader = new SkinningShader(renderer);
        skinningShader->initialize();
    } else {
        Console::println("TDME2::Not using skinning compute shader");
    }
 
    #define CHECK_INITIALIZED(NAME, SHADER) if (SHADER != nullptr && SHADER->isInitialized() == false) Console::println(string("TDME: ") + NAME + ": Not initialized")
 
    CHECK_INITIALIZED("EZRShader", ezrShader);
    CHECK_INITIALIZED("ShadowMapCreationShader", shadowMappingShaderPre);
    CHECK_INITIALIZED("ShadowMappingShader", shadowMappingShaderRender);
    CHECK_INITIALIZED("LightingShader", lightingShader);
    CHECK_INITIALIZED("ParticlesShader", particlesShader);
    CHECK_INITIALIZED("LinesShader", linesShader);
    CHECK_INITIALIZED("GUIShader", guiShader);
    CHECK_INITIALIZED("FrameBufferRenderShader", frameBufferRenderShader);
    CHECK_INITIALIZED("DeferredLightingRenderShader", deferredLightingRenderShader);
    CHECK_INITIALIZED("PostProcessingShader", postProcessingShader);
    CHECK_INITIALIZED("Texture2DRenderShader", texture2DRenderShader);
 
    // check if initialized
    // initialized &= objectsFrameBuffer->isInitialized();
    initialized &= ezrShader == nullptr ? true : ezrShader->isInitialized();
    initialized &= shadowMappingShaderPre == nullptr ? true : shadowMappingShaderPre->isInitialized();
    initialized &= shadowMappingShaderRender == nullptr ? true : shadowMappingShaderRender->isInitialized();
    initialized &= lightingShader->isInitialized();
    initialized &= particlesShader->isInitialized();
    initialized &= linesShader->isInitialized();
    initialized &= guiShader->isInitialized();
    initialized &= frameBufferRenderShader->isInitialized();
    initialized &= deferredLightingRenderShader != nullptr?deferredLightingRenderShader->isInitialized():true;
    initialized &= postProcessingShader->isInitialized();
    initialized &= texture2DRenderShader->isInitialized();
 
    // deferred shading
    if (renderer->isDeferredShadingAvailable() == true) {
        Console::println("TDME2::Using deferred shading");
    } else {
        Console::println("TDME2::Not using deferred shading");
    }
 
    //
    Console::println(string("TDME2::initialized & ready: ") + to_string(initialized));
 
    // shut down engine if not initialized
    if (initialized == false) {
        Console::println("Engine not initialized: Exiting!");
        Application::exit(0);
        return;
    }
 
    //
    if (renderer->isSupportingMultithreadedRendering() == true) {
        engineThreadsQueue = new Queue<Engine::EngineThreadQueueElement>(0);
        engineThreads.resize(threadCount - 1);
        for (auto i = 0; i < threadCount - 1; i++) {
            engineThreads[i] = new EngineThread(
                i + 1,
                engineThreadsQueue
            );
            engineThreads[i]->start();
        }
    }
 
    // show registered shaders
    dumpShaders();
}
 
void Engine::reshape(int32_t width, int32_t height)
{
    // apparently windows sends 0x0 dimension if windows gets minimized
    if (width == 0 && height == 0) return;
 
    // set current engine
    currentEngine = this;
 
    // update our width and height
    this->width = width;
    this->height = height;
 
    //
    int _width = scaledWidth != -1?scaledWidth:width;
    int _height = scaledHeight != -1?scaledHeight:height;
 
    // update frame buffer if we have one
    if (frameBuffer != nullptr) frameBuffer->reshape(_width, _height);
 
    // update post processing frame buffer if we have one
    if (postProcessingFrameBuffer1 != nullptr) postProcessingFrameBuffer1->reshape(_width, _height);
    if (postProcessingFrameBuffer2 != nullptr) postProcessingFrameBuffer2->reshape(_width, _height);
    if (postProcessingTemporaryFrameBuffer != nullptr) postProcessingTemporaryFrameBuffer->reshape(_width, _height);
    if (postProcessingTemporaryFrameBuffer != nullptr) postProcessingTemporaryFrameBuffer->reshape(_width, _height);
    if (postProcessingTemporaryFrameBuffer != nullptr) postProcessingTemporaryFrameBuffer->reshape(_width, _height);
 
    // update shadow mapping
    if (shadowMapping != nullptr) shadowMapping->reshape(width, height);
 
    // unset scaling frame buffer if width and height matches scaling
    if (this == Engine::instance && scaledWidth != -1 && scaledHeight != -1) {
        if (this->width == scaledWidth && this->height == scaledHeight) {
            if (frameBuffer != nullptr) frameBuffer->dispose();
            frameBuffer = nullptr;
        } else {
            if (frameBuffer == nullptr) {
                frameBuffer = new FrameBuffer(_width, _height, FrameBuffer::FRAMEBUFFER_DEPTHBUFFER | FrameBuffer::FRAMEBUFFER_COLORBUFFER);
                frameBuffer->initialize();
            } else {
                frameBuffer->reshape(_width, _height);
            }
        }
    }
 
    // create geometry buffer if available
    if (renderer->isDeferredShadingAvailable() == true) {
        if (geometryBuffer == nullptr) {
            geometryBuffer = new GeometryBuffer(_width, _height);
            geometryBuffer->initialize();
        } else {
            geometryBuffer->reshape(_width, _height);
        }
    }
 
    // update GUI system
    gui->reshape(width, height);
}
 
void Engine::scale(int32_t width, int32_t height)
{
    if (this != Engine::instance) return;
    scaledWidth = width;
    scaledHeight = height;
    if (frameBuffer != nullptr) frameBuffer->dispose();
    frameBuffer = nullptr;
    if (scaledWidth != this->width || scaledHeight != this->height) {
        frameBuffer = new FrameBuffer(scaledWidth, scaledHeight, FrameBuffer::FRAMEBUFFER_DEPTHBUFFER | FrameBuffer::FRAMEBUFFER_COLORBUFFER);
        frameBuffer->initialize();
    }
    reshape(this->width, this->height);
}
 
void Engine::unscale()
{
    scaledWidth = -1;
    scaledHeight = -1;
    if (frameBuffer != nullptr) frameBuffer->dispose();
    frameBuffer = nullptr;
    reshape(this->width, this->height);
}
 
void Engine::renderToScreen() {
    if (this == Engine::instance && frameBuffer != nullptr) frameBuffer->renderToScreen(this);
}
 
void Engine::resetLists(DecomposedEntities& decomposedEntites) {
    // clear lists of visible objects
    decomposedEntites.objects.clear();
    decomposedEntites.objectsForwardShading.clear();
    decomposedEntites.objectsPostPostProcessing.clear();
    decomposedEntites.objectsNoDepthTest.clear();
    decomposedEntites.lodObjects.clear();
    decomposedEntites.opses.clear();
    decomposedEntites.ppses.clear();
    decomposedEntites.psgs.clear();
    decomposedEntites.linesObjects.clear();
    decomposedEntites.objectRenderGroups.clear();
    decomposedEntites.entityHierarchies.clear();
    decomposedEntites.ezrObjects.clear();
    decomposedEntites.noFrustumCullingEntities.clear();
    decomposedEntites.environmentMappingEntities.clear();
    decomposedEntites.needsPreRenderEntities.clear();
    decomposedEntites.needsComputeTransformationsEntities.clear();
}
 
void Engine::initRendering()
{
    // update timing
    timing->updateTiming();
 
    //
    resetLists(visibleDecomposedEntities);
 
    //
    renderingInitiated = true;
}
 
void Engine::preRenderFunction(vector<Object3D*>& objects, int threadIdx) {
    for (auto object: objects) object->preRender(threadIdx);
}
 
void Engine::computeTransformationsFunction(vector<Object3D*>& objects, int threadIdx) {
    for (auto object: objects) object->computeTransformations(threadIdx);
}
 
inline void Engine::decomposeEntityType(Entity* entity, DecomposedEntities& decomposedEntities, bool decomposeAllEntities) {
    switch (entity->getEntityType()) {
        case Entity::ENTITYTYPE_OBJECT3D:
            {
                auto object = static_cast<Object3D*>(entity);
                if (object->isDisableDepthTest() == true) {
                    decomposedEntities.objectsNoDepthTest.push_back(object);
                } else
                if (object->getRenderPass() == Entity::RENDERPASS_POST_POSTPROCESSING) {
                    decomposedEntities.objectsPostPostProcessing.push_back(object);
                } else
                if (object->isNeedsForwardShading() == true &&
                    (object->getRenderPass() == Entity::RENDERPASS_TERRAIN || object->getRenderPass() == Entity::RENDERPASS_STANDARD) &&
                    renderer->isDeferredShadingAvailable() == true) {
                    decomposedEntities.objectsForwardShading.push_back(object);
                } else {
                    decomposedEntities.objects.push_back(object);
                }
                if (object->isEnableEarlyZRejection() == true) {
                    decomposedEntities.ezrObjects.push_back(object);
                }
            }
            break;
        case Entity::ENTITYTYPE_LODOBJECT3D:
            {
                auto lodObject = static_cast<LODObject3D*>(entity);
                if (decomposeAllEntities == true) {
                    auto lod1Object = lodObject->getLOD1Object();
                    auto lod2Object = lodObject->getLOD2Object();
                    auto lod3Object = lodObject->getLOD3Object();
                    if (lod1Object != nullptr) decomposeEntityType(lod1Object, decomposedEntities);
                    if (lod2Object != nullptr) decomposeEntityType(lod2Object, decomposedEntities);
                    if (lod3Object != nullptr) decomposeEntityType(lod3Object, decomposedEntities);
                } else {
                    auto object = lodObject->determineLODObject(camera);
                    if (object != nullptr) decomposeEntityType(object, decomposedEntities, decomposeAllEntities);
                }
            }
            break;
        case Entity::ENTITYTYPE_IMPOSTEROBJECT3D:
            {
                auto imposterObject = static_cast<ImposterObject3D*>(entity);
                if (decomposeAllEntities == true) {
                    for (auto subEntity: imposterObject->getBillboardObjects()) decomposeEntityType(subEntity, decomposedEntities);
                } else {
                    decomposeEntityType(imposterObject->determineBillboardObject(camera), decomposedEntities, decomposeAllEntities);
                }
            }
            break;
        case Entity::ENTITYTYPE_LODOBJECT3DIMPOSTER:
            {
                auto lodObjectImposter = static_cast<LODObject3DImposter*>(entity);
                if (decomposeAllEntities == true) {
                    decomposeEntityType(lodObjectImposter->getLOD1Object(), decomposedEntities);
                    for (auto subEntity: lodObjectImposter->getLOD2Object()->getBillboardObjects()) decomposeEntityType(subEntity, decomposedEntities);
                } else {
                    auto object = lodObjectImposter->determineLODObject(camera);
                    if (object != nullptr) decomposeEntityType(object, decomposedEntities, decomposeAllEntities);
                }
            }
            break;
        case Entity::ENTITYTYPE_OBJECTPARTICLESYSTEM:
            {
                auto opse = static_cast<ObjectParticleSystem*>(entity);
                if (decomposeAllEntities == true) {
                    for (auto object: opse->getObjects()) decomposeEntityType(object, decomposedEntities, decomposeAllEntities);
                } else {
                    for (auto object: opse->getEnabledObjects()) decomposeEntityType(object, decomposedEntities, decomposeAllEntities);
                }
                decomposedEntities.opses.push_back(opse);
            }
            break;
        case Entity::ENTITYTYPE_POINTSPARTICLESYSTEM:
            {
                auto ppse = static_cast<PointsParticleSystem*>(entity);
                decomposedEntities.ppses.push_back(ppse);
            }
            break;
        case Entity::ENTITYTYPE_FOGPARTICLESYSTEM:
            {
                auto fpse = static_cast<FogParticleSystem*>(entity);
                decomposedEntities.ppses.push_back(fpse);
            }
            break;
        case Entity::ENTITYTYPE_LINESOBJECT3D:
            {
                auto lo = static_cast<LinesObject3D*>(entity);
                decomposedEntities.linesObjects.push_back(lo);
            }
            break;
        case Entity::ENTITYTYPE_ENVIRONMENTMAPPING:
            {
                auto eme = static_cast<EnvironmentMapping*>(entity);
                decomposedEntities.environmentMappingEntities.push_back(eme);
            }
            break;
        case Entity::ENTITYTYPE_OBJECT3DRENDERGROUP:
            {
                auto org = static_cast<Object3DRenderGroup*>(entity);
                decomposedEntities.objectRenderGroups.push_back(org);
                auto subEntity = org->getEntity();
                if (subEntity != nullptr) decomposeEntityType(subEntity, decomposedEntities, decomposeAllEntities);
            }
            break;
        case Entity::ENTITYTYPE_PARTICLESYSTEMGROUP:
            {
                auto psg = static_cast<ParticleSystemGroup*>(entity);
                decomposedEntities.psgs.push_back(psg); \
                for (auto ps: psg->getParticleSystems()) decomposeEntityType(ps, decomposedEntities, decomposeAllEntities);
            }
            break;
        case Entity::ENTITYTYPE_ENTITYHIERARCHY:
            {
                auto eh = static_cast<EntityHierarchy*>(entity);
                decomposedEntities.entityHierarchies.push_back(eh);
                for (auto entityEh: eh->getEntities()) {
                    if (entityEh->isEnabled() == false && decomposeAllEntities == false) continue;
                    decomposeEntityType(entityEh, decomposedEntities, decomposeAllEntities);
                }
            }
 
        default:
            break;
    }
}
 
inline void Engine::decomposeEntityTypes(const vector<Entity*>& entities, DecomposedEntities& decomposedEntities, bool decomposeAllEntities) {
    for (auto entity: entities) {
        decomposeEntityType(entity, decomposedEntities, decomposeAllEntities);
    }
}
 
void Engine::computeTransformations(Camera* camera, DecomposedEntities& decomposedEntities, bool autoEmit, bool computeTransformations)
{
    // do particle systems auto emit
    if (autoEmit == true) {
        for (auto entity: autoEmitParticleSystemEntities) {
            auto pse = static_cast<ParticleSystemEntity*>(entity);
 
            // skip on disabled entities
            if (pse->isEnabled() == false) continue;
 
            // do auto emit
            pse->emitParticles();
            pse->updateParticles();
        }
    }
 
    // determine entity types and store them
    decomposeEntityTypes(
        partition->getVisibleEntities(camera->getFrustum()),
        decomposedEntities
    );
 
    // pre render
    for (auto entity: needsPreRenderEntities) {
        // skip on disabled entities
        if (partition->isVisibleEntity(entity) == false) continue;
        //
        decomposedEntities.needsPreRenderEntities.push_back(static_cast<Object3D*>(entity));
    }
 
    // compute transformations
    if (computeTransformations == true) {
        for (auto entity: needsComputeTransformationsEntities) {
            // skip on disabled entities
            if (partition->isVisibleEntity(entity) == false) continue;
            //
            decomposedEntities.needsComputeTransformationsEntities.push_back(static_cast<Object3D*>(entity));
        }
    }
 
    // collect entities that do not have frustum culling enabled
    for (auto entity: noFrustumCullingEntities) {
        // skip on disabled entities
        if (entity->isEnabled() == false) continue;
 
        //
        decomposedEntities.noFrustumCullingEntities.push_back(entity);
    }
 
    // determine additional entity types for objects without frustum culling
    decomposeEntityTypes(
        decomposedEntities.noFrustumCullingEntities,
        decomposedEntities
    );
 
    //
    if (skinningShaderEnabled == true) skinningShader->useProgram();
    if (renderer->isSupportingMultithreadedRendering() == false) {
        //
        preRenderFunction(decomposedEntities.needsPreRenderEntities, 0);
        computeTransformationsFunction(decomposedEntities.needsComputeTransformationsEntities, 0);
    } else {
        auto elementsIssued = 0;
        auto queueElement = engineThreadQueueElementPool.allocate();
        queueElement->type = Engine::EngineThreadQueueElement::TYPE_PRERENDER;
        queueElement->engine = this;
        queueElement->transformations.computeTransformations = computeTransformations;
        for (auto i = 0; i < decomposedEntities.needsPreRenderEntities.size(); i++) {
            queueElement->objects.push_back(decomposedEntities.needsPreRenderEntities[i]);
            if (queueElement->objects.size() == Engine::ENGINETHREADSQUEUE_PRERENDER_DISPATCH_COUNT) {
                auto queueElementToSubmit = queueElement;
                queueElement = engineThreadQueueElementPool.allocate();
                queueElement->type = Engine::EngineThreadQueueElement::TYPE_PRERENDER;
                queueElement->engine = this;
                queueElement->transformations.computeTransformations = computeTransformations;
                elementsIssued++;
                engineThreadsQueue->addElement(queueElementToSubmit, false);
            }
        }
        if (queueElement->objects.empty() == false) {
            elementsIssued++;
            engineThreadsQueue->addElement(queueElement, false);
            queueElement = engineThreadQueueElementPool.allocate();
        }
        queueElement->type = Engine::EngineThreadQueueElement::TYPE_TRANSFORMATIONS;
        queueElement->engine = this;
        queueElement->transformations.computeTransformations = computeTransformations;
        for (auto i = 0; i < decomposedEntities.needsComputeTransformationsEntities.size(); i++) {
            queueElement->objects.push_back(decomposedEntities.needsComputeTransformationsEntities[i]);
            if (queueElement->objects.size() == Engine::ENGINETHREADSQUEUE_COMPUTE_DISPATCH_COUNT) {
                auto queueElementToSubmit = queueElement;
                queueElement = engineThreadQueueElementPool.allocate();
                queueElement->type = Engine::EngineThreadQueueElement::TYPE_TRANSFORMATIONS;
                queueElement->engine = this;
                queueElement->transformations.computeTransformations = computeTransformations;
                elementsIssued++;
                engineThreadsQueue->addElement(queueElementToSubmit, false);
            }
        }
        if (queueElement->objects.empty() == false) {
            elementsIssued++;
            engineThreadsQueue->addElement(queueElement, false);
            queueElement = nullptr;
        }
 
        // wait until all elements have been processed
        while (true == true) {
            auto elementsProcessed = 0;
            for (auto engineThread: Engine::engineThreads) elementsProcessed+= engineThread->getProcessedElements();
            if (elementsProcessed == elementsIssued) {
                for (auto engineThread: Engine::engineThreads) engineThread->resetProcessedElements();
                break;
            }
        }
        // reset pool
        engineThreadQueueElementPool.reset();
    }
 
    //
    if (skinningShaderEnabled == true) {
        skinningShader->unUseProgram();
    }
 
    //
    renderingComputedTransformations = true;
}
 
void Engine::display()
{
    // set current engine
    currentEngine = this;
 
    // execute enqueued actions
    for (auto action: actions) {
        action->performAction();
        delete action;
    }
    actions.clear();
 
    // finish last frame
    if (this == Engine::instance) Engine::renderer->finishFrame();
 
    // init frame
    if (this == Engine::instance) Engine::renderer->initializeFrame();
 
    //
    initRendering();
 
    // default context
    auto _width = scaledWidth != -1?scaledWidth:width;
    auto _height = scaledHeight != -1?scaledHeight:height;
 
    // camera
    camera->update(renderer->CONTEXTINDEX_DEFAULT, _width, _height);
    // frustum
    camera->getFrustum()->update();
 
    // clear pre render states
    renderingComputedTransformations = false;
 
    // do pre rendering steps
    computeTransformations(camera, visibleDecomposedEntities, true, true);
 
    // render environment maps
    for (auto environmentMappingEntity: visibleDecomposedEntities.environmentMappingEntities) environmentMappingEntity->render();
 
    // camera
    camera->update(renderer->CONTEXTINDEX_DEFAULT, _width, _height);
 
    // create shadow maps
    if (shadowMapping != nullptr) shadowMapping->createShadowMaps();
 
    // do post processing programs effect passes
    array<bool, EFFECTPASS_COUNT - 1> effectPassFrameBuffersInUse;
    effectPassFrameBuffersInUse.fill(false);
    effectPassSkip.fill(false);
    for (auto programId: postProcessingPrograms) {
        auto program = postProcessing->getPostProcessingProgram(programId);
        if (program == nullptr) continue;
        for (auto& effectPass: program->getEffectPasses()) {
            auto effectPassIdx = effectPass.effectPassIdx;
            auto frameBufferIdx = effectPass.effectPassIdx - 1;
            auto frameBufferWidth = _width / effectPass.frameBufferWidthDivideFactor;
            auto frameBufferHeight = _height / effectPass.frameBufferHeightDivideFactor;
            if (effectPassFrameBuffers[frameBufferIdx] == nullptr) {
                effectPassFrameBuffers[frameBufferIdx] = new FrameBuffer(frameBufferWidth, frameBufferHeight, FrameBuffer::FRAMEBUFFER_COLORBUFFER); // TODO: types of buffers
                effectPassFrameBuffers[frameBufferIdx]->initialize();
            } else
            if (effectPassFrameBuffers[frameBufferIdx]->getWidth() != frameBufferWidth ||
                effectPassFrameBuffers[frameBufferIdx]->getHeight() != frameBufferHeight) {
                effectPassFrameBuffers[frameBufferIdx]->reshape(frameBufferWidth, frameBufferHeight);
            }
            effectPassFrameBuffersInUse[frameBufferIdx] = true;
            // enable
            effectPassFrameBuffers[frameBufferIdx]->enableFrameBuffer();
            // clear
            Engine::renderer->setClearColor(
                effectPass.clearColor.getRed(),
                effectPass.clearColor.getGreen(),
                effectPass.clearColor.getBlue(),
                effectPass.clearColor.getAlpha()
            );
            renderer->clear(renderer->CLEAR_COLOR_BUFFER_BIT);
            // camera
            camera->update(renderer->CONTEXTINDEX_DEFAULT, frameBufferWidth, frameBufferHeight);
            //
            auto lightSourceVisible = false;
            if (effectPass.renderLightSources == true) {
                lightSourceVisible = renderLightSources(frameBufferWidth, frameBufferHeight);
            }
            if (effectPass.skipOnLightSourceNotVisible == true && lightSourceVisible == false) {
                effectPassSkip[frameBufferIdx] = true;
            } else {
                // Do the effect render pass
                render(
                    effectPassFrameBuffers[frameBufferIdx],
                    nullptr, // TODO: we might want to use a deferred shading here for further effects
                    visibleDecomposedEntities,
                    effectPassIdx,
                    Entity::RENDERPASS_ALL,
                    effectPass.shaderPrefix,
                    false,
                    false,
                    false,
                    false,
                    false,
                    EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY |
                    EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY |
                    EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY
                );
            }
        }
    }
 
    // dispose effect pass frame buffers that we do not use anymore
    for (auto i = 0; i < effectPassFrameBuffersInUse.size(); i++) {
        if (effectPassFrameBuffersInUse[i] == false && effectPassFrameBuffers[i] != nullptr) {
            effectPassFrameBuffers[i]->dispose();
            delete effectPassFrameBuffers[i];
            effectPassFrameBuffers[i] = nullptr;
        }
    }
 
    // create post processing frame buffers if having post processing
    FrameBuffer* renderFrameBuffer = nullptr;
    if (postProcessingPrograms.size() > 0) {
        if (postProcessingFrameBuffer1 == nullptr) {
            postProcessingFrameBuffer1 = new FrameBuffer(_width, _height, FrameBuffer::FRAMEBUFFER_DEPTHBUFFER | FrameBuffer::FRAMEBUFFER_COLORBUFFER);
            postProcessingFrameBuffer1->initialize();
        }
        if (postProcessingFrameBuffer2 == nullptr) {
            postProcessingFrameBuffer2 = new FrameBuffer(_width, _height, FrameBuffer::FRAMEBUFFER_DEPTHBUFFER | FrameBuffer::FRAMEBUFFER_COLORBUFFER);
            postProcessingFrameBuffer2->initialize();
        }
        postProcessingFrameBuffer1->enableFrameBuffer();
        renderFrameBuffer = postProcessingFrameBuffer1;
    } else {
        if (postProcessingFrameBuffer1 != nullptr) {
            postProcessingFrameBuffer1->dispose();
            delete postProcessingFrameBuffer1;
            postProcessingFrameBuffer1 = nullptr;
        }
        if (postProcessingFrameBuffer2 != nullptr) {
            postProcessingFrameBuffer2->dispose();
            delete postProcessingFrameBuffer2;
            postProcessingFrameBuffer2 = nullptr;
        }
        // render objects to target frame buffer or screen
        if (frameBuffer != nullptr) {
            frameBuffer->enableFrameBuffer();
            renderFrameBuffer = frameBuffer;
        } else {
            FrameBuffer::disableFrameBuffer();
        }
    }
 
    // camera
    camera->update(renderer->CONTEXTINDEX_DEFAULT, _width, _height);
 
    // clear previous frame values
    Engine::renderer->setClearColor(sceneColor.getRed(), sceneColor.getGreen(), sceneColor.getBlue(), sceneColor.getAlpha());
    renderer->clear(renderer->CLEAR_DEPTH_BUFFER_BIT | renderer->CLEAR_COLOR_BUFFER_BIT);
 
    // do rendering
    render(
        renderFrameBuffer,
        geometryBuffer,
        visibleDecomposedEntities,
        EFFECTPASS_NONE,
        Entity::RENDERPASS_ALL,
        string(),
        true,
        true,
        true,
        true,
        true,
        EntityRenderer::RENDERTYPE_NORMALS |
            EntityRenderer::RENDERTYPE_TEXTUREARRAYS |
            EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY |
            EntityRenderer::RENDERTYPE_EFFECTCOLORS |
            EntityRenderer::RENDERTYPE_MATERIALS |
            EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY |
            EntityRenderer::RENDERTYPE_TEXTURES |
            EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY |
            EntityRenderer::RENDERTYPE_LIGHTS
    );
 
    // delete post processing termporary buffer if not required anymore
    if (isUsingPostProcessingTemporaryFrameBuffer == false && postProcessingTemporaryFrameBuffer != nullptr) {
        postProcessingTemporaryFrameBuffer->dispose();
        delete postProcessingTemporaryFrameBuffer;
        postProcessingTemporaryFrameBuffer = nullptr;
    }
 
    // clear pre render states
    renderingInitiated = false;
    renderingComputedTransformations = false;
 
    //
    if (frameBuffer != nullptr) {
        FrameBuffer::disableFrameBuffer();
    }
 
    // camera
    camera->update(renderer->CONTEXTINDEX_DEFAULT, _width, _height);
}
 
Vector3 Engine::computeWorldCoordinateByMousePosition(int32_t mouseX, int32_t mouseY, float z)
{
    auto scaleFactorWidth = static_cast<float>(scaledWidth != -1?scaledWidth:width) / static_cast<float>(width);
    auto scaleFactorHeight = static_cast<float>(scaledHeight != -1?scaledHeight:height) / static_cast<float>(height);
    auto _width = scaledWidth != -1?scaledWidth:width;
    auto _height = scaledHeight != -1?scaledHeight:height;
    // see: http://stackoverflow.com/questions/7692988/opengl-math-projecting-screen-space-to-world-space-coords-solved
    auto worldCoordinate4 = camera->getModelViewProjectionInvertedMatrix().multiply(
        Vector4(
            (2.0f * (mouseX * scaleFactorWidth) / _width) - 1.0f,
            1.0f - (2.0f * (mouseY * scaleFactorHeight) / _height),
            2.0f * z - 1.0f,
            1.0f
        )
    );
    worldCoordinate4.scale(1.0f / worldCoordinate4.getW());
    return Vector3(
        worldCoordinate4.getX(),
        worldCoordinate4.getY(),
        worldCoordinate4.getZ()
    );
}
 
Vector3 Engine::computeWorldCoordinateByMousePosition(int32_t mouseX, int32_t mouseY)
{
    // use framebuffer if we have one
    if (frameBuffer != nullptr)
        frameBuffer->enableFrameBuffer();
 
    //
    auto scaleFactorWidth = static_cast<float>(scaledWidth != -1?scaledWidth:width) / static_cast<float>(width);
    auto scaleFactorHeight = static_cast<float>(scaledHeight != -1?scaledHeight:height) / static_cast<float>(height);
 
    // see: http://stackoverflow.com/questions/7692988/opengl-math-projecting-screen-space-to-world-space-coords-solved
    auto z = renderer->readPixelDepth(mouseX * scaleFactorWidth, (height  - mouseY) * scaleFactorHeight);
 
    // unuse framebuffer if we have one
    if (frameBuffer != nullptr)
        FrameBuffer::disableFrameBuffer();
 
    //
    return computeWorldCoordinateByMousePosition(mouseX, mouseY, z);
}
 
Entity* Engine::getEntityByMousePosition(
    DecomposedEntities& decomposedEntities,
    bool forcePicking,
    int32_t mouseX,
    int32_t mouseY,
    EntityPickingFilter* filter,
    Node** object3DNode,
    ParticleSystemEntity** particleSystemEntity
) {
    // get world position of mouse position at near and far plane
    auto nearPlaneWorldCoordinate = computeWorldCoordinateByMousePosition(mouseX, mouseY, 0.0f);
    auto farPlaneWorldCoordinate = computeWorldCoordinateByMousePosition(mouseX, mouseY, 1.0f);
    Vector3 boundingBoxLineContactMin;
    Vector3 boundingBoxLineContactMax;
    Vector3 lineTriangleContact;
 
    // selected entity
    auto selectedEntityDistance = Float::MAX_VALUE;
    Entity* selectedEntity = nullptr;
    Node* selectedObject3DNode = nullptr;
    ParticleSystemEntity* selectedParticleSystem = nullptr;
 
    // iterate visible objects that have no depth test, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    for (auto entity: decomposedEntities.objectsNoDepthTest) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            for (auto it = entity->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                auto& vertices = it->next();
                if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], nearPlaneWorldCoordinate, farPlaneWorldCoordinate, lineTriangleContact) == true) {
                    auto entityDistance = lineTriangleContact.sub(nearPlaneWorldCoordinate).computeLengthSquared();
                    // check if match or better match
                    if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                        selectedEntity = entity;
                        selectedEntityDistance = entityDistance;
                        selectedObject3DNode = it->getNode();
                        selectedParticleSystem = nullptr;
                    }
                }
            }
        }
    }
    // they have first priority right now
    if (selectedEntity != nullptr) {
        if (object3DNode != nullptr) *object3DNode = selectedObject3DNode;
        for (auto _entity = selectedEntity; _entity != nullptr; _entity = _entity->getParentEntity()) {
            if (_entity->getParentEntity() == nullptr) return _entity;
        }
        return nullptr;
    }
 
    // iterate visible object partition systems, check if ray with given mouse position from near plane to far plane collides with bounding volume
    for (auto entity: decomposedEntities.opses) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto entityDistance = lineTriangleContact.set(entity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
            // check if match or better match
            if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                selectedEntity = entity;
                selectedEntityDistance = entityDistance;
                selectedObject3DNode = nullptr;
                selectedParticleSystem = nullptr;
            }
        }
    }
 
    // iterate visible point partition systems, check if ray with given mouse position from near plane to far plane collides with bounding volume
    for (auto entity: decomposedEntities.ppses) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto entityDistance = lineTriangleContact.set(entity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
            // check if match or better match
            if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                selectedEntity = entity;
                selectedEntityDistance = entityDistance;
                selectedObject3DNode = nullptr;
                selectedParticleSystem = nullptr;
            }
        }
    }
 
    // iterate visible particle system nodes, check if ray with given mouse position from near plane to far plane collides with bounding volume
    for (auto entity: decomposedEntities.psgs) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto entityDistance = lineTriangleContact.set(entity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
            // check if match or better match
            if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                selectedEntity = entity;
                selectedEntityDistance = entityDistance;
                selectedObject3DNode = nullptr;
                selectedParticleSystem = nullptr;
                auto selectedSubEntityDistance = Float::MAX_VALUE;
                // iterate sub partition systems, check if ray with given mouse position from near plane to far plane collides with bounding volume
                for (auto subEntity: entity->getParticleSystems()) {
                    if (LineSegment::doesBoundingBoxCollideWithLineSegment(subEntity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
                        auto subEntityDistance = lineTriangleContact.set(subEntity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
                        // check if match or better match
                        if (selectedParticleSystem == nullptr || subEntityDistance < selectedSubEntityDistance) {
                            selectedSubEntityDistance = subEntityDistance;
                            selectedParticleSystem = subEntity;
                        }
                    }
                }
            }
        }
    }
 
    // iterate visible line objects, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    for (auto entity: decomposedEntities.linesObjects) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto entityDistance = lineTriangleContact.set(entity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
            // check if match or better match
            if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                selectedEntity = entity;
                selectedEntityDistance = entityDistance;
                selectedObject3DNode = nullptr;
                selectedParticleSystem = nullptr;
            }
        }
    }
 
    // iterate visible objects, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    array<vector<Object3D*>, 3> objectsArray {decomposedEntities.objects, decomposedEntities.objectsForwardShading, decomposedEntities.objectsPostPostProcessing,  };
    for (auto& objects: objectsArray) {
        for (auto entity: objects) {
            // skip if not pickable or ignored by filter
            if (forcePicking == false && entity->isPickable() == false) continue;
            if (filter != nullptr && filter->filterEntity(entity) == false) continue;
            // do the collision test
            if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
                for (auto it = entity->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                    auto& vertices = it->next();
                    if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], nearPlaneWorldCoordinate, farPlaneWorldCoordinate, lineTriangleContact) == true) {
                        auto entityDistance = lineTriangleContact.sub(nearPlaneWorldCoordinate).computeLengthSquared();
                        // check if match or better match
                        if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                            selectedEntity = entity;
                            selectedEntityDistance = entityDistance;
                            selectedObject3DNode = it->getNode();
                            selectedParticleSystem = nullptr;
                        }
                    }
                }
            }
        }
    }
 
    // iterate visible LOD objects, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    for (auto entity: decomposedEntities.lodObjects) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto object = entity->getLODObject();
            if (object != nullptr) {
                for (auto it = object->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                    auto& vertices = it->next();
                    if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], nearPlaneWorldCoordinate, farPlaneWorldCoordinate, lineTriangleContact) == true) {
                        auto entityDistance = lineTriangleContact.sub(nearPlaneWorldCoordinate).computeLengthSquared();
                        // check if match or better match
                        if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                            selectedEntity = entity;
                            selectedEntityDistance = entityDistance;
                        }
                    }
                    selectedObject3DNode = it->getNode();
                    selectedParticleSystem = nullptr;
                }
            }
        }
    }
 
    // iterate visible entity hierarchies, check if ray with given mouse position from near plane to far plane collides with bounding volume
    for (auto entity: decomposedEntities.entityHierarchies) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), nearPlaneWorldCoordinate, farPlaneWorldCoordinate, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            DecomposedEntities decomposedEntitiesEH;
            Node* object3DNodeEH = nullptr;
            ParticleSystemEntity* particleSystemEntityEH = nullptr;
            decomposeEntityTypes(
                entity->getEntities(),
                decomposedEntitiesEH
            );
            auto subEntity = getEntityByMousePosition(
                decomposedEntitiesEH,
                true,
                mouseX,
                mouseY,
                filter,
                &object3DNodeEH,
                &particleSystemEntityEH
            );
            if (subEntity != nullptr) {
                auto entityDistance = lineTriangleContact.set(subEntity->getBoundingBoxTransformed()->getCenter()).sub(nearPlaneWorldCoordinate).computeLengthSquared();
                // check if match or better match
                if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                    selectedEntity = entity;
                    selectedEntityDistance = entityDistance;
                    selectedObject3DNode = object3DNodeEH;
                    selectedParticleSystem = particleSystemEntityEH;
                }
            }
        }
    }
 
    // store node
    if (object3DNode != nullptr) *object3DNode = selectedObject3DNode;
 
    // store particle system entity
    if (particleSystemEntity != nullptr) {
        *particleSystemEntity = selectedParticleSystem;
    }
 
    // return parent entity if entity is part of a hierarchy
    if (selectedEntity != nullptr) {
        for (auto _entity = selectedEntity; _entity != nullptr; _entity = _entity->getParentEntity()) {
            if (_entity->getParentEntity() == nullptr) return _entity;
        }
        return nullptr;
    } else {
        return nullptr;
    }
}
 
Entity* Engine::getEntityByMousePosition(int32_t mouseX, int32_t mouseY, Vector3& contactPoint, EntityPickingFilter* filter, Node** object3DNode, ParticleSystemEntity** particleSystemEntity) {
    // get world position of mouse position at near and far plane
    auto startPoint = computeWorldCoordinateByMousePosition(mouseX, mouseY, 0.0f);
    auto endPoint = computeWorldCoordinateByMousePosition(mouseX, mouseY, 1.0f);
 
    //
    return doRayCasting(startPoint, endPoint, contactPoint, filter);// TODO: object 3d node, particle system entity
}
 
Entity* Engine::doRayCasting(
    DecomposedEntities& decomposedEntities,
    bool forcePicking,
    const Vector3& startPoint,
    const Vector3& endPoint,
    Vector3& contactPoint,
    EntityPickingFilter* filter) {
    Vector3 boundingBoxLineContactMin;
    Vector3 boundingBoxLineContactMax;
    Vector3 lineTriangleContact;
 
    // selected entity
    auto selectedEntityDistance = Float::MAX_VALUE;
    Entity* selectedEntity = nullptr;
 
    // iterate visible objects with no depth writing, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    for (auto entity: decomposedEntities.objectsNoDepthTest) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), startPoint, endPoint, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            for (auto it = entity->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                auto& vertices = it->next();
                if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], startPoint, endPoint, lineTriangleContact) == true) {
                    auto entityDistance = lineTriangleContact.clone().sub(startPoint).computeLengthSquared();
                    // check if match or better match
                    if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                        selectedEntity = entity;
                        selectedEntityDistance = entityDistance;
                        contactPoint = lineTriangleContact;
                    }
                }
            }
        }
    }
    // they have first priority right now
    if (selectedEntity != nullptr) {
        return selectedEntity;
    }
 
    // iterate visible objects, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    array<vector<Object3D*>, 3> objectsArray {decomposedEntities.objects, decomposedEntities.objectsForwardShading, decomposedEntities.objectsPostPostProcessing,  };
    for (auto& objects: objectsArray) {
        for (auto entity: objects) {
            // skip if not pickable or ignored by filter
            if (forcePicking == false && entity->isPickable() == false) continue;
            if (filter != nullptr && filter->filterEntity(entity) == false) continue;
            // do the collision test
            if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), startPoint, endPoint, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
                for (auto it = entity->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                    auto& vertices = it->next();
                    if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], startPoint, endPoint, lineTriangleContact) == true) {
                        auto entityDistance = lineTriangleContact.clone().sub(startPoint).computeLengthSquared();
                        // check if match or better match
                        if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                            selectedEntity = entity;
                            selectedEntityDistance = entityDistance;
                            contactPoint = lineTriangleContact;
                        }
                    }
                }
            }
        }
    }
 
    // iterate visible LOD objects, check if ray with given mouse position from near plane to far plane collides with each object's triangles
    for (auto entity: decomposedEntities.lodObjects) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), startPoint, endPoint, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            auto object = entity->getLODObject();
            if (object != nullptr) {
                for (auto it = object->getTransformedFacesIterator()->iterator(); it->hasNext();) {
                    auto& vertices = it->next();
                    if (LineSegment::doesLineSegmentCollideWithTriangle(vertices[0], vertices[1], vertices[2], startPoint, endPoint, lineTriangleContact) == true) {
                        auto entityDistance = lineTriangleContact.sub(startPoint).computeLengthSquared();
                        // check if match or better match
                        if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                            selectedEntity = entity;
                            selectedEntityDistance = entityDistance;
                            contactPoint = lineTriangleContact;
                        }
                    }
                }
            }
        }
    }
 
    // iterate visible entity hierarchies, check if ray with given mouse position from near plane to far plane collides with bounding volume
    for (auto entity: decomposedEntities.entityHierarchies) {
        // skip if not pickable or ignored by filter
        if (forcePicking == false && entity->isPickable() == false) continue;
        if (filter != nullptr && filter->filterEntity(entity) == false) continue;
        // do the collision test
        if (LineSegment::doesBoundingBoxCollideWithLineSegment(entity->getBoundingBoxTransformed(), startPoint, endPoint, boundingBoxLineContactMin, boundingBoxLineContactMax) == true) {
            DecomposedEntities decomposedEntitiesEH;
            decomposeEntityTypes(
                entity->getEntities(),
                decomposedEntitiesEH
            );
            Vector3 contactPointEH;
            auto entity = doRayCasting(
                decomposedEntitiesEH,
                true,
                startPoint,
                endPoint,
                contactPointEH,
                filter
            );
            if (entity != nullptr) {
                auto entityDistance = lineTriangleContact.sub(startPoint).computeLengthSquared();
                // check if match or better match
                if (selectedEntity == nullptr || entityDistance < selectedEntityDistance) {
                    selectedEntity = entity;
                    selectedEntityDistance = entityDistance;
                    contactPoint = contactPointEH;
                }
            }
        }
    }
 
    //
    return selectedEntity;
}
 
bool Engine::computeScreenCoordinateByWorldCoordinate(const Vector3& worldCoordinate, Vector2& screenCoordinate, int width, int height)
{
    auto _width = width != -1?width:(scaledWidth != -1?scaledWidth:this->width);
    auto _height = height != -1?height:(scaledHeight != -1?scaledHeight:this->height);
    // convert to normalized device coordinates
    auto screenCoordinate4 = camera->getModelViewProjectionMatrix().multiply(Vector4(worldCoordinate, 1.0f));
    screenCoordinate4.scale(1.0f / screenCoordinate4.getW());
    // convert to screen coordinate
    screenCoordinate.setX((screenCoordinate4[0] + 1.0f) * _width / 2.0f);
    screenCoordinate.setY(_height - ((screenCoordinate4[1] + 1.0f) * _height / 2.0f));
    return camera->getModelViewMatrix().multiply(worldCoordinate).getZ() <= 0.0f;
}
 
void Engine::dispose()
{
    // finish last frame
    if (this == Engine::instance) Engine::renderer->finishFrame();
 
    // remove entities
    vector<string> entitiesToRemove;
    for (auto it: entitiesById) {
        auto entityKey = it.first;
        entitiesToRemove.push_back(entityKey);
    }
    for (auto entityKey: entitiesToRemove) {
        removeEntity(entityKey);
    }
 
    // dispose shadow mapping
    if (shadowMapping != nullptr) shadowMapping->dispose();
 
    // dispose frame buffers
    if (frameBuffer != nullptr) frameBuffer->dispose();
    if (postProcessingFrameBuffer1 != nullptr) postProcessingFrameBuffer1->dispose();
    if (postProcessingFrameBuffer2 != nullptr) postProcessingFrameBuffer2->dispose();
    if (postProcessingTemporaryFrameBuffer != nullptr) postProcessingTemporaryFrameBuffer->dispose();
 
    // dispose GUI
    gui->dispose();
    if (this == Engine::instance) {
        guiRenderer->dispose();
        GUIParser::dispose();
    }
 
    // dispose object 3d VBO renderer
    entityRenderer->dispose();
 
    // dispose object buffer if main engine
    if (this == Engine::instance) {
        ObjectBuffer::dispose();
    }
 
    // set current engine
    if (currentEngine == this) currentEngine = nullptr;
}
 
void Engine::initGUIMode()
{
    // use framebuffer if we have one
    if (frameBuffer != nullptr) {
        frameBuffer->enableFrameBuffer();
    } else {
        frameBuffer->disableFrameBuffer();
    }
 
    renderer->initGuiMode();
}
 
void Engine::doneGUIMode()
{
    renderer->doneGuiMode();
 
    // unuse framebuffer if we have one
    if (frameBuffer != nullptr)
        FrameBuffer::disableFrameBuffer();
}
 
bool Engine::makeScreenshot(const string& pathName, const string& fileName, bool removeAlphaChannel)
{
    // use framebuffer if we have one
    if (frameBuffer != nullptr) frameBuffer->enableFrameBuffer();
 
    // fetch pixel
    auto pixels = renderer->readPixels(0, 0, width, height);
    if (pixels == nullptr) {
        Console::println("Engine::makeScreenshot(): Failed to read pixels");
        return false;
    }
 
    // create texture, write and delete
    auto texture = new Texture(
        "tdme.engine.makescreenshot",
        32,
        width,
        height,
        width,
        height,
        pixels
    );
    texture->acquireReference();
    PNGTextureWriter::write(texture, pathName, fileName, removeAlphaChannel);
    texture->releaseReference();
 
    // unuse framebuffer if we have one
    if (frameBuffer != nullptr) FrameBuffer::disableFrameBuffer();
 
    //
    return true;
}
 
bool Engine::makeScreenshot(vector<uint8_t>& pngData)
{
    // use framebuffer if we have one
    if (frameBuffer != nullptr) frameBuffer->enableFrameBuffer();
 
    // fetch pixel
    auto pixels = renderer->readPixels(0, 0, width, height);
    if (pixels == nullptr) {
        Console::println("Engine::makeScreenshot(): Failed to read pixels");
        return false;
    }
 
    // create texture, write and delete
    auto texture = new Texture(
        "tdme.engine.makescreenshot",
        32,
        width,
        height,
        width,
        height,
        pixels
    );
 
    texture->acquireReference();
    PNGTextureWriter::write(texture, pngData);
    texture->releaseReference();
 
    // unuse framebuffer if we have one
    if (frameBuffer != nullptr) FrameBuffer::disableFrameBuffer();
 
    //
    return true;
}
 
void Engine::resetPostProcessingPrograms() {
    postProcessingPrograms.clear();
}
 
void Engine::addPostProcessingProgram(const string& programId) {
    postProcessingPrograms.erase(remove(postProcessingPrograms.begin(), postProcessingPrograms.end(), programId), postProcessingPrograms.end());
    if (postProcessing->getPostProcessingProgram(programId) != nullptr) postProcessingPrograms.push_back(programId);
}
 
void Engine::doPostProcessing(PostProcessingProgram::RenderPass renderPass, array<FrameBuffer*, 2> postProcessingFrameBuffers, FrameBuffer* targetFrameBuffer) {
    auto postProcessingFrameBufferIdx = 0;
    for (auto programId: postProcessingPrograms) {
        auto program = postProcessing->getPostProcessingProgram(programId);
        if (program == nullptr) continue;
        if (program->getRenderPass() != renderPass) continue;
        auto effectPassSkipDetected = false;
        for (auto& effectPass: program->getEffectPasses()) {
            if (effectPassSkip[effectPass.effectPassIdx - 1] == true) effectPassSkipDetected = true;
        }
        if (effectPassSkipDetected == true) continue;
        for (auto& step: program->getPostProcessingSteps()) {
            auto shaderId = step.shaderId;
            FrameBuffer* blendToSource = nullptr;
            FrameBuffer* source = nullptr;
            FrameBuffer* target = nullptr;
            if (step.blendToSource == PostProcessingProgram::FRAMEBUFFERSOURCE_SCREEN) {
                blendToSource = postProcessingFrameBuffers[postProcessingFrameBufferIdx];
            }
            switch(step.source) {
                case PostProcessingProgram::FRAMEBUFFERSOURCE_NONE:
                    break;
                case PostProcessingProgram::FRAMEBUFFERSOURCE_SCREEN:
                    source = postProcessingFrameBuffers[postProcessingFrameBufferIdx];
                    break;
                default:
                    source = effectPassFrameBuffers[step.source - PostProcessingProgram::FRAMEBUFFERSOURCE_EFFECTPASS0];
                    break;
            }
            switch(step.target) {
                case PostProcessingProgram::FRAMEBUFFERTARGET_SCREEN:
                    target = postProcessingFrameBuffers[(postProcessingFrameBufferIdx + 1) % 2];
                    break;
                case PostProcessingProgram::FRAMEBUFFERTARGET_TEMPORARY:
                    isUsingPostProcessingTemporaryFrameBuffer = true;
                    if (postProcessingTemporaryFrameBuffer == nullptr) {
                        postProcessingTemporaryFrameBuffer = new FrameBuffer(width, height, FrameBuffer::FRAMEBUFFER_COLORBUFFER | FrameBuffer::FRAMEBUFFER_DEPTHBUFFER);
                        postProcessingTemporaryFrameBuffer->initialize();
                    }
                    target = postProcessingTemporaryFrameBuffer;
                    break;
            }
            FrameBuffer::doPostProcessing(this, target, source, programId, shaderId, step.bindTemporary == true?postProcessingTemporaryFrameBuffer:nullptr, blendToSource);
            switch(step.target) {
                case PostProcessingProgram::FRAMEBUFFERTARGET_SCREEN:
                    postProcessingFrameBufferIdx = (postProcessingFrameBufferIdx + 1) % 2;
                    break;
                case PostProcessingProgram::FRAMEBUFFERTARGET_TEMPORARY:
                    break;
            }
        }
    }
 
    // render back to objects frame buffer
    if (postProcessingFrameBuffers[postProcessingFrameBufferIdx] != targetFrameBuffer) {
        if (targetFrameBuffer != nullptr) {
            targetFrameBuffer->enableFrameBuffer();
        } else {
            FrameBuffer::disableFrameBuffer();
        }
        postProcessingFrameBuffers[postProcessingFrameBufferIdx]->renderToScreen(this);
    }
}
 
const vector<string> Engine::getRegisteredShader(ShaderType type) {
    vector<string> result;
    for (auto shadersIt: shaders) {
        auto& shader = shadersIt.second;
        if (shader.type == type) {
            result.push_back(shader.id);
        }
    }
    return result;
}
 
void Engine::registerShader(ShaderType type, const string& shaderId, const map<string, ShaderParameter>& parameterDefaults) {
    if (shaders.find(shaderId) != shaders.end()) {
        Console::println("Engine::registerShader(): Shader already registered: " + shaderId);
        return;
    }
    shaders[shaderId] = {
        .type = type,
        .id = shaderId,
        .parameterDefaults = parameterDefaults
    };
}
 
const map<string, ShaderParameter> Engine::getShaderParameterDefaults(const string& shaderId) {
    auto shaderIt = shaders.find(shaderId);
    if (shaderIt == shaders.end()) {
        Console::println("Engine::getShaderParameterDefaults(): No registered shader: " + shaderId);
        return map<string, ShaderParameter>();
    }
    return shaderIt->second.parameterDefaults;
}
 
void Engine::render(FrameBuffer* renderFrameBuffer, GeometryBuffer* renderGeometryBuffer, DecomposedEntities& visibleDecomposedEntities, int32_t effectPass, int32_t renderPassMask, const string& shaderPrefix, bool useEZR, bool applyShadowMapping, bool applyPostProcessing, bool doRenderLightSource, bool doRenderParticleSystems, int32_t renderTypes) {
    //
    Engine::renderer->setEffectPass(effectPass);
    Engine::renderer->setShaderPrefix(shaderPrefix);
 
    // do depth buffer writing aka early z rejection
    if (renderGeometryBuffer == nullptr && useEZR == true && ezrShader != nullptr && visibleDecomposedEntities.ezrObjects.size() > 0) {
        // disable color rendering, we only want to write to the Z-Buffer
        renderer->setColorMask(false, false, false, false);
        // render
        ezrShader->useProgram(this);
        // only draw opaque face entities of objects marked as EZR objects
        for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
            auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
            if ((renderPassMask & renderPass) == renderPass) {
                entityRenderer->render(
                    renderPass,
                    visibleDecomposedEntities.ezrObjects,
                    false,
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)
                );
            }
        }
        // done
        ezrShader->unUseProgram();
        // restore disable color rendering
        renderer->setColorMask(true, true, true, true);
    }
 
    // use lighting shader
    if (visibleDecomposedEntities.objects.empty() == false || visibleDecomposedEntities.objectsForwardShading.empty() == false) {
        //
        if (lightingShader != nullptr) lightingShader->useProgram(this);
 
        // render objects
        for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
            auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
            if ((renderPassMask & renderPass) == renderPass) {
                if (renderPass == Entity::RENDERPASS_TERRAIN) {
                    if (renderGeometryBuffer != nullptr) {
                        if (lightingShader != nullptr) lightingShader->unUseProgram();
                        renderGeometryBuffer->enableGeometryBuffer();
                        renderer->setClearColor(0.0f, 0.0f, 0.0f, 0.0f);
                        renderer->clear(renderer->CLEAR_DEPTH_BUFFER_BIT | renderer->CLEAR_COLOR_BUFFER_BIT);
                        Engine::renderer->setShaderPrefix("defer_");
                        if (lightingShader != nullptr) lightingShader->useProgram(this);
                    }
                } else
                if (renderPass == Entity::RENDERPASS_WATER) renderer->enableBlending();
                entityRenderer->render(
                    renderPass,
                    visibleDecomposedEntities.objects,
                    true,
                    ((renderTypes & EntityRenderer::RENDERTYPE_NORMALS) == EntityRenderer::RENDERTYPE_NORMALS?EntityRenderer::RENDERTYPE_NORMALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS?EntityRenderer::RENDERTYPE_TEXTUREARRAYS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_EFFECTCOLORS) == EntityRenderer::RENDERTYPE_EFFECTCOLORS?EntityRenderer::RENDERTYPE_EFFECTCOLORS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS) == EntityRenderer::RENDERTYPE_MATERIALS?EntityRenderer::RENDERTYPE_MATERIALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES) == EntityRenderer::RENDERTYPE_TEXTURES?EntityRenderer::RENDERTYPE_TEXTURES:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)|
                    ((renderTypes & EntityRenderer::RENDERTYPE_LIGHTS) == EntityRenderer::RENDERTYPE_LIGHTS?EntityRenderer::RENDERTYPE_LIGHTS:0)
                );
                if (renderPass == Entity::RENDERPASS_STANDARD) {
                    if (renderGeometryBuffer != nullptr) {
                        if (lightingShader != nullptr) lightingShader->unUseProgram();
                        renderGeometryBuffer->disableGeometryBuffer();
                        Engine::renderer->setShaderPrefix(shaderPrefix);
                        if (renderFrameBuffer != nullptr) renderFrameBuffer->enableFrameBuffer();
                        renderGeometryBuffer->renderToScreen(this);
                        if (lightingShader != nullptr) lightingShader->useProgram(this);
                        if (visibleDecomposedEntities.objectsForwardShading.empty() == false) {
                            // TODO: use a loop maybe from TERRAIN to STANDARD, but for now it works this way too :)
                            // terrain
                            entityRenderer->render(
                                Entity::RENDERPASS_TERRAIN,
                                visibleDecomposedEntities.objectsForwardShading,
                                true,
                                ((renderTypes & EntityRenderer::RENDERTYPE_NORMALS) == EntityRenderer::RENDERTYPE_NORMALS?EntityRenderer::RENDERTYPE_NORMALS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS?EntityRenderer::RENDERTYPE_TEXTUREARRAYS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_EFFECTCOLORS) == EntityRenderer::RENDERTYPE_EFFECTCOLORS?EntityRenderer::RENDERTYPE_EFFECTCOLORS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS) == EntityRenderer::RENDERTYPE_MATERIALS?EntityRenderer::RENDERTYPE_MATERIALS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES) == EntityRenderer::RENDERTYPE_TEXTURES?EntityRenderer::RENDERTYPE_TEXTURES:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)|
                                ((renderTypes & EntityRenderer::RENDERTYPE_LIGHTS) == EntityRenderer::RENDERTYPE_LIGHTS?EntityRenderer::RENDERTYPE_LIGHTS:0)
                            );
                            // standard
                            entityRenderer->render(
                                Entity::RENDERPASS_STANDARD,
                                visibleDecomposedEntities.objectsForwardShading,
                                true,
                                ((renderTypes & EntityRenderer::RENDERTYPE_NORMALS) == EntityRenderer::RENDERTYPE_NORMALS?EntityRenderer::RENDERTYPE_NORMALS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS?EntityRenderer::RENDERTYPE_TEXTUREARRAYS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_EFFECTCOLORS) == EntityRenderer::RENDERTYPE_EFFECTCOLORS?EntityRenderer::RENDERTYPE_EFFECTCOLORS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS) == EntityRenderer::RENDERTYPE_MATERIALS?EntityRenderer::RENDERTYPE_MATERIALS:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES) == EntityRenderer::RENDERTYPE_TEXTURES?EntityRenderer::RENDERTYPE_TEXTURES:0) |
                                ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)|
                                ((renderTypes & EntityRenderer::RENDERTYPE_LIGHTS) == EntityRenderer::RENDERTYPE_LIGHTS?EntityRenderer::RENDERTYPE_LIGHTS:0)
                            );
                        }
                    }
                } else
                if (renderPass == Entity::RENDERPASS_WATER) renderer->disableBlending();
            }
        }
 
        // render transparent faces
        entityRenderer->renderTransparentFaces();
 
        // unuse lighting shader
        if (lightingShader != nullptr) lightingShader->unUseProgram();
 
        // render shadows if required
        if (applyShadowMapping == true && shadowMapping != nullptr) {
            if (visibleDecomposedEntities.objects.empty() == false) shadowMapping->renderShadowMaps(visibleDecomposedEntities.objects);
            if (visibleDecomposedEntities.objectsForwardShading.empty() == false) shadowMapping->renderShadowMaps(visibleDecomposedEntities.objectsForwardShading);
        }
    }
 
    // do post processing
    if (applyPostProcessing == true) {
        isUsingPostProcessingTemporaryFrameBuffer = false;
        if (postProcessingPrograms.size() > 0) {
            doPostProcessing(PostProcessingProgram::RENDERPASS_OBJECTS, {{postProcessingFrameBuffer1, postProcessingFrameBuffer2 }}, postProcessingFrameBuffer1);
            postProcessingFrameBuffer1->enableFrameBuffer();
        }
    }
 
    // render lines objects
    if (visibleDecomposedEntities.linesObjects.size() > 0) {
        // use particle shader
        if (linesShader != nullptr) linesShader->useProgram(renderer->CONTEXTINDEX_DEFAULT);
 
        // render points based particle systems
        for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
            auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
            if ((renderPassMask & renderPass) == renderPass) entityRenderer->render(renderPass, visibleDecomposedEntities.linesObjects);
        }
 
        // unuse particle shader
        if (linesShader != nullptr) linesShader->unUseProgram(renderer->CONTEXTINDEX_DEFAULT);
    }
 
    // render point particle systems
    if (doRenderParticleSystems == true && visibleDecomposedEntities.ppses.size() > 0) {
        // use particle shader
        if (particlesShader != nullptr) particlesShader->useProgram(renderer->CONTEXTINDEX_DEFAULT);
 
        // render points based particle systems
        if (visibleDecomposedEntities.ppses.size() > 0) {
            for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
                auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
                if ((renderPassMask & renderPass) == renderPass) entityRenderer->render(renderPass, visibleDecomposedEntities.ppses);
            }
        }
 
        // unuse particle shader
        if (particlesShader != nullptr) particlesShader->unUseProgram(renderer->CONTEXTINDEX_DEFAULT);
    }
 
    // render objects and particles together
    if (applyPostProcessing == true) {
        if (postProcessingPrograms.size() > 0) {
            doPostProcessing(PostProcessingProgram::RENDERPASS_FINAL, {{postProcessingFrameBuffer1, postProcessingFrameBuffer2 }}, frameBuffer);
        }
    }
 
    // render objects that are have post post processing render pass
    if (visibleDecomposedEntities.objectsPostPostProcessing.size() > 0) {
        // use lighting shader
        if (lightingShader != nullptr) {
            lightingShader->useProgram(this);
        }
 
        // render post processing objects
        for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
            auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
            if ((renderPassMask & renderPass) == renderPass) {
                if (renderPass == Entity::RENDERPASS_WATER) renderer->enableBlending();
                entityRenderer->render(
                    renderPass,
                    visibleDecomposedEntities.objectsPostPostProcessing,
                    true,
                    ((renderTypes & EntityRenderer::RENDERTYPE_NORMALS) == EntityRenderer::RENDERTYPE_NORMALS?EntityRenderer::RENDERTYPE_NORMALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS?EntityRenderer::RENDERTYPE_TEXTUREARRAYS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_EFFECTCOLORS) == EntityRenderer::RENDERTYPE_EFFECTCOLORS?EntityRenderer::RENDERTYPE_EFFECTCOLORS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS) == EntityRenderer::RENDERTYPE_MATERIALS?EntityRenderer::RENDERTYPE_MATERIALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES) == EntityRenderer::RENDERTYPE_TEXTURES?EntityRenderer::RENDERTYPE_TEXTURES:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)|
                    ((renderTypes & EntityRenderer::RENDERTYPE_LIGHTS) == EntityRenderer::RENDERTYPE_LIGHTS?EntityRenderer::RENDERTYPE_LIGHTS:0)
                );
                if (renderPass == Entity::RENDERPASS_WATER) renderer->disableBlending();
            }
        }
 
        // render transparent faces
        entityRenderer->renderTransparentFaces();
 
        // unuse lighting shader
        if (lightingShader != nullptr) lightingShader->unUseProgram();
 
        // render shadows if required
        if (applyShadowMapping == true && shadowMapping != nullptr) {
            if (visibleDecomposedEntities.objectsPostPostProcessing.empty() == false) shadowMapping->renderShadowMaps(visibleDecomposedEntities.objectsPostPostProcessing);
        }
    }
 
    // render objects that are have post post processing render pass
    if (visibleDecomposedEntities.objectsNoDepthTest.size() > 0) {
        // use lighting shader
        if (lightingShader != nullptr) {
            lightingShader->useProgram(this);
        }
 
        //
        renderer->disableDepthBufferTest();
 
        // render post processing objects
        for (auto i = 0; i < Entity::RENDERPASS_MAX; i++) {
            auto renderPass = static_cast<Entity::RenderPass>(Math::pow(2, i));
            if ((renderPassMask & renderPass) == renderPass) {
                if (renderPass == Entity::RENDERPASS_WATER) renderer->enableBlending();
                entityRenderer->render(
                    renderPass,
                    visibleDecomposedEntities.objectsNoDepthTest,
                    true,
                    ((renderTypes & EntityRenderer::RENDERTYPE_NORMALS) == EntityRenderer::RENDERTYPE_NORMALS?EntityRenderer::RENDERTYPE_NORMALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS?EntityRenderer::RENDERTYPE_TEXTUREARRAYS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTUREARRAYS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_EFFECTCOLORS) == EntityRenderer::RENDERTYPE_EFFECTCOLORS?EntityRenderer::RENDERTYPE_EFFECTCOLORS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS) == EntityRenderer::RENDERTYPE_MATERIALS?EntityRenderer::RENDERTYPE_MATERIALS:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_MATERIALS_DIFFUSEMASKEDTRANSPARENCY:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES) == EntityRenderer::RENDERTYPE_TEXTURES?EntityRenderer::RENDERTYPE_TEXTURES:0) |
                    ((renderTypes & EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY) == EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY?EntityRenderer::RENDERTYPE_TEXTURES_DIFFUSEMASKEDTRANSPARENCY:0)|
                    ((renderTypes & EntityRenderer::RENDERTYPE_LIGHTS) == EntityRenderer::RENDERTYPE_LIGHTS?EntityRenderer::RENDERTYPE_LIGHTS:0)
                );
                if (renderPass == Entity::RENDERPASS_WATER) renderer->disableBlending();
            }
        }
 
        // render transparent faces
        entityRenderer->renderTransparentFaces();
 
        //
        renderer->enableDepthBufferTest();
 
        // unuse lighting shader
        if (lightingShader != nullptr) lightingShader->unUseProgram();
 
        // render shadows if required
        if (applyShadowMapping == true && shadowMapping != nullptr) {
            if (visibleDecomposedEntities.objectsNoDepthTest.empty() == false) shadowMapping->renderShadowMaps(visibleDecomposedEntities.objectsNoDepthTest);
        }
    }
 
    if (doRenderLightSource == true) {
        auto _width = scaledWidth != -1?scaledWidth:width;
        auto _height = scaledHeight != -1?scaledHeight:height;
        //
        renderLightSources(_width, _height);
    }
 
    //
    Engine::renderer->setShaderPrefix(string());
    Engine::renderer->setEffectPass(0);
}
 
bool Engine::renderLightSources(int width, int height) {
    auto lightSourceVisible = false;
    for (auto& light: lights) {
        if (light.isEnabled() == false || light.isRenderSource() == false) continue;
        auto lightSourceSize = light.getSourceSize();
        auto lightSourcePixelSize = width < height?static_cast<float>(lightSourceSize) * static_cast<float>(width):static_cast<float>(lightSourceSize) * static_cast<float>(height);;
        Vector2 lightSourceDimension2D = Vector2(lightSourcePixelSize, lightSourcePixelSize);
        Vector2 lightSourcePosition2D;
        Vector3 lightSourcePosition = Vector3(light.getPosition().getX(), light.getPosition().getY(), light.getPosition().getZ());
        if (light.getPosition().getW() > Math::EPSILON) lightSourcePosition.scale(1.0f / light.getPosition().getW());
        auto visible = computeScreenCoordinateByWorldCoordinate(lightSourcePosition, lightSourcePosition2D, width, height);
        lightSourcePosition2D.sub(lightSourceDimension2D.clone().scale(0.5f));
        if (visible == true) {
            texture2DRenderShader->renderTexture(this, lightSourcePosition2D, lightSourceDimension2D, light.getSourceTextureId(), width, height);
            lightSourceVisible = true;
        }
    }
    return lightSourceVisible;
}
 
void Engine::dumpShaders() {
    for (auto shaderType = 0; shaderType < SHADERTYPE_MAX; shaderType++)
    for (auto& shaderId: getRegisteredShader(static_cast<ShaderType>(shaderType))) {
        string shaderTypeString = "unknowm";
        switch (shaderType) {
            case SHADERTYPE_OBJECT3D: shaderTypeString = "object3d"; break;
            case SHADERTYPE_POSTPROCESSING: shaderTypeString = "postprocessing"; break;
            default: break;
        }
        Console::println(string("TDME2::registered " + shaderTypeString + " shader: ") + shaderId);
        auto& defaultShaderParameters = getShaderParameterDefaults(shaderId);
        if (defaultShaderParameters.size() > 0) {
            Console::print("\t");
            for (auto it: defaultShaderParameters) {
                auto& parameterName = it.first;
                Console::print(parameterName);
                switch(it.second.getType()) {
                    case ShaderParameter::TYPE_NONE:
                        Console::print("=none; ");
                        break;
                    case ShaderParameter::TYPE_BOOLEAN:
                        Console::print("=boolean(");
                        Console::print(getShaderParameter(shaderId, parameterName).getBooleanValue() == true?"true":"false");
                        Console::print("); ");
                        break;
                    case ShaderParameter::TYPE_INTEGER:
                        Console::print("=integer(");
                        Console::print(to_string(getShaderParameter(shaderId, parameterName).getIntegerValue()));
                        Console::print("); ");
                        break;
                    case ShaderParameter::TYPE_FLOAT:
                        Console::print("=float(");
                        Console::print(to_string(getShaderParameter(shaderId, parameterName).getFloatValue()));
                        Console::print("); ");
                        break;
                    case ShaderParameter::TYPE_VECTOR2:
                        {
                            Console::print("=Vector2(");
                            auto& shaderParameterArray = getShaderParameter(shaderId, parameterName).getVector2Value().getArray();
                            for (auto i = 0; i < shaderParameterArray.size(); i++) {
                                if (i != 0) Console::print(",");
                                Console::print(to_string(shaderParameterArray[i]));
                            }
                            Console::print("); ");
                        }
                        break;
                    case ShaderParameter::TYPE_VECTOR3:
                        {
                            Console::print("=Vector3(");
                            auto& shaderParameterArray = getShaderParameter(shaderId, parameterName).getVector3Value().getArray();
                            for (auto i = 0; i < shaderParameterArray.size(); i++) {
                                if (i != 0) Console::print(",");
                                Console::print(to_string(shaderParameterArray[i]));
                            }
                            Console::print("); ");
                        }
                        break;
                    case ShaderParameter::TYPE_VECTOR4:
                        {
                            Console::print("=Vector4(");
                            auto& shaderParameterArray = getShaderParameter(shaderId, parameterName).getVector4Value().getArray();
                            for (auto i = 0; i < shaderParameterArray.size(); i++) {
                                if (i != 0) Console::print(",");
                                Console::print(to_string(shaderParameterArray[i]));
                            }
                            Console::print("); ");
                        }
                        break;
                    default:
                        Console::print("=unknown; ");
                        break;
                }
            }
            Console::println();
        }
    }
}