From 09d6998d3da2bdde4a0df744868188e188723a23 Mon Sep 17 00:00:00 2001 From: Kearwood Gilbert Date: Thu, 25 Apr 2013 16:21:28 -0700 Subject: [PATCH] CPU Optimization Pass --- KREngine/kraken/KRAmbientZone.cpp | 8 +- KREngine/kraken/KRAmbientZone.h | 2 +- KREngine/kraken/KRAudioSource.cpp | 8 +- KREngine/kraken/KRAudioSource.h | 2 +- KREngine/kraken/KRBone.cpp | 8 +- KREngine/kraken/KRBone.h | 2 +- KREngine/kraken/KRCamera.cpp | 14 +- KREngine/kraken/KRDirectionalLight.cpp | 10 +- KREngine/kraken/KRDirectionalLight.h | 2 +- KREngine/kraken/KREngine-common.h | 9 +- KREngine/kraken/KRLight.cpp | 59 ++-- KREngine/kraken/KRLight.h | 2 +- KREngine/kraken/KRMat4.cpp | 252 ++++++++++-------- KREngine/kraken/KRMat4.h | 25 +- KREngine/kraken/KRMaterial.cpp | 6 +- KREngine/kraken/KRMaterial.h | 2 +- KREngine/kraken/KRMesh.cpp | 4 +- KREngine/kraken/KRMesh.h | 2 +- KREngine/kraken/KRModel.cpp | 6 +- KREngine/kraken/KRModel.h | 2 +- KREngine/kraken/KRNode.cpp | 2 +- KREngine/kraken/KRNode.h | 5 +- KREngine/kraken/KRParticleSystem.h | 2 +- KREngine/kraken/KRParticleSystemNewtonian.cpp | 8 +- KREngine/kraken/KRParticleSystemNewtonian.h | 2 +- KREngine/kraken/KRPointLight.cpp | 10 +- KREngine/kraken/KRPointLight.h | 2 +- KREngine/kraken/KRReverbZone.cpp | 8 +- KREngine/kraken/KRReverbZone.h | 2 +- KREngine/kraken/KRScene.cpp | 66 +++-- KREngine/kraken/KRScene.h | 2 +- KREngine/kraken/KRShader.cpp | 120 ++++----- KREngine/kraken/KRShader.h | 2 +- KREngine/kraken/KRShaderManager.cpp | 35 +-- KREngine/kraken/KRShaderManager.h | 6 +- KREngine/kraken/KRVector2.h | 7 +- KREngine/kraken/KRVector3.cpp | 14 + KREngine/kraken/KRVector3.h | 11 +- KREngine/kraken/KRVector4.cpp | 7 + KREngine/kraken/KRVector4.h | 10 +- KREngine/kraken/KRViewport.cpp | 19 +- 41 files changed, 444 insertions(+), 321 deletions(-) diff --git a/KREngine/kraken/KRAmbientZone.cpp b/KREngine/kraken/KRAmbientZone.cpp index 8f9ce5e..0d253dc 100644 --- a/KREngine/kraken/KRAmbientZone.cpp +++ b/KREngine/kraken/KRAmbientZone.cpp @@ -85,19 +85,19 @@ void KRAmbientZone::setZone(const std::string &zone) m_zone = zone; } -void KRAmbientZone::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) +void KRAmbientZone::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); bool bVisualize = false; if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { KRMat4 sphereModelMatrix = getModelMatrix(); - KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, lights, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass)) { // Enable additive blending GLDEBUG(glEnable(GL_BLEND)); diff --git a/KREngine/kraken/KRAmbientZone.h b/KREngine/kraken/KRAmbientZone.h index 528dd5c..ff16337 100644 --- a/KREngine/kraken/KRAmbientZone.h +++ b/KREngine/kraken/KRAmbientZone.h @@ -21,7 +21,7 @@ public: virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual void loadXML(tinyxml2::XMLElement *e); - void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); std::string getZone(); void setZone(const std::string &zone); diff --git a/KREngine/kraken/KRAudioSource.cpp b/KREngine/kraken/KRAudioSource.cpp index 8a18dd3..4e07b87 100644 --- a/KREngine/kraken/KRAudioSource.cpp +++ b/KREngine/kraken/KRAudioSource.cpp @@ -196,19 +196,19 @@ void KRAudioSource::queueBuffer() m_nextBufferIndex = (m_nextBufferIndex + 1) % m_audioFile->getBufferCount(); } -void KRAudioSource::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) +void KRAudioSource::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); bool bVisualize = false; if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { KRMat4 sphereModelMatrix = getModelMatrix(); - KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, lights, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass)) { // Enable additive blending GLDEBUG(glEnable(GL_BLEND)); diff --git a/KREngine/kraken/KRAudioSource.h b/KREngine/kraken/KRAudioSource.h index f366488..8472f36 100644 --- a/KREngine/kraken/KRAudioSource.h +++ b/KREngine/kraken/KRAudioSource.h @@ -50,7 +50,7 @@ public: virtual bool hasPhysics(); virtual void physicsUpdate(float deltaTime); - void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); void play(); void stop(); bool isPlaying(); diff --git a/KREngine/kraken/KRBone.cpp b/KREngine/kraken/KRBone.cpp index 67bf273..b443c1d 100644 --- a/KREngine/kraken/KRBone.cpp +++ b/KREngine/kraken/KRBone.cpp @@ -35,19 +35,19 @@ void KRBone::loadXML(tinyxml2::XMLElement *e) } -void KRBone::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) +void KRBone::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); bool bVisualize = false; if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { KRMat4 sphereModelMatrix = getModelMatrix(); - KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, lights, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass)) { // Enable additive blending GLDEBUG(glEnable(GL_BLEND)); diff --git a/KREngine/kraken/KRBone.h b/KREngine/kraken/KRBone.h index 07d3a68..5021c12 100644 --- a/KREngine/kraken/KRBone.h +++ b/KREngine/kraken/KRBone.h @@ -21,7 +21,7 @@ public: virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual void loadXML(tinyxml2::XMLElement *e); - void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); private: diff --git a/KREngine/kraken/KRCamera.cpp b/KREngine/kraken/KRCamera.cpp index a05e0b8..a48b274 100644 --- a/KREngine/kraken/KRCamera.cpp +++ b/KREngine/kraken/KRCamera.cpp @@ -277,7 +277,7 @@ void KRCamera::renderFrame(float deltaTime, GLint renderBufferWidth, GLint rende } if(m_pSkyBoxTexture) { - getContext().getShaderManager()->selectShader("sky_box", *this, std::vector(), 0, m_viewport, KRMat4(), false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_OPAQUE); + getContext().getShaderManager()->selectShader("sky_box", *this, std::vector(), std::vector(), std::vector(), 0, m_viewport, KRMat4(), false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_OPAQUE); getContext().getTextureManager()->selectTexture(0, m_pSkyBoxTexture); @@ -437,7 +437,7 @@ void KRCamera::renderFrame(float deltaTime, GLint renderBufferWidth, GLint rende GLDEBUG(glBlendFunc(GL_ONE, GL_ONE)); - KRShader *pVisShader = getContext().getShaderManager()->getShader("visualize_overlay", this, std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + KRShader *pVisShader = getContext().getShaderManager()->getShader("visualize_overlay", this, std::vector(), std::vector(), std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); m_pContext->getModelManager()->bindVBO((void *)KRENGINE_VBO_3D_CUBE, KRENGINE_VBO_3D_CUBE_SIZE, NULL, 0, true, false, false, false, false, false, false, true); for(std::unordered_map::iterator itr=m_viewport.getVisibleBounds().begin(); itr != m_viewport.getVisibleBounds().end(); itr++) { @@ -445,7 +445,7 @@ void KRCamera::renderFrame(float deltaTime, GLint renderBufferWidth, GLint rende matModel.scale((*itr).first.size() * 0.5f); matModel.translate((*itr).first.center()); - if(getContext().getShaderManager()->selectShader(*this, pVisShader, m_viewport, matModel, std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) { + if(getContext().getShaderManager()->selectShader(*this, pVisShader, m_viewport, matModel, std::vector(), std::vector(), std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) { GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 14)); } } @@ -647,8 +647,8 @@ void KRCamera::renderPost() GLDEBUG(glDisable(GL_DEPTH_TEST)); - KRShader *postShader = m_pContext->getShaderManager()->getShader("PostShader", this, std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); - getContext().getShaderManager()->selectShader(*this, postShader, m_viewport, KRMat4(), std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + KRShader *postShader = m_pContext->getShaderManager()->getShader("PostShader", this, std::vector(), std::vector(), std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + getContext().getShaderManager()->selectShader(*this, postShader, m_viewport, KRMat4(), std::vector(), std::vector(), std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); m_pContext->getTextureManager()->selectTexture(0, NULL); m_pContext->getTextureManager()->_setActiveTexture(0); @@ -848,8 +848,8 @@ void KRCamera::renderPost() GLDEBUG(glEnable(GL_BLEND)); GLDEBUG(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)); - KRShader *fontShader = m_pContext->getShaderManager()->getShader("debug_font", this, std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); - getContext().getShaderManager()->selectShader(*this, fontShader, m_viewport, KRMat4(), std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + KRShader *fontShader = m_pContext->getShaderManager()->getShader("debug_font", this, std::vector(), std::vector(), std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + getContext().getShaderManager()->selectShader(*this, fontShader, m_viewport, KRMat4(), std::vector(), std::vector(), std::vector(), 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); m_pContext->getTextureManager()->selectTexture(0, m_pContext->getTextureManager()->getTexture("font")); diff --git a/KREngine/kraken/KRDirectionalLight.cpp b/KREngine/kraken/KRDirectionalLight.cpp index c572dd2..dd16d90 100644 --- a/KREngine/kraken/KRDirectionalLight.cpp +++ b/KREngine/kraken/KRDirectionalLight.cpp @@ -98,14 +98,14 @@ int KRDirectionalLight::configureShadowBufferViewports(const KRViewport &viewpor return 1; } -void KRDirectionalLight::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { +void KRDirectionalLight::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRLight::render(pCamera, lights, viewport, renderPass); + KRLight::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); if(renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS) { // Lights are rendered on the second pass of the deferred renderer - std::vector this_light; + std::vector this_light; this_light.push_back(this); KRMat4 matModelViewInverseTranspose = viewport.getViewMatrix() * getModelMatrix(); @@ -116,8 +116,8 @@ void KRDirectionalLight::render(KRCamera *pCamera, std::vector &light light_direction_view_space = KRMat4::Dot(matModelViewInverseTranspose, light_direction_view_space); light_direction_view_space.normalize(); - KRShader *pShader = getContext().getShaderManager()->getShader("light_directional", pCamera, this_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), this_light, 0, renderPass)) { + KRShader *pShader = getContext().getShaderManager()->getShader("light_directional", pCamera, std::vector(), this_light, std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), std::vector(), this_light, std::vector(), 0, renderPass)) { light_direction_view_space.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE]); m_color.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR]); diff --git a/KREngine/kraken/KRDirectionalLight.h b/KREngine/kraken/KRDirectionalLight.h index 455cc1d..037c9d5 100644 --- a/KREngine/kraken/KRDirectionalLight.h +++ b/KREngine/kraken/KRDirectionalLight.h @@ -23,7 +23,7 @@ public: KRVector3 getLocalLightDirection(); KRVector3 getWorldLightDirection(); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); virtual KRAABB getBounds(); protected: diff --git a/KREngine/kraken/KREngine-common.h b/KREngine/kraken/KREngine-common.h index 9102b0a..e84c459 100644 --- a/KREngine/kraken/KREngine-common.h +++ b/KREngine/kraken/KREngine-common.h @@ -63,6 +63,12 @@ using std::queue; #include #include #include +#define KRAKEN_HAVE_BLAS 1 +#endif + + +#if !defined(__i386__) && defined(__arm__) +#define KRAKEN_USE_ARM_NEON #endif #if TARGET_OS_IPHONE @@ -166,5 +172,6 @@ fprintf(stderr, "Error at line number %d, in file %s. Returned %d for call %s\n" #define KRCLAMP(x, min, max) (KRMAX(KRMIN(x, max), min)) #define KRALIGN(x) ((x + 3) & ~0x03) +#include "KRVector4.h" #include "KRVector3.h" -#include "KRVector2.h" \ No newline at end of file +#include "KRVector2.h" diff --git a/KREngine/kraken/KRLight.cpp b/KREngine/kraken/KRLight.cpp index 629a918..d2438ea 100644 --- a/KREngine/kraken/KRLight.cpp +++ b/KREngine/kraken/KRLight.cpp @@ -19,6 +19,9 @@ #include "KRShaderManager.h" #include "KRShader.h" #include "KRStockGeometry.h" +#include "KRDirectionalLight.h" +#include "KRSpotLight.h" +#include "KRPointLight.h" KRLight::KRLight(KRScene &scene, std::string name) : KRNode(scene, name) @@ -171,9 +174,9 @@ float KRLight::getDecayStart() { return m_decayStart; } -void KRLight::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { +void KRLight::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); if(renderPass == KRNode::RENDER_PASS_GENERATE_SHADOWMAPS && (pCamera->settings.volumetric_environment_enable || pCamera->settings.dust_particle_enable || (pCamera->settings.m_cShadowBuffers > 0 && m_casts_shadow))) { allocateShadowBuffers(configureShadowBufferViewports(viewport)); @@ -199,12 +202,25 @@ void KRLight::render(KRCamera *pCamera, std::vector &lights, const KR particleModelMatrix.scale(particle_range); // Scale the box symetrically to ensure that we don't have an uneven distribution of particles for different angles of the view frustrum particleModelMatrix.translate(viewport.getCameraPosition()); - std::vector this_light; - this_light.push_back(this); + std::vector this_directional_light; + std::vector this_spot_light; + std::vector this_point_light; + KRDirectionalLight *directional_light = dynamic_cast(this); + KRSpotLight *spot_light = dynamic_cast(this); + KRPointLight *point_light = dynamic_cast(this); + if(directional_light) { + this_directional_light.push_back(directional_light); + } + if(spot_light) { + this_spot_light.push_back(spot_light); + } + if(point_light) { + this_point_light.push_back(point_light); + } - KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, this_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, particleModelMatrix, this_light, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, particleModelMatrix, this_point_light, this_directional_light, this_spot_light, 0, renderPass)) { (m_color * pCamera->settings.dust_particle_intensity * m_dust_particle_intensity * m_intensity).setUniform(pParticleShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR]); @@ -224,13 +240,26 @@ void KRLight::render(KRCamera *pCamera, std::vector &lights, const KR if(renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && pCamera->settings.volumetric_environment_enable && m_light_shafts) { std::string shader_name = pCamera->settings.volumetric_environment_downsample != 0 ? "volumetric_fog_downsampled" : "volumetric_fog"; - std::vector this_light; - this_light.push_back(this); + std::vector this_directional_light; + std::vector this_spot_light; + std::vector this_point_light; + KRDirectionalLight *directional_light = dynamic_cast(this); + KRSpotLight *spot_light = dynamic_cast(this); + KRPointLight *point_light = dynamic_cast(this); + if(directional_light) { + this_directional_light.push_back(directional_light); + } + if(spot_light) { + this_spot_light.push_back(spot_light); + } + if(point_light) { + this_point_light.push_back(point_light); + } - KRShader *pFogShader = m_pContext->getShaderManager()->getShader(shader_name, pCamera, this_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_ADDITIVE_PARTICLES); + KRShader *pFogShader = m_pContext->getShaderManager()->getShader(shader_name, pCamera, this_point_light, this_directional_light, this_spot_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_ADDITIVE_PARTICLES); - if(getContext().getShaderManager()->selectShader(*pCamera, pFogShader, viewport, KRMat4(), this_light, 0, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pFogShader, viewport, KRMat4(), this_point_light, this_directional_light, this_spot_light, 0, KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE)) { int slice_count = (int)(pCamera->settings.volumetric_environment_quality * 495.0) + 5; float slice_near = -pCamera->settings.getPerspectiveNearZ(); @@ -257,7 +286,7 @@ void KRLight::render(KRCamera *pCamera, std::vector &lights, const KR occlusion_test_sphere_matrix *= m_parentNode->getModelMatrix(); } - if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, lights, 0, viewport, occlusion_test_sphere_matrix, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass)) { + if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, occlusion_test_sphere_matrix, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass)) { GLDEBUG(glGenQueriesEXT(1, &m_occlusionQuery)); #if TARGET_OS_IPHONE @@ -309,8 +338,8 @@ void KRLight::render(KRCamera *pCamera, std::vector &lights, const KR GLDEBUG(glDepthRangef(0.0, 1.0)); // Render light flare on transparency pass - KRShader *pShader = getContext().getShaderManager()->getShader("flare", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), lights, 0, renderPass)) { + KRShader *pShader = getContext().getShaderManager()->getShader("flare", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass)) { if(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE] != -1) { GLDEBUG(glUniform1f( pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE], @@ -429,9 +458,9 @@ void KRLight::renderShadowBuffers(KRCamera *pCamera) GLDEBUG(glDisable(GL_BLEND)); // Use shader program - KRShader *shadowShader = m_pContext->getShaderManager()->getShader("ShadowShader", pCamera, std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); + KRShader *shadowShader = m_pContext->getShaderManager()->getShader("ShadowShader", pCamera, std::vector(), std::vector(), std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT); - getContext().getShaderManager()->selectShader(*pCamera, shadowShader, m_shadowViewports[iShadow], KRMat4(), std::vector(), 0, KRNode::RENDER_PASS_SHADOWMAP); + getContext().getShaderManager()->selectShader(*pCamera, shadowShader, m_shadowViewports[iShadow], KRMat4(), std::vector(), std::vector(), std::vector(), 0, KRNode::RENDER_PASS_SHADOWMAP); getScene().render(pCamera, m_shadowViewports[iShadow].getVisibleBounds(), m_shadowViewports[iShadow], KRNode::RENDER_PASS_SHADOWMAP, true); diff --git a/KREngine/kraken/KRLight.h b/KREngine/kraken/KRLight.h index b75c9ff..247a5d4 100644 --- a/KREngine/kraken/KRLight.h +++ b/KREngine/kraken/KRLight.h @@ -42,7 +42,7 @@ public: void setFlareOcclusionSize(float occlusion_size); void deleteBuffers(); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); int getShadowBufferCount(); GLuint *getShadowTextures(); diff --git a/KREngine/kraken/KRMat4.cpp b/KREngine/kraken/KRMat4.cpp index 9b52796..27b2108 100644 --- a/KREngine/kraken/KRMat4.cpp +++ b/KREngine/kraken/KRMat4.cpp @@ -36,64 +36,64 @@ KRMat4::KRMat4() { // Default constructor - Initialize with an identity matrix - static const GLfloat IDENTITY_MATRIX[] = { + static const float IDENTITY_MATRIX[] = { 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 }; - memcpy(m_mat, IDENTITY_MATRIX, sizeof(GLfloat) * 16); + memcpy(c, IDENTITY_MATRIX, sizeof(float) * 16); } -KRMat4::KRMat4(GLfloat *pMat) { - memcpy(m_mat, pMat, sizeof(GLfloat) * 16); +KRMat4::KRMat4(float *pMat) { + memcpy(c, pMat, sizeof(float) * 16); } KRMat4::KRMat4(const KRVector3 &axis_x, const KRVector3 &axis_y, const KRVector3 &axis_z, const KRVector3 &trans) { - m_mat[0] = axis_x.x; m_mat[1] = axis_x.y; m_mat[2] = axis_x.z; m_mat[3] = 0.0f; - m_mat[4] = axis_y.x; m_mat[5] = axis_y.y; m_mat[6] = axis_y.z; m_mat[7] = 0.0f; - m_mat[8] = axis_z.x; m_mat[9] = axis_z.y; m_mat[10] = axis_z.z; m_mat[11] = 0.0f; - m_mat[12] = trans.x; m_mat[13] = trans.y; m_mat[14] = trans.z; m_mat[15] = 1.0f; + c[0] = axis_x.x; c[1] = axis_x.y; c[2] = axis_x.z; c[3] = 0.0f; + c[4] = axis_y.x; c[5] = axis_y.y; c[6] = axis_y.z; c[7] = 0.0f; + c[8] = axis_z.x; c[9] = axis_z.y; c[10] = axis_z.z; c[11] = 0.0f; + c[12] = trans.x; c[13] = trans.y; c[14] = trans.z; c[15] = 1.0f; } KRMat4::~KRMat4() { } -GLfloat *KRMat4::getPointer() { - return m_mat; +float *KRMat4::getPointer() { + return c; } // Copy constructor KRMat4::KRMat4(const KRMat4 &m) { - memcpy(m_mat, m.m_mat, sizeof(GLfloat) * 16); + memcpy(c, m.c, sizeof(float) * 16); } KRMat4& KRMat4::operator=(const KRMat4 &m) { if(this != &m) { // Prevent self-assignment. - memcpy(m_mat, m.m_mat, sizeof(GLfloat) * 16); + memcpy(c, m.c, sizeof(float) * 16); } return *this; } float& KRMat4::operator[](unsigned i) { - return m_mat[i]; + return c[i]; } float KRMat4::operator[](unsigned i) const { - return m_mat[i]; + return c[i]; } // Overload comparison operator bool KRMat4::operator==(const KRMat4 &m) { - return memcmp(m_mat, m.m_mat, sizeof(GLfloat) * 16) == 0; + return memcmp(c, m.c, sizeof(float) * 16) == 0; } // Overload compound multiply operator KRMat4& KRMat4::operator*=(const KRMat4 &m) { - GLfloat temp[16]; + float temp[16]; int x,y; @@ -101,14 +101,14 @@ KRMat4& KRMat4::operator*=(const KRMat4 &m) { { for(y=0; y < 4; y++) { - temp[y + (x*4)] = (m_mat[x*4] * m.m_mat[y]) + - (m_mat[(x*4)+1] * m.m_mat[y+4]) + - (m_mat[(x*4)+2] * m.m_mat[y+8]) + - (m_mat[(x*4)+3] * m.m_mat[y+12]); + temp[y + (x*4)] = (c[x*4] * m.c[y]) + + (c[(x*4)+1] * m.c[y+4]) + + (c[(x*4)+2] * m.c[y+8]) + + (c[(x*4)+3] * m.c[y+12]); } } - memcpy(m_mat, temp, sizeof(GLfloat) << 4); + memcpy(c, temp, sizeof(float) << 4); return *this; } @@ -122,36 +122,36 @@ KRMat4 KRMat4::operator*(const KRMat4 &m) const { /* Generate a perspective view matrix using a field of view angle fov, * window aspect ratio, near and far clipping planes */ -void KRMat4::perspective(GLfloat fov, GLfloat aspect, GLfloat nearz, GLfloat farz) { +void KRMat4::perspective(float fov, float aspect, float nearz, float farz) { - memset(m_mat, 0, sizeof(GLfloat) * 16); + memset(c, 0, sizeof(float) * 16); - GLfloat range= tan(fov * 0.5) * nearz; - m_mat[0] = (2 * nearz) / ((range * aspect) - (-range * aspect)); - m_mat[5] = (2 * nearz) / (2 * range); - m_mat[10] = -(farz + nearz) / (farz - nearz); - m_mat[11] = -1; - m_mat[14] = -(2 * farz * nearz) / (farz - nearz); + float range= tan(fov * 0.5) * nearz; + c[0] = (2 * nearz) / ((range * aspect) - (-range * aspect)); + c[5] = (2 * nearz) / (2 * range); + c[10] = -(farz + nearz) / (farz - nearz); + c[11] = -1; + c[14] = -(2 * farz * nearz) / (farz - nearz); /* - GLfloat range= atan(fov / 20.0f) * nearz; - GLfloat r = range * aspect; - GLfloat t = range * 1.0; + float range= atan(fov / 20.0f) * nearz; + float r = range * aspect; + float t = range * 1.0; - m_mat[0] = nearz / r; - m_mat[5] = nearz / t; - m_mat[10] = -(farz + nearz) / (farz - nearz); - m_mat[11] = -(2.0 * farz * nearz) / (farz - nearz); - m_mat[14] = -1.0; + c[0] = nearz / r; + c[5] = nearz / t; + c[10] = -(farz + nearz) / (farz - nearz); + c[11] = -(2.0 * farz * nearz) / (farz - nearz); + c[14] = -1.0; */ } /* Perform translation operations on a matrix */ -void KRMat4::translate(GLfloat x, GLfloat y, GLfloat z) { +void KRMat4::translate(float x, float y, float z) { KRMat4 newMatrix; // Create new identity matrix - newMatrix.m_mat[12] = x; - newMatrix.m_mat[13] = y; - newMatrix.m_mat[14] = z; + newMatrix.c[12] = x; + newMatrix.c[13] = y; + newMatrix.c[14] = z; *this *= newMatrix; } @@ -162,7 +162,7 @@ void KRMat4::translate(const KRVector3 &v) } /* Rotate a matrix by an angle on a X, Y, or Z axis */ -void KRMat4::rotate(GLfloat angle, AXIS axis) { +void KRMat4::rotate(float angle, AXIS axis) { const int cos1[3] = { 5, 0, 0 }; const int cos2[3] = { 10, 10, 5 }; const int sin1[3] = { 6, 2, 1 }; @@ -170,10 +170,10 @@ void KRMat4::rotate(GLfloat angle, AXIS axis) { KRMat4 newMatrix; // Create new identity matrix - newMatrix.m_mat[cos1[axis]] = cos(angle); - newMatrix.m_mat[sin1[axis]] = -sin(angle); - newMatrix.m_mat[sin2[axis]] = -newMatrix.m_mat[sin1[axis]]; - newMatrix.m_mat[cos2[axis]] = newMatrix.m_mat[cos1[axis]]; + newMatrix.c[cos1[axis]] = cos(angle); + newMatrix.c[sin1[axis]] = -sin(angle); + newMatrix.c[sin2[axis]] = -newMatrix.c[sin1[axis]]; + newMatrix.c[cos2[axis]] = newMatrix.c[cos1[axis]]; *this *= newMatrix; } @@ -184,12 +184,12 @@ void KRMat4::rotate(const KRQuaternion &q) } /* Scale matrix by separate x, y, and z amounts */ -void KRMat4::scale(GLfloat x, GLfloat y, GLfloat z) { +void KRMat4::scale(float x, float y, float z) { KRMat4 newMatrix; // Create new identity matrix - newMatrix.m_mat[0] = x; - newMatrix.m_mat[5] = y; - newMatrix.m_mat[10] = z; + newMatrix.c[0] = x; + newMatrix.c[5] = y; + newMatrix.c[10] = z; *this *= newMatrix; } @@ -199,30 +199,30 @@ void KRMat4::scale(const KRVector3 &v) { } /* Scale all dimensions equally */ -void KRMat4::scale(GLfloat s) { +void KRMat4::scale(float s) { scale(s,s,s); } // Initialize with a bias matrix void KRMat4::bias() { - static const GLfloat BIAS_MATRIX[] = { + static const float BIAS_MATRIX[] = { 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.5, 1.0 }; - memcpy(m_mat, BIAS_MATRIX, sizeof(GLfloat) * 16); + memcpy(c, BIAS_MATRIX, sizeof(float) * 16); } /* Generate an orthographic view matrix */ -void KRMat4::ortho(GLfloat left, GLfloat right, GLfloat top, GLfloat bottom, GLfloat nearz, GLfloat farz) { - memset(m_mat, 0, sizeof(GLfloat) * 16); - m_mat[0] = 2.0f / (right - left); - m_mat[5] = 2.0f / (bottom - top); - m_mat[10] = -1.0f / (farz - nearz); - m_mat[11] = -nearz / (farz - nearz); - m_mat[15] = 1.0f; +void KRMat4::ortho(float left, float right, float top, float bottom, float nearz, float farz) { + memset(c, 0, sizeof(float) * 16); + c[0] = 2.0f / (right - left); + c[5] = 2.0f / (bottom - top); + c[10] = -1.0f / (farz - nearz); + c[11] = -nearz / (farz - nearz); + c[15] = 1.0f; } /* Replace matrix with its inverse */ @@ -232,40 +232,40 @@ bool KRMat4::invert() { float inv[16], det; int i; - inv[0] = m_mat[5]*m_mat[10]*m_mat[15] - m_mat[5]*m_mat[11]*m_mat[14] - m_mat[9]*m_mat[6]*m_mat[15] - + m_mat[9]*m_mat[7]*m_mat[14] + m_mat[13]*m_mat[6]*m_mat[11] - m_mat[13]*m_mat[7]*m_mat[10]; - inv[4] = -m_mat[4]*m_mat[10]*m_mat[15] + m_mat[4]*m_mat[11]*m_mat[14] + m_mat[8]*m_mat[6]*m_mat[15] - - m_mat[8]*m_mat[7]*m_mat[14] - m_mat[12]*m_mat[6]*m_mat[11] + m_mat[12]*m_mat[7]*m_mat[10]; - inv[8] = m_mat[4]*m_mat[9]*m_mat[15] - m_mat[4]*m_mat[11]*m_mat[13] - m_mat[8]*m_mat[5]*m_mat[15] - + m_mat[8]*m_mat[7]*m_mat[13] + m_mat[12]*m_mat[5]*m_mat[11] - m_mat[12]*m_mat[7]*m_mat[9]; - inv[12] = -m_mat[4]*m_mat[9]*m_mat[14] + m_mat[4]*m_mat[10]*m_mat[13] + m_mat[8]*m_mat[5]*m_mat[14] - - m_mat[8]*m_mat[6]*m_mat[13] - m_mat[12]*m_mat[5]*m_mat[10] + m_mat[12]*m_mat[6]*m_mat[9]; - inv[1] = -m_mat[1]*m_mat[10]*m_mat[15] + m_mat[1]*m_mat[11]*m_mat[14] + m_mat[9]*m_mat[2]*m_mat[15] - - m_mat[9]*m_mat[3]*m_mat[14] - m_mat[13]*m_mat[2]*m_mat[11] + m_mat[13]*m_mat[3]*m_mat[10]; - inv[5] = m_mat[0]*m_mat[10]*m_mat[15] - m_mat[0]*m_mat[11]*m_mat[14] - m_mat[8]*m_mat[2]*m_mat[15] - + m_mat[8]*m_mat[3]*m_mat[14] + m_mat[12]*m_mat[2]*m_mat[11] - m_mat[12]*m_mat[3]*m_mat[10]; - inv[9] = -m_mat[0]*m_mat[9]*m_mat[15] + m_mat[0]*m_mat[11]*m_mat[13] + m_mat[8]*m_mat[1]*m_mat[15] - - m_mat[8]*m_mat[3]*m_mat[13] - m_mat[12]*m_mat[1]*m_mat[11] + m_mat[12]*m_mat[3]*m_mat[9]; - inv[13] = m_mat[0]*m_mat[9]*m_mat[14] - m_mat[0]*m_mat[10]*m_mat[13] - m_mat[8]*m_mat[1]*m_mat[14] - + m_mat[8]*m_mat[2]*m_mat[13] + m_mat[12]*m_mat[1]*m_mat[10] - m_mat[12]*m_mat[2]*m_mat[9]; - inv[2] = m_mat[1]*m_mat[6]*m_mat[15] - m_mat[1]*m_mat[7]*m_mat[14] - m_mat[5]*m_mat[2]*m_mat[15] - + m_mat[5]*m_mat[3]*m_mat[14] + m_mat[13]*m_mat[2]*m_mat[7] - m_mat[13]*m_mat[3]*m_mat[6]; - inv[6] = -m_mat[0]*m_mat[6]*m_mat[15] + m_mat[0]*m_mat[7]*m_mat[14] + m_mat[4]*m_mat[2]*m_mat[15] - - m_mat[4]*m_mat[3]*m_mat[14] - m_mat[12]*m_mat[2]*m_mat[7] + m_mat[12]*m_mat[3]*m_mat[6]; - inv[10] = m_mat[0]*m_mat[5]*m_mat[15] - m_mat[0]*m_mat[7]*m_mat[13] - m_mat[4]*m_mat[1]*m_mat[15] - + m_mat[4]*m_mat[3]*m_mat[13] + m_mat[12]*m_mat[1]*m_mat[7] - m_mat[12]*m_mat[3]*m_mat[5]; - inv[14] = -m_mat[0]*m_mat[5]*m_mat[14] + m_mat[0]*m_mat[6]*m_mat[13] + m_mat[4]*m_mat[1]*m_mat[14] - - m_mat[4]*m_mat[2]*m_mat[13] - m_mat[12]*m_mat[1]*m_mat[6] + m_mat[12]*m_mat[2]*m_mat[5]; - inv[3] = -m_mat[1]*m_mat[6]*m_mat[11] + m_mat[1]*m_mat[7]*m_mat[10] + m_mat[5]*m_mat[2]*m_mat[11] - - m_mat[5]*m_mat[3]*m_mat[10] - m_mat[9]*m_mat[2]*m_mat[7] + m_mat[9]*m_mat[3]*m_mat[6]; - inv[7] = m_mat[0]*m_mat[6]*m_mat[11] - m_mat[0]*m_mat[7]*m_mat[10] - m_mat[4]*m_mat[2]*m_mat[11] - + m_mat[4]*m_mat[3]*m_mat[10] + m_mat[8]*m_mat[2]*m_mat[7] - m_mat[8]*m_mat[3]*m_mat[6]; - inv[11] = -m_mat[0]*m_mat[5]*m_mat[11] + m_mat[0]*m_mat[7]*m_mat[9] + m_mat[4]*m_mat[1]*m_mat[11] - - m_mat[4]*m_mat[3]*m_mat[9] - m_mat[8]*m_mat[1]*m_mat[7] + m_mat[8]*m_mat[3]*m_mat[5]; - inv[15] = m_mat[0]*m_mat[5]*m_mat[10] - m_mat[0]*m_mat[6]*m_mat[9] - m_mat[4]*m_mat[1]*m_mat[10] - + m_mat[4]*m_mat[2]*m_mat[9] + m_mat[8]*m_mat[1]*m_mat[6] - m_mat[8]*m_mat[2]*m_mat[5]; + inv[0] = c[5]*c[10]*c[15] - c[5]*c[11]*c[14] - c[9]*c[6]*c[15] + + c[9]*c[7]*c[14] + c[13]*c[6]*c[11] - c[13]*c[7]*c[10]; + inv[4] = -c[4]*c[10]*c[15] + c[4]*c[11]*c[14] + c[8]*c[6]*c[15] + - c[8]*c[7]*c[14] - c[12]*c[6]*c[11] + c[12]*c[7]*c[10]; + inv[8] = c[4]*c[9]*c[15] - c[4]*c[11]*c[13] - c[8]*c[5]*c[15] + + c[8]*c[7]*c[13] + c[12]*c[5]*c[11] - c[12]*c[7]*c[9]; + inv[12] = -c[4]*c[9]*c[14] + c[4]*c[10]*c[13] + c[8]*c[5]*c[14] + - c[8]*c[6]*c[13] - c[12]*c[5]*c[10] + c[12]*c[6]*c[9]; + inv[1] = -c[1]*c[10]*c[15] + c[1]*c[11]*c[14] + c[9]*c[2]*c[15] + - c[9]*c[3]*c[14] - c[13]*c[2]*c[11] + c[13]*c[3]*c[10]; + inv[5] = c[0]*c[10]*c[15] - c[0]*c[11]*c[14] - c[8]*c[2]*c[15] + + c[8]*c[3]*c[14] + c[12]*c[2]*c[11] - c[12]*c[3]*c[10]; + inv[9] = -c[0]*c[9]*c[15] + c[0]*c[11]*c[13] + c[8]*c[1]*c[15] + - c[8]*c[3]*c[13] - c[12]*c[1]*c[11] + c[12]*c[3]*c[9]; + inv[13] = c[0]*c[9]*c[14] - c[0]*c[10]*c[13] - c[8]*c[1]*c[14] + + c[8]*c[2]*c[13] + c[12]*c[1]*c[10] - c[12]*c[2]*c[9]; + inv[2] = c[1]*c[6]*c[15] - c[1]*c[7]*c[14] - c[5]*c[2]*c[15] + + c[5]*c[3]*c[14] + c[13]*c[2]*c[7] - c[13]*c[3]*c[6]; + inv[6] = -c[0]*c[6]*c[15] + c[0]*c[7]*c[14] + c[4]*c[2]*c[15] + - c[4]*c[3]*c[14] - c[12]*c[2]*c[7] + c[12]*c[3]*c[6]; + inv[10] = c[0]*c[5]*c[15] - c[0]*c[7]*c[13] - c[4]*c[1]*c[15] + + c[4]*c[3]*c[13] + c[12]*c[1]*c[7] - c[12]*c[3]*c[5]; + inv[14] = -c[0]*c[5]*c[14] + c[0]*c[6]*c[13] + c[4]*c[1]*c[14] + - c[4]*c[2]*c[13] - c[12]*c[1]*c[6] + c[12]*c[2]*c[5]; + inv[3] = -c[1]*c[6]*c[11] + c[1]*c[7]*c[10] + c[5]*c[2]*c[11] + - c[5]*c[3]*c[10] - c[9]*c[2]*c[7] + c[9]*c[3]*c[6]; + inv[7] = c[0]*c[6]*c[11] - c[0]*c[7]*c[10] - c[4]*c[2]*c[11] + + c[4]*c[3]*c[10] + c[8]*c[2]*c[7] - c[8]*c[3]*c[6]; + inv[11] = -c[0]*c[5]*c[11] + c[0]*c[7]*c[9] + c[4]*c[1]*c[11] + - c[4]*c[3]*c[9] - c[8]*c[1]*c[7] + c[8]*c[3]*c[5]; + inv[15] = c[0]*c[5]*c[10] - c[0]*c[6]*c[9] - c[4]*c[1]*c[10] + + c[4]*c[2]*c[9] + c[8]*c[1]*c[6] - c[8]*c[2]*c[5]; - det = m_mat[0]*inv[0] + m_mat[1]*inv[4] + m_mat[2]*inv[8] + m_mat[3]*inv[12]; + det = c[0]*inv[0] + c[1]*inv[4] + c[2]*inv[8] + c[3]*inv[12]; if (det == 0) { return false; @@ -274,56 +274,82 @@ bool KRMat4::invert() { det = 1.0 / det; for (i = 0; i < 16; i++) { - m_mat[i] = inv[i] * det; + c[i] = inv[i] * det; } return true; } void KRMat4::transpose() { - GLfloat trans[16]; + float trans[16]; for(int x=0; x<4; x++) { for(int y=0; y<4; y++) { - trans[x + y * 4] = m_mat[y + x * 4]; + trans[x + y * 4] = c[y + x * 4]; } } - memcpy(m_mat, trans, sizeof(GLfloat) * 16); + memcpy(c, trans, sizeof(float) * 16); } /* Dot Product, returning KRVector3 */ KRVector3 KRMat4::Dot(const KRMat4 &m, const KRVector3 &v) { return KRVector3( - v.x * (float)m[0*4 + 0] + v.y * (float)m[1*4 + 0] + v.z * (float)m[2*4 + 0] + (float)m[3*4 + 0], - v.x * (float)m[0*4 + 1] + v.y * (float)m[1*4 + 1] + v.z * (float)m[2*4 + 1] + (float)m[3*4 + 1], - v.x * (float)m[0*4 + 2] + v.y * (float)m[1*4 + 2] + v.z * (float)m[2*4 + 2] + (float)m[3*4 + 2] + v.c[0] * m.c[0] + v.c[1] * m.c[4] + v.c[2] * m.c[8] + m.c[12], + v.c[0] * m.c[1] + v.c[1] * m.c[5] + v.c[2] * m.c[9] + m.c[13], + v.c[0] * m.c[2] + v.c[1] * m.c[6] + v.c[2] * m.c[10] + m.c[14] ); } +KRVector4 KRMat4::Dot4(const KRMat4 &m, const KRVector4 &v) { +#ifdef KRAKEN_USE_ARM_NEON + + KRVector4 d; + asm volatile ( + "vld1.32 {d0, d1}, [%1] \n\t" //Q0 = v + "vld1.32 {d18, d19}, [%0]! \n\t" //Q1 = m + "vld1.32 {d20, d21}, [%0]! \n\t" //Q2 = m+4 + "vld1.32 {d22, d23}, [%0]! \n\t" //Q3 = m+8 + "vld1.32 {d24, d25}, [%0]! \n\t" //Q4 = m+12 + + "vmul.f32 q13, q9, d0[0] \n\t" //Q5 = Q1*Q0[0] + "vmla.f32 q13, q10, d0[1] \n\t" //Q5 += Q1*Q0[1] + "vmla.f32 q13, q11, d1[0] \n\t" //Q5 += Q2*Q0[2] + "vmla.f32 q13, q12, d1[1] \n\t" //Q5 += Q3*Q0[3] + + "vst1.32 {d26, d27}, [%2] \n\t" //Q4 = m+12 + : /* no output registers */ + : "r"(m.c), "r"(v.c), "r"(d.c) + : "q0", "q9", "q10","q11", "q12", "q13", "memory" + ); + return d; +#else + return KRVector4( + v.c[0] * m.c[0] + v.c[1] * m.c[4] + v.c[2] * m.c[8] + m.c[12], + v.c[0] * m.c[1] + v.c[1] * m.c[5] + v.c[2] * m.c[9] + m.c[13], + v.c[0] * m.c[2] + v.c[1] * m.c[6] + v.c[2] * m.c[10] + m.c[14], + v.c[0] * m.c[3] + v.c[1] * m.c[7] + v.c[2] * m.c[11] + m.c[15] + ); +#endif +} + // Dot product without including translation; useful for transforming normals and tangents KRVector3 KRMat4::DotNoTranslate(const KRMat4 &m, const KRVector3 &v) { return KRVector3( - v.x * (float)m[0*4 + 0] + v.y * (float)m[1*4 + 0] + v.z * (float)m[2*4 + 0], - v.x * (float)m[0*4 + 1] + v.y * (float)m[1*4 + 1] + v.z * (float)m[2*4 + 1], - v.x * (float)m[0*4 + 2] + v.y * (float)m[1*4 + 2] + v.z * (float)m[2*4 + 2] + v.x * m.c[0] + v.y * m.c[4] + v.z * m.c[8], + v.x * m.c[1] + v.y * m.c[5] + v.z * m.c[9], + v.x * m.c[2] + v.y * m.c[6] + v.z * m.c[10] ); } /* Dot Product, returning w component as if it were a KRVector4 (This will be deprecated once KRVector4 is implemented instead*/ float KRMat4::DotW(const KRMat4 &m, const KRVector3 &v) { - return v.x * (float)m[0*4 + 3] + v.y * (float)m[1*4 + 3] + v.z * (float)m[2*4 + 3] + (float)m[3*4 + 3]; + return v.x * m.c[0*4 + 3] + v.y * m.c[1*4 + 3] + v.z * m.c[2*4 + 3] + m.c[3*4 + 3]; } /* Dot Product followed by W-divide */ KRVector3 KRMat4::DotWDiv(const KRMat4 &m, const KRVector3 &v) { - KRVector3 r = KRVector3( - v.x * (float)m[0*4 + 0] + v.y * (float)m[1*4 + 0] + v.z * (float)m[2*4 + 0] + (float)m[3*4 + 0], - v.x * (float)m[0*4 + 1] + v.y * (float)m[1*4 + 1] + v.z * (float)m[2*4 + 1] + (float)m[3*4 + 1], - v.x * (float)m[0*4 + 2] + v.y * (float)m[1*4 + 2] + v.z * (float)m[2*4 + 2] + (float)m[3*4 + 2] - ); - // Get W component, then divide x, y, and z by w. - r /= DotW(m, v); - return r; + KRVector4 r = Dot4(m, KRVector4(v, 1.0f)); + return KRVector3(r) / r.w; } KRMat4 KRMat4::LookAt(const KRVector3 &cameraPos, const KRVector3 &lookAtPos, const KRVector3 &upDirection) @@ -370,5 +396,5 @@ KRMat4 KRMat4::Transpose(const KRMat4 &m) void KRMat4::setUniform(GLint location) const { - if(location != -1) GLDEBUG(glUniformMatrix4fv(location, 1, GL_FALSE, m_mat)); + if(location != -1) GLDEBUG(glUniformMatrix4fv(location, 1, GL_FALSE, c)); } diff --git a/KREngine/kraken/KRMat4.h b/KREngine/kraken/KRMat4.h index e4036b4..7a4c18c 100644 --- a/KREngine/kraken/KRMat4.h +++ b/KREngine/kraken/KRMat4.h @@ -31,6 +31,7 @@ #include "KRVector3.h" +#include "KRVector4.h" #include "KREngine-common.h" @@ -58,14 +59,17 @@ class KRQuaternion; class KRMat4 { - GLfloat m_mat[16]; -public: + public: + + float c[16]; + + // Default constructor - Creates an identity matrix KRMat4(); - KRMat4(GLfloat *pMat); + KRMat4(float *pMat); KRMat4(const KRVector3 &axis_x, const KRVector3 &axis_y, const KRVector3 &axis_z, const KRVector3 &trans); @@ -91,16 +95,16 @@ public: //KRMat4& operator*(const KRMat4 &m); KRMat4 operator*(const KRMat4 &m) const; - GLfloat *getPointer(); + float *getPointer(); - void perspective(GLfloat fov, GLfloat aspect, GLfloat nearz, GLfloat farz); - void ortho(GLfloat left, GLfloat right, GLfloat top, GLfloat bottom, GLfloat nearz, GLfloat farz); - void translate(GLfloat x, GLfloat y, GLfloat z); + void perspective(float fov, float aspect, float nearz, float farz); + void ortho(float left, float right, float top, float bottom, float nearz, float farz); + void translate(float x, float y, float z); void translate(const KRVector3 &v); - void scale(GLfloat x, GLfloat y, GLfloat z); + void scale(float x, float y, float z); void scale(const KRVector3 &v); - void scale(GLfloat s); - void rotate(GLfloat angle, AXIS axis); + void scale(float s); + void rotate(float angle, AXIS axis); void rotate(const KRQuaternion &q); void bias(); bool invert(); @@ -110,6 +114,7 @@ public: static KRMat4 Invert(const KRMat4 &m); static KRMat4 Transpose(const KRMat4 &m); static KRVector3 Dot(const KRMat4 &m, const KRVector3 &v); + static KRVector4 Dot4(const KRMat4 &m, const KRVector4 &v); static float DotW(const KRMat4 &m, const KRVector3 &v); static KRVector3 DotWDiv(const KRMat4 &m, const KRVector3 &v); diff --git a/KREngine/kraken/KRMaterial.cpp b/KREngine/kraken/KRMaterial.cpp index ca50b99..46f90dc 100644 --- a/KREngine/kraken/KRMaterial.cpp +++ b/KREngine/kraken/KRMaterial.cpp @@ -212,7 +212,7 @@ bool KRMaterial::isTransparent() { return m_tr < 1.0 || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDONESIDE || m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE; } -bool KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, std::vector &lights, const std::vector &bones, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass) { +bool KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const std::vector &bones, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass) { bool bSameMaterial = *prevBoundMaterial == this; bool bLightMap = pLightMap && pCamera->settings.bEnableLightMap; @@ -249,11 +249,11 @@ bool KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC bool bAlphaBlend = (m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDONESIDE) || (m_alpha_mode == KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE); - KRShader *pShader = getContext().getShaderManager()->getShader("ObjectShader", pCamera, lights, bones.size(), bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_reflectionMapScale != default_scale && bReflectionMap, m_normalMapScale != default_scale && bNormalMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_reflectionMapOffset != default_offset && bReflectionMap, m_normalMapOffset != default_offset && bNormalMap, bAlphaTest, bAlphaBlend, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader("ObjectShader", pCamera, point_lights, directional_lights, spot_lights, bones.size(), bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, m_diffuseMapScale != default_scale && bDiffuseMap, m_specularMapScale != default_scale && bSpecMap, m_reflectionMapScale != default_scale && bReflectionMap, m_normalMapScale != default_scale && bNormalMap, m_diffuseMapOffset != default_offset && bDiffuseMap, m_specularMapOffset != default_offset && bSpecMap, m_reflectionMapOffset != default_offset && bReflectionMap, m_normalMapOffset != default_offset && bNormalMap, bAlphaTest, bAlphaBlend, renderPass); bool bSameShader = strcmp(pShader->getKey(), szPrevShaderKey) == 0; if(!bSameShader) { - if(!getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, matModel, lights, 0, renderPass)) { + if(!getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, matModel, point_lights, directional_lights, spot_lights, 0, renderPass)) { return false; } diff --git a/KREngine/kraken/KRMaterial.h b/KREngine/kraken/KRMaterial.h index 6a00fb9..8ff4259 100644 --- a/KREngine/kraken/KRMaterial.h +++ b/KREngine/kraken/KRMaterial.h @@ -83,7 +83,7 @@ public: bool isTransparent(); const std::string &getName() const; - bool bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, std::vector &lights, const std::vector &bones, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass); + bool bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const std::vector &bones, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass); private: std::string m_name; diff --git a/KREngine/kraken/KRMesh.cpp b/KREngine/kraken/KRMesh.cpp index 21e810b..970e8e1 100644 --- a/KREngine/kraken/KRMesh.cpp +++ b/KREngine/kraken/KRMesh.cpp @@ -132,7 +132,7 @@ void KRMesh::loadPack(KRDataBlock *data) { m_maxPoint = KRVector3(pHeader->maxx, pHeader->maxy, pHeader->maxz); } -void KRMesh::render(const std::string &object_name, KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass, const std::vector &bones) { +void KRMesh::render(const std::string &object_name, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass, const std::vector &bones) { //fprintf(stderr, "Rendering model: %s\n", m_name.c_str()); if(renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION && renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE) { @@ -184,7 +184,7 @@ void KRMesh::render(const std::string &object_name, KRCamera *pCamera, std::vect if(pMaterial != NULL && pMaterial == (*mat_itr)) { if((!pMaterial->isTransparent() && renderPass != KRNode::RENDER_PASS_FORWARD_TRANSPARENT) || (pMaterial->isTransparent() && renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) { - if(pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, lights, bones, viewport, matModel, pLightMap, renderPass)) { + if(pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, point_lights, directional_lights, spot_lights, bones, viewport, matModel, pLightMap, renderPass)) { switch(pMaterial->getAlphaMode()) { case KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE: // Non-transparent materials diff --git a/KREngine/kraken/KRMesh.h b/KREngine/kraken/KRMesh.h index e1cb49e..fef2786 100644 --- a/KREngine/kraken/KRMesh.h +++ b/KREngine/kraken/KRMesh.h @@ -83,7 +83,7 @@ public: } model_format_t; - void render(const std::string &object_name, KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass, const std::vector &bones); + void render(const std::string &object_name, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, const KRMat4 &matModel, KRTexture *pLightMap, KRNode::RenderPass renderPass, const std::vector &bones); std::string m_lodBaseName; diff --git a/KREngine/kraken/KRModel.cpp b/KREngine/kraken/KRModel.cpp index f781218..5155aad 100644 --- a/KREngine/kraken/KRModel.cpp +++ b/KREngine/kraken/KRModel.cpp @@ -93,10 +93,10 @@ void KRModel::loadModel() { } } -void KRModel::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { +void KRModel::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_ADDITIVE_PARTICLES && renderPass != KRNode::RENDER_PASS_PARTICLE_OCCLUSION && renderPass != KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) { loadModel(); @@ -141,7 +141,7 @@ void KRModel::render(KRCamera *pCamera, std::vector &lights, const KR matModel = KRQuaternion(KRVector3::Forward(), KRVector3::Normalize(camera_pos - model_center)).rotationMatrix() * matModel; } - pModel->render(getName(), pCamera, lights, viewport, matModel, m_pLightMap, renderPass, m_bones[pModel]); + pModel->render(getName(), pCamera, point_lights, directional_lights, spot_lights, viewport, matModel, m_pLightMap, renderPass, m_bones[pModel]); } } } diff --git a/KREngine/kraken/KRModel.h b/KREngine/kraken/KRModel.h index d312a8d..83aef1b 100644 --- a/KREngine/kraken/KRModel.h +++ b/KREngine/kraken/KRModel.h @@ -57,7 +57,7 @@ public: virtual std::string getElementName(); virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); virtual KRAABB getBounds(); diff --git a/KREngine/kraken/KRNode.cpp b/KREngine/kraken/KRNode.cpp index 1701582..cc572d0 100644 --- a/KREngine/kraken/KRNode.cpp +++ b/KREngine/kraken/KRNode.cpp @@ -261,7 +261,7 @@ KRNode *KRNode::LoadXML(KRScene &scene, tinyxml2::XMLElement *e) { return new_node; } -void KRNode::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, RenderPass renderPass) +void KRNode::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, RenderPass renderPass) { } diff --git a/KREngine/kraken/KRNode.h b/KREngine/kraken/KRNode.h index 9787f81..b167b10 100644 --- a/KREngine/kraken/KRNode.h +++ b/KREngine/kraken/KRNode.h @@ -25,6 +25,9 @@ class KRContext; class KRScene; class KRAABB; class KRNode; +class KRPointLight; +class KRSpotLight; +class KRDirectionalLight; class KRNode : public KRContextObject { @@ -101,7 +104,7 @@ public: KRScene &getScene(); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, RenderPass renderPass); virtual void physicsUpdate(float deltaTime); virtual bool hasPhysics(); diff --git a/KREngine/kraken/KRParticleSystem.h b/KREngine/kraken/KRParticleSystem.h index f938b32..c7e45e6 100644 --- a/KREngine/kraken/KRParticleSystem.h +++ b/KREngine/kraken/KRParticleSystem.h @@ -21,7 +21,7 @@ public: virtual KRAABB getBounds() = 0; - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) = 0; + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) = 0; protected: KRParticleSystem(KRScene &scene, std::string name); diff --git a/KREngine/kraken/KRParticleSystemNewtonian.cpp b/KREngine/kraken/KRParticleSystemNewtonian.cpp index 82c698e..7602fe4 100644 --- a/KREngine/kraken/KRParticleSystemNewtonian.cpp +++ b/KREngine/kraken/KRParticleSystemNewtonian.cpp @@ -54,10 +54,10 @@ bool KRParticleSystemNewtonian::hasPhysics() return true; } -void KRParticleSystemNewtonian::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { +void KRParticleSystemNewtonian::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); if(renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES) { if(viewport.visible(getBounds())) { @@ -72,9 +72,9 @@ void KRParticleSystemNewtonian::render(KRCamera *pCamera, std::vector int particle_count = 10000; - KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pParticleShader = m_pContext->getShaderManager()->getShader("dust_particle", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, getModelMatrix(), lights, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pParticleShader, viewport, getModelMatrix(), point_lights, directional_lights, spot_lights, 0, renderPass)) { if(pParticleShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE] != -1) { GLDEBUG(glUniform1f( pParticleShader->m_uniforms[KRShader::KRENGINE_UNIFORM_FLARE_SIZE], diff --git a/KREngine/kraken/KRParticleSystemNewtonian.h b/KREngine/kraken/KRParticleSystemNewtonian.h index 2ccc74f..2470db3 100644 --- a/KREngine/kraken/KRParticleSystemNewtonian.h +++ b/KREngine/kraken/KRParticleSystemNewtonian.h @@ -23,7 +23,7 @@ public: virtual KRAABB getBounds(); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); virtual void physicsUpdate(float deltaTime); diff --git a/KREngine/kraken/KRPointLight.cpp b/KREngine/kraken/KRPointLight.cpp index 607bb76..4275f9d 100644 --- a/KREngine/kraken/KRPointLight.cpp +++ b/KREngine/kraken/KRPointLight.cpp @@ -41,17 +41,17 @@ KRAABB KRPointLight::getBounds() { return KRAABB(KRVector3(-influence_radius), KRVector3(influence_radius), getModelMatrix()); } -void KRPointLight::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) +void KRPointLight::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRLight::render(pCamera, lights, viewport, renderPass); + KRLight::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); bool bVisualize = renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && pCamera->settings.bShowDeferred; if(renderPass == KRNode::RENDER_PASS_DEFERRED_LIGHTS || bVisualize) { // Lights are rendered on the second pass of the deferred renderer - std::vector this_light; + std::vector this_light; this_light.push_back(this); KRVector3 light_position = getLocalTranslation(); @@ -68,9 +68,9 @@ void KRPointLight::render(KRCamera *pCamera, std::vector &lights, con bool bInsideLight = view_light_position.sqrMagnitude() <= (influence_radius + pCamera->settings.getPerspectiveNearZ()) * (influence_radius + pCamera->settings.getPerspectiveNearZ()); - KRShader *pShader = getContext().getShaderManager()->getShader(bVisualize ? "visualize_overlay" : (bInsideLight ? "light_point_inside" : "light_point"), pCamera, this_light, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader(bVisualize ? "visualize_overlay" : (bInsideLight ? "light_point_inside" : "light_point"), pCamera, this_light, std::vector(), std::vector(), 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, this_light, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, this_light, std::vector(), std::vector(), 0, renderPass)) { diff --git a/KREngine/kraken/KRPointLight.h b/KREngine/kraken/KRPointLight.h index 34b84cb..f3ff0ec 100644 --- a/KREngine/kraken/KRPointLight.h +++ b/KREngine/kraken/KRPointLight.h @@ -22,7 +22,7 @@ public: virtual std::string getElementName(); virtual KRAABB getBounds(); - virtual void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + virtual void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); private: void generateMesh(); diff --git a/KREngine/kraken/KRReverbZone.cpp b/KREngine/kraken/KRReverbZone.cpp index 6f323e0..45e56a2 100644 --- a/KREngine/kraken/KRReverbZone.cpp +++ b/KREngine/kraken/KRReverbZone.cpp @@ -84,19 +84,19 @@ void KRReverbZone::setZone(const std::string &zone) m_zone = zone; } -void KRReverbZone::render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass) +void KRReverbZone::render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass) { - KRNode::render(pCamera, lights, viewport, renderPass); + KRNode::render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); bool bVisualize = false; if(renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT && bVisualize) { KRMat4 sphereModelMatrix = getModelMatrix(); - KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); + KRShader *pShader = getContext().getShaderManager()->getShader("visualize_overlay", pCamera, point_lights, directional_lights, spot_lights, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass); - if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, lights, 0, renderPass)) { + if(getContext().getShaderManager()->selectShader(*pCamera, pShader, viewport, sphereModelMatrix, point_lights, directional_lights, spot_lights, 0, renderPass)) { // Enable additive blending GLDEBUG(glEnable(GL_BLEND)); diff --git a/KREngine/kraken/KRReverbZone.h b/KREngine/kraken/KRReverbZone.h index a803e4a..4d1c117 100644 --- a/KREngine/kraken/KRReverbZone.h +++ b/KREngine/kraken/KRReverbZone.h @@ -21,7 +21,7 @@ public: virtual tinyxml2::XMLElement *saveXML( tinyxml2::XMLNode *parent); virtual void loadXML(tinyxml2::XMLElement *e); - void render(KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass); + void render(KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass); std::string getZone(); void setZone(const std::string &zone); diff --git a/KREngine/kraken/KRScene.cpp b/KREngine/kraken/KRScene.cpp index 8b72703..0c9f2dc 100644 --- a/KREngine/kraken/KRScene.cpp +++ b/KREngine/kraken/KRScene.cpp @@ -105,7 +105,9 @@ void KRScene::render(KRCamera *pCamera, std::unordered_map &visible addDefaultLights(); } - std::vector lights; + std::vector point_lights; + std::vectordirectional_lights; + std::vectorspot_lights; pCamera->settings.setSkyBox(m_skyBoxName); // This is temporary until the camera is moved into the scene graph @@ -115,16 +117,24 @@ void KRScene::render(KRCamera *pCamera, std::unordered_map &visible // Get lights from outer nodes (directional lights, which have no bounds) for(std::set::iterator itr=outerNodes.begin(); itr != outerNodes.end(); itr++) { KRNode *node = (*itr); - KRLight *light = dynamic_cast(node); - if(light) { - lights.push_back(light); + KRPointLight *point_light = dynamic_cast(node); + if(point_light) { + point_lights.push_back(point_light); + } + KRDirectionalLight *directional_light = dynamic_cast(node); + if(directional_light) { + directional_lights.push_back(directional_light); + } + KRSpotLight *spot_light = dynamic_cast(node); + if(spot_light) { + spot_lights.push_back(spot_light); } } // Render outer nodes for(std::set::iterator itr=outerNodes.begin(); itr != outerNodes.end(); itr++) { KRNode *node = (*itr); - node->render(pCamera, lights, viewport, renderPass); + node->render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); } std::vector remainingOctrees; @@ -140,10 +150,10 @@ void KRScene::render(KRCamera *pCamera, std::unordered_map &visible newRemainingOctrees.clear(); newRemainingOctreesTestResults.clear(); for(std::vector::iterator octree_itr = remainingOctrees.begin(); octree_itr != remainingOctrees.end(); octree_itr++) { - render(*octree_itr, visibleBounds, pCamera, lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false); + render(*octree_itr, visibleBounds, pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false); } for(std::vector::iterator octree_itr = remainingOctreesTestResults.begin(); octree_itr != remainingOctreesTestResults.end(); octree_itr++) { - render(*octree_itr, visibleBounds, pCamera, lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, true, false); + render(*octree_itr, visibleBounds, pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, true, false); } remainingOctrees = newRemainingOctrees; remainingOctreesTestResults = newRemainingOctreesTestResults; @@ -152,11 +162,11 @@ void KRScene::render(KRCamera *pCamera, std::unordered_map &visible newRemainingOctrees.clear(); newRemainingOctreesTestResults.clear(); for(std::vector::iterator octree_itr = remainingOctreesTestResultsOnly.begin(); octree_itr != remainingOctreesTestResultsOnly.end(); octree_itr++) { - render(*octree_itr, visibleBounds, pCamera, lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, true, true); + render(*octree_itr, visibleBounds, pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass, newRemainingOctrees, newRemainingOctreesTestResults, remainingOctreesTestResultsOnly, true, true); } } -void KRScene::render(KROctreeNode *pOctreeNode, std::unordered_map &visibleBounds, KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass, std::vector &remainingOctrees, std::vector &remainingOctreesTestResults, std::vector &remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly) +void KRScene::render(KROctreeNode *pOctreeNode, std::unordered_map &visibleBounds, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass, std::vector &remainingOctrees, std::vector &remainingOctreesTestResults, std::vector &remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly) { if(pOctreeNode) { @@ -284,7 +294,7 @@ void KRScene::render(KROctreeNode *pOctreeNode, std::unordered_map GLDEBUG(glDepthMask(GL_FALSE)); } - if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, lights, 0, viewport, matModel, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) { + if(getContext().getShaderManager()->selectShader("occlusion_test", *pCamera, point_lights, directional_lights, spot_lights, 0, viewport, matModel, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT)) { GLDEBUG(glDrawArrays(GL_TRIANGLE_STRIP, 0, 14)); m_pContext->getModelManager()->log_draw_call(renderPass, "octree", "occlusion_test", 14); } @@ -321,32 +331,50 @@ void KRScene::render(KROctreeNode *pOctreeNode, std::unordered_map if(bVisible) { // Add lights that influence this octree level and its children to the stack - int light_count = 0; + int directional_light_count = 0; + int spot_light_count = 0; + int point_light_count = 0; for(std::set::iterator itr=pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) { KRNode *node = (*itr); - KRLight *light = dynamic_cast(node); - if(light) { - lights.push_back(light); - light_count++; + KRDirectionalLight *directional_light = dynamic_cast(node); + if(directional_light) { + directional_lights.push_back(directional_light); + directional_light_count++; + } + KRSpotLight *spot_light = dynamic_cast(node); + if(spot_light) { + spot_lights.push_back(spot_light); + spot_light_count++; + } + KRPointLight *point_light = dynamic_cast(node); + if(point_light) { + point_lights.push_back(point_light); + point_light_count++; } } // Render objects that are at this octree level for(std::set::iterator itr=pOctreeNode->getSceneNodes().begin(); itr != pOctreeNode->getSceneNodes().end(); itr++) { //assert(pOctreeNode->getBounds().contains((*itr)->getBounds())); // Sanity check - (*itr)->render(pCamera, lights, viewport, renderPass); + (*itr)->render(pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass); } // Render child octrees const int *childOctreeOrder = renderPass == KRNode::RENDER_PASS_FORWARD_TRANSPARENT || renderPass == KRNode::RENDER_PASS_ADDITIVE_PARTICLES || renderPass == KRNode::RENDER_PASS_VOLUMETRIC_EFFECTS_ADDITIVE ? viewport.getBackToFrontOrder() : viewport.getFrontToBackOrder(); for(int i=0; i<8; i++) { - render(pOctreeNode->getChildren()[childOctreeOrder[i]], visibleBounds, pCamera, lights, viewport, renderPass, remainingOctrees, remainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false); + render(pOctreeNode->getChildren()[childOctreeOrder[i]], visibleBounds, pCamera, point_lights, directional_lights, spot_lights, viewport, renderPass, remainingOctrees, remainingOctreesTestResults, remainingOctreesTestResultsOnly, false, false); } // Remove lights added at this octree level from the stack - while(light_count--) { - lights.pop_back(); + while(directional_light_count--) { + directional_lights.pop_back(); + } + while(spot_light_count--) { + spot_lights.pop_back(); + } + while(point_light_count--) { + point_lights.pop_back(); } } } diff --git a/KREngine/kraken/KRScene.h b/KREngine/kraken/KRScene.h index 9de3306..dd7b2f9 100644 --- a/KREngine/kraken/KRScene.h +++ b/KREngine/kraken/KRScene.h @@ -69,7 +69,7 @@ public: void renderFrame(float deltaTime, int width, int height); void render(KRCamera *pCamera, std::unordered_map &visibleBounds, const KRViewport &viewport, KRNode::RenderPass renderPass, bool new_frame); - void render(KROctreeNode *pOctreeNode, std::unordered_map &visibleBounds, KRCamera *pCamera, std::vector &lights, const KRViewport &viewport, KRNode::RenderPass renderPass, std::vector &remainingOctrees, std::vector &remainingOctreesTestResults, std::vector &remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly); + void render(KROctreeNode *pOctreeNode, std::unordered_map &visibleBounds, KRCamera *pCamera, std::vector &point_lights, std::vector &directional_lights, std::vector&spot_lights, const KRViewport &viewport, KRNode::RenderPass renderPass, std::vector &remainingOctrees, std::vector &remainingOctreesTestResults, std::vector &remainingOctreesTestResultsOnly, bool bOcclusionResultsPass, bool bOcclusionTestResultsOnly); void updateOctree(const KRViewport &viewport); diff --git a/KREngine/kraken/KRShader.cpp b/KREngine/kraken/KRShader.cpp index c99168c..b02fc83 100644 --- a/KREngine/kraken/KRShader.cpp +++ b/KREngine/kraken/KRShader.cpp @@ -223,7 +223,7 @@ KRShader::~KRShader() { } } -bool KRShader::bind(KRCamera &camera, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &lights, const KRNode::RenderPass &renderPass) const { +bool KRShader::bind(KRCamera &camera, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, const KRNode::RenderPass &renderPass) const { if(m_iProgram == 0) { return false; } @@ -241,73 +241,67 @@ bool KRShader::bind(KRCamera &camera, const KRViewport &viewport, const KRMat4 & int light_spot_count = 0; // TODO - Need to support multiple lights and more light types in forward rendering if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) { - for(std::vector::const_iterator light_itr=lights.begin(); light_itr != lights.end(); light_itr++) { - KRLight *light = (*light_itr); - KRDirectionalLight *directional_light = dynamic_cast(light); - KRPointLight *point_light = dynamic_cast(light); - KRSpotLight *spot_light = dynamic_cast(light); - if(directional_light) { - if(light_directional_count == 0) { - int cShadowBuffers = directional_light->getShadowBufferCount(); - if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE1] != -1 && cShadowBuffers > 0) { - m_pContext->getTextureManager()->selectTexture(3, NULL); - m_pContext->getTextureManager()->_setActiveTexture(3); - GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[0])); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); - - m_pContext->getTextureManager()->_setWrapModeS(3, GL_CLAMP_TO_EDGE); - m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE); - } - - if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE2] != -1 && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) { - m_pContext->getTextureManager()->selectTexture(4, NULL); - m_pContext->getTextureManager()->_setActiveTexture(4); - GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[1])); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); - m_pContext->getTextureManager()->_setWrapModeS(4, GL_CLAMP_TO_EDGE); - m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE); - } - - if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE3] != -1 && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) { - m_pContext->getTextureManager()->selectTexture(5, NULL); - m_pContext->getTextureManager()->_setActiveTexture(5); - GLDEBUG(glActiveTexture(GL_TEXTURE5)); - GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[2])); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); - GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); - m_pContext->getTextureManager()->_setWrapModeS(5, GL_CLAMP_TO_EDGE); - m_pContext->getTextureManager()->_setWrapModeT(5, GL_CLAMP_TO_EDGE); - } + + + for(std::vector::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) { + KRDirectionalLight *directional_light = (*light_itr); + if(light_directional_count == 0) { + int cShadowBuffers = directional_light->getShadowBufferCount(); + if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE1] != -1 && cShadowBuffers > 0) { + m_pContext->getTextureManager()->selectTexture(3, NULL); + m_pContext->getTextureManager()->_setActiveTexture(3); + GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[0])); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); - KRMat4 matBias; - matBias.translate(1.0, 1.0, 1.0); - matBias.scale(0.5); - for(int iShadow=0; iShadow < cShadowBuffers; iShadow++) { - (matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias).setUniform(m_uniforms[KRENGINE_UNIFORM_SHADOWMVP1 + iShadow]); - } - - if(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE] != -1) { - KRMat4 inverseModelMatrix = matModel; - inverseModelMatrix.invert(); - - // Bind the light direction vector - KRVector3 lightDirObject = KRMat4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection()); - lightDirObject.normalize(); - lightDirObject.setUniform(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE]); - } + m_pContext->getTextureManager()->_setWrapModeS(3, GL_CLAMP_TO_EDGE); + m_pContext->getTextureManager()->_setWrapModeT(3, GL_CLAMP_TO_EDGE); } - light_directional_count++; - } - if(point_light) { - light_point_count++; - } - if(spot_light) { - light_spot_count++; + if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE2] != -1 && cShadowBuffers > 1 && camera.settings.m_cShadowBuffers > 1) { + m_pContext->getTextureManager()->selectTexture(4, NULL); + m_pContext->getTextureManager()->_setActiveTexture(4); + GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[1])); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); + m_pContext->getTextureManager()->_setWrapModeS(4, GL_CLAMP_TO_EDGE); + m_pContext->getTextureManager()->_setWrapModeT(4, GL_CLAMP_TO_EDGE); + } + + if(m_uniforms[KRENGINE_UNIFORM_SHADOWTEXTURE3] != -1 && cShadowBuffers > 2 && camera.settings.m_cShadowBuffers > 2) { + m_pContext->getTextureManager()->selectTexture(5, NULL); + m_pContext->getTextureManager()->_setActiveTexture(5); + GLDEBUG(glActiveTexture(GL_TEXTURE5)); + GLDEBUG(glBindTexture(GL_TEXTURE_2D, directional_light->getShadowTextures()[2])); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); + GLDEBUG(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)); + m_pContext->getTextureManager()->_setWrapModeS(5, GL_CLAMP_TO_EDGE); + m_pContext->getTextureManager()->_setWrapModeT(5, GL_CLAMP_TO_EDGE); + } + + KRMat4 matBias; + matBias.translate(1.0, 1.0, 1.0); + matBias.scale(0.5); + for(int iShadow=0; iShadow < cShadowBuffers; iShadow++) { + (matModel * directional_light->getShadowViewports()[iShadow].getViewProjectionMatrix() * matBias).setUniform(m_uniforms[KRENGINE_UNIFORM_SHADOWMVP1 + iShadow]); + } + + if(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE] != -1) { + KRMat4 inverseModelMatrix = matModel; + inverseModelMatrix.invert(); + + // Bind the light direction vector + KRVector3 lightDirObject = KRMat4::Dot(inverseModelMatrix, directional_light->getWorldLightDirection()); + lightDirObject.normalize(); + lightDirObject.setUniform(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION_MODEL_SPACE]); + } } + + light_directional_count++; } + + light_point_count = point_lights.size(); + light_spot_count = spot_lights.size(); } diff --git a/KREngine/kraken/KRShader.h b/KREngine/kraken/KRShader.h index 71d8206..6576af4 100644 --- a/KREngine/kraken/KRShader.h +++ b/KREngine/kraken/KRShader.h @@ -47,7 +47,7 @@ public: virtual ~KRShader(); const char *getKey() const; - bool bind(KRCamera &camera, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &lights, const KRNode::RenderPass &renderPass) const; + bool bind(KRCamera &camera, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, const KRNode::RenderPass &renderPass) const; enum { KRENGINE_UNIFORM_MATERIAL_AMBIENT = 0, diff --git a/KREngine/kraken/KRShaderManager.cpp b/KREngine/kraken/KRShaderManager.cpp index 0918ca1..d0c290d 100644 --- a/KREngine/kraken/KRShaderManager.cpp +++ b/KREngine/kraken/KRShaderManager.cpp @@ -48,7 +48,7 @@ KRShaderManager::~KRShaderManager() { } -KRShader *KRShaderManager::getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector &lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass) { +KRShader *KRShaderManager::getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass) { int iShadowQuality = 0; // FINDME - HACK - Placeholder code, need to iterate through lights and dynamically build shader @@ -57,29 +57,18 @@ KRShader *KRShaderManager::getShader(const std::string &shader_name, KRCamera *p int light_point_count = 0; int light_spot_count = 0; if(renderPass != KRNode::RENDER_PASS_DEFERRED_LIGHTS && renderPass != KRNode::RENDER_PASS_DEFERRED_GBUFFER && renderPass != KRNode::RENDER_PASS_DEFERRED_OPAQUE && renderPass != KRNode::RENDER_PASS_GENERATE_SHADOWMAPS) { - for(std::vector::const_iterator light_itr=lights.begin(); light_itr != lights.end(); light_itr++) { - KRLight *light = (*light_itr); - KRDirectionalLight *directional_light = dynamic_cast(light); - KRPointLight *point_light = dynamic_cast(light); - KRSpotLight *spot_light = dynamic_cast(light); - if(directional_light) { - iShadowQuality = directional_light->getShadowBufferCount(); - light_directional_count++; - } - if(point_light) light_point_count++; - if(spot_light) light_spot_count++; + light_directional_count = directional_lights.size(); + light_point_count = point_lights.size(); + light_spot_count = spot_lights.size(); + for(std::vector::const_iterator light_itr=directional_lights.begin(); light_itr != directional_lights.end(); light_itr++) { + KRDirectionalLight *directional_light =(*light_itr); + iShadowQuality = directional_light->getShadowBufferCount(); } } if(iShadowQuality > pCamera->settings.m_cShadowBuffers) { iShadowQuality = pCamera->settings.m_cShadowBuffers; } - /* - char szKey[256]; - sprintf(szKey, "%i_%i_%i_%i_%i_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d_%i_%s_%i_%d_%d_%f_%f_%f_%f_%f_%f_%f", light_directional_count, light_point_count, light_spot_count, bone_count, pCamera->settings.fog_type, pCamera->settings.bEnablePerPixel,bAlphaTest, bAlphaBlend, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, pCamera->settings.bDebugPSSM, iShadowQuality, pCamera->settings.bEnableAmbient, pCamera->settings.bEnableDiffuse, pCamera->settings.bEnableSpecular, bLightMap, bDiffuseMapScale, bSpecMapScale, bReflectionMapScale, bNormalMapScale, bDiffuseMapOffset, bSpecMapOffset, bReflectionMapOffset, bNormalMapOffset,pCamera->settings.volumetric_environment_enable && pCamera->settings.volumetric_environment_downsample != 0, renderPass, platform_shader_name.c_str(),pCamera->settings.dof_quality,pCamera->settings.bEnableFlash,pCamera->settings.bEnableVignette,pCamera->settings.dof_depth,pCamera->settings.dof_falloff,pCamera->settings.flash_depth,pCamera->settings.flash_falloff,pCamera->settings.flash_intensity,pCamera->settings.vignette_radius,pCamera->settings.vignette_falloff); - - KRShader *pShader = m_shaders[szKey]; - */ std::pair > key; key.first = shader_name; @@ -239,19 +228,19 @@ KRShader *KRShaderManager::getShader(const std::string &shader_name, KRCamera *p return pShader; } -bool KRShaderManager::selectShader(const std::string &shader_name, KRCamera &camera, const std::vector &lights, int bone_count, const KRViewport &viewport, const KRMat4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass) +bool KRShaderManager::selectShader(const std::string &shader_name, KRCamera &camera, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, const KRViewport &viewport, const KRMat4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass) { - KRShader *pShader = getShader(shader_name, &camera, lights, bone_count, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, bDiffuseMapScale, bSpecMapScale, bNormalMapScale, bReflectionMapScale, bDiffuseMapOffset, bSpecMapOffset, bNormalMapOffset, bReflectionMapOffset, bAlphaTest, bAlphaBlend, renderPass); - return selectShader(camera, pShader, viewport, matModel, lights, bone_count, renderPass); + KRShader *pShader = getShader(shader_name, &camera, point_lights, directional_lights, spot_lights, bone_count, bDiffuseMap, bNormalMap, bSpecMap, bReflectionMap, bReflectionCubeMap, bLightMap, bDiffuseMapScale, bSpecMapScale, bNormalMapScale, bReflectionMapScale, bDiffuseMapOffset, bSpecMapOffset, bNormalMapOffset, bReflectionMapOffset, bAlphaTest, bAlphaBlend, renderPass); + return selectShader(camera, pShader, viewport, matModel, point_lights, directional_lights, spot_lights, bone_count, renderPass); } -bool KRShaderManager::selectShader(KRCamera &camera, const KRShader *pShader, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &lights, int bone_count, const KRNode::RenderPass &renderPass) +bool KRShaderManager::selectShader(KRCamera &camera, const KRShader *pShader, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, const KRNode::RenderPass &renderPass) { if(pShader) { bool bSameShader = strcmp(pShader->getKey(), m_szCurrentShaderKey) == 0; if(!bSameShader || true) { // FINDME, HACK. Need to update logic to detect appropriate times to bind a new shader strcpy(m_szCurrentShaderKey, pShader->getKey()); - return pShader->bind(camera, viewport, matModel, lights, renderPass); + return pShader->bind(camera, viewport, matModel, point_lights, directional_lights, spot_lights, renderPass); } else { return true; } diff --git a/KREngine/kraken/KRShaderManager.h b/KREngine/kraken/KRShaderManager.h index 1f8383e..beb996e 100644 --- a/KREngine/kraken/KRShaderManager.h +++ b/KREngine/kraken/KRShaderManager.h @@ -58,11 +58,11 @@ public: const std::string &getVertShaderSource(const std::string &name); - KRShader *getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector &lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass); + KRShader *getShader(const std::string &shader_name, KRCamera *pCamera, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass); - bool selectShader(KRCamera &camera, const KRShader *pShader, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &lights, int bone_count, const KRNode::RenderPass &renderPass); + bool selectShader(KRCamera &camera, const KRShader *pShader, const KRViewport &viewport, const KRMat4 &matModel, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, const KRNode::RenderPass &renderPass); - bool selectShader(const std::string &shader_name, KRCamera &camera, const std::vector &lights, int bone_count, const KRViewport &viewport, const KRMat4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass); + bool selectShader(const std::string &shader_name, KRCamera &camera, const std::vector &point_lights, const std::vector &directional_lights, const std::vector&spot_lights, int bone_count, const KRViewport &viewport, const KRMat4 &matModel, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, bool bReflectionMap, bool bReflectionCubeMap, bool bLightMap, bool bDiffuseMapScale,bool bSpecMapScale, bool bNormalMapScale, bool bReflectionMapScale, bool bDiffuseMapOffset, bool bSpecMapOffset, bool bNormalMapOffset, bool bReflectionMapOffset, bool bAlphaTest, bool bAlphaBlend, KRNode::RenderPass renderPass); long getShaderHandlesUsed(); diff --git a/KREngine/kraken/KRVector2.h b/KREngine/kraken/KRVector2.h index ac74804..c71c6c3 100644 --- a/KREngine/kraken/KRVector2.h +++ b/KREngine/kraken/KRVector2.h @@ -37,7 +37,12 @@ class KRVector2 { public: - float x, y; + union { + struct { + float x, y; + }; + float c[2]; + }; KRVector2(); KRVector2(float X, float Y); diff --git a/KREngine/kraken/KRVector3.cpp b/KREngine/kraken/KRVector3.cpp index d46d959..60e2e6a 100644 --- a/KREngine/kraken/KRVector3.cpp +++ b/KREngine/kraken/KRVector3.cpp @@ -46,6 +46,12 @@ KRVector3::KRVector3(const KRVector3 &v) { z = v.z; } +KRVector3::KRVector3(const KRVector4 &v) { + x = v.x; + y = v.y; + z = v.z; +} + KRVector3::KRVector3(float *v) { x = v[0]; y = v[1]; @@ -144,6 +150,14 @@ KRVector3& KRVector3::operator =(const KRVector3& b) { z = b.z; return *this; } + +KRVector3& KRVector3::operator =(const KRVector4 &b) { + x = b.x; + y = b.y; + z = b.z; + return *this; +} + KRVector3 KRVector3::operator +(const KRVector3& b) const { return KRVector3(x + b.x, y + b.y, z + b.z); } diff --git a/KREngine/kraken/KRVector3.h b/KREngine/kraken/KRVector3.h index b33a134..60a259b 100644 --- a/KREngine/kraken/KRVector3.h +++ b/KREngine/kraken/KRVector3.h @@ -34,20 +34,29 @@ #include "KREngine-common.h" +class KRVector4; + class KRVector3 { public: - float x, y, z; + union { + struct { + float x, y, z; + }; + float c[3]; + }; KRVector3(); KRVector3(float X, float Y, float Z); KRVector3(float v); KRVector3(float *v); KRVector3(const KRVector3 &v); + KRVector3(const KRVector4 &v); ~KRVector3(); KRVector3& operator =(const KRVector3& b); + KRVector3& operator =(const KRVector4& b); KRVector3 operator +(const KRVector3& b) const; KRVector3 operator -(const KRVector3& b) const; KRVector3 operator +() const; diff --git a/KREngine/kraken/KRVector4.cpp b/KREngine/kraken/KRVector4.cpp index 7a9d5d3..a9c9531 100644 --- a/KREngine/kraken/KRVector4.cpp +++ b/KREngine/kraken/KRVector4.cpp @@ -48,6 +48,13 @@ KRVector4::KRVector4(const KRVector4 &v) { w = v.w; } +KRVector4::KRVector4(const KRVector3 &v, float W) { + x = v.x; + y = v.y; + z = v.z; + w = W; +} + KRVector4::KRVector4(float *v) { x = v[0]; y = v[1]; diff --git a/KREngine/kraken/KRVector4.h b/KREngine/kraken/KRVector4.h index 166a97a..4487605 100644 --- a/KREngine/kraken/KRVector4.h +++ b/KREngine/kraken/KRVector4.h @@ -34,16 +34,24 @@ #include "KREngine-common.h" +class KRVector3; + class KRVector4 { public: - float x, y, z, w; + union { + struct { + float x, y, z, w; + }; + float c[4]; + }; KRVector4(); KRVector4(float X, float Y, float Z, float W); KRVector4(float v); KRVector4(float *v); KRVector4(const KRVector4 &v); + KRVector4(const KRVector3 &v, float W); ~KRVector4(); diff --git a/KREngine/kraken/KRViewport.cpp b/KREngine/kraken/KRViewport.cpp index 13336fd..610405a 100644 --- a/KREngine/kraken/KRViewport.cpp +++ b/KREngine/kraken/KRViewport.cpp @@ -207,30 +207,29 @@ bool KRViewport::visible(const KRAABB &b) const int outside_count[6] = {0, 0, 0, 0, 0, 0}; for(int iCorner=0; iCorner<8; iCorner++) { - KRVector3 sourceCornerVertex = KRVector3( + KRVector4 sourceCornerVertex = KRVector4( (iCorner & 1) == 0 ? b.min.x : b.max.x, (iCorner & 2) == 0 ? b.min.y : b.max.y, - (iCorner & 4) == 0 ? b.min.z : b.max.z); + (iCorner & 4) == 0 ? b.min.z : b.max.z, 1.0f); - KRVector3 cornerVertex = KRMat4::Dot(m_matViewProjection, sourceCornerVertex); - float cornerVertexW = KRMat4::DotW(m_matViewProjection, sourceCornerVertex); + KRVector4 cornerVertex = KRMat4::Dot4(m_matViewProjection, sourceCornerVertex); - if(cornerVertex.x < -cornerVertexW) { + if(cornerVertex.x < -cornerVertex.w) { outside_count[0]++; } - if(cornerVertex.y < -cornerVertexW) { + if(cornerVertex.y < -cornerVertex.w) { outside_count[1]++; } - if(cornerVertex.z < -cornerVertexW) { + if(cornerVertex.z < -cornerVertex.w) { outside_count[2]++; } - if(cornerVertex.x > cornerVertexW) { + if(cornerVertex.x > cornerVertex.w) { outside_count[3]++; } - if(cornerVertex.y > cornerVertexW) { + if(cornerVertex.y > cornerVertex.w) { outside_count[4]++; } - if(cornerVertex.z > cornerVertexW) { + if(cornerVertex.z > cornerVertex.w) { outside_count[5]++; } }