kraken_engine/kraken
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Now using setUniform methods of KRMat4, KRVector3, and KRVector2 instead of direct glUniform calls

Browse Source 
--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%40131
This commit is contained in:
kearwood
2012-10-18 08:37:19 +00:00
parent 6358f7fcb9
commit 2aded76722
5 changed files with 34 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
KREngine/KREngine/Classes/KRCamera.cpp
View File

@@ -657,8 +657,7 @@ void KRCamera::renderShadowBuffer(KRScene &scene, int iShadow)
shadowShader->bind(this, matModel, matIdentity, matIdentity, vec4Temp, NULL, NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
GLDEBUG(glUniformMatrix4fv(shadowShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SHADOWMVP1], 1, GL_FALSE, shadowmvpmatrix[iShadow].getPointer()));
shadowmvpmatrix[iShadow].setUniform(shadowShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SHADOWMVP1]);
// Calculate the bounding volume of the light map
KRMat4 matInvShadow = shadowmvpmatrix[iShadow];

16
KREngine/KREngine/Classes/KRDirectionalLight.cpp
View File

@@ -71,20 +71,8 @@ void KRDirectionalLight::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &
KRShader *pShader = pContext->getShaderManager()->getShader("light_directional", pCamera, false, false, false, 0, false, false, false, false, false, false, false, false, false, false, false, false, false, renderPass);
if(pShader->bind(pCamera, m_modelMatrix, viewMatrix, mvpmatrix, lightDirection, pShadowMatrices, shadowDepthTextures, 0, renderPass)) {
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE],
light_direction_view_space.x,
light_direction_view_space.y,
light_direction_view_space.z
));
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR],
m_color.x,
m_color.y,
m_color.z
));
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]);
GLDEBUG(glUniform1f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_INTENSITY],

90
KREngine/KREngine/Classes/KRMaterial.cpp
View File

@@ -295,123 +295,61 @@ bool KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC
}
if(!bSameAmbient) {
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_AMBIENT],
m_ambientColor.x + pCamera->dAmbientR,
m_ambientColor.y + pCamera->dAmbientG,
m_ambientColor.z + pCamera->dAmbientB
));
(m_ambientColor + KRVector3(pCamera->dAmbientR, pCamera->dAmbientG, pCamera->dAmbientB)).setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_AMBIENT]);
}
if(!bSameDiffuse) {
if(renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE],
m_diffuseColor.x * pCamera->dSunR,
m_diffuseColor.y * pCamera->dSunG,
m_diffuseColor.z * pCamera->dSunB
));
KRVector3(m_diffuseColor.x * pCamera->dSunR, m_diffuseColor.y * pCamera->dSunG, m_diffuseColor.z * pCamera->dSunB).setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE]);
} else {
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE],
m_diffuseColor.x,
m_diffuseColor.y,
m_diffuseColor.z
));
m_diffuseColor.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_DIFFUSE]);
}
}
if(!bSameSpecular) {
if(renderPass == KRNode::RENDER_PASS_FORWARD_OPAQUE) {
// We pre-multiply the light color with the material color in the forward renderer
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR],
m_specularColor.x * pCamera->dSunR,
m_specularColor.y * pCamera->dSunG,
m_specularColor.z * pCamera->dSunB
));
KRVector3(m_specularColor.x * pCamera->dSunR, m_specularColor.y * pCamera->dSunG, m_specularColor.z * pCamera->dSunB).setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR]);
} else {
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR],
m_specularColor.x,
m_specularColor.y,
m_specularColor.z
));
m_specularColor.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SPECULAR]);
}
}
if(!bSameReflection) {
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_REFLECTION],
m_reflectionColor.x,
m_reflectionColor.y,
m_reflectionColor.z
));
m_reflectionColor.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_REFLECTION]);
}
if(bDiffuseMap && !bSameDiffuseScale && m_diffuseMapScale != default_scale) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE],
m_diffuseMapScale.x,
m_diffuseMapScale.y
));
m_diffuseMapScale.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_SCALE]);
}
if(bSpecMap && !bSameSpecularScale && m_specularMapScale != default_scale) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE],
m_specularMapScale.x,
m_specularMapScale.y
));
m_specularMapScale.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_SCALE]);
}
if(bReflectionMap && !bSameReflectionScale && m_reflectionMapScale != default_scale) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE],
m_reflectionMapScale.x,
m_reflectionMapScale.y
));
m_reflectionMapScale.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_SCALE]);
}
if(bNormalMap && !bSameNormalScale && m_normalMapScale != default_scale) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_SCALE],
m_normalMapScale.x,
m_normalMapScale.y
));
m_normalMapScale.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_SCALE]);
}
if(bDiffuseMap && !bSameDiffuseOffset && m_diffuseMapOffset != default_offset) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET],
m_diffuseMapOffset.x,
m_diffuseMapOffset.y
));
m_diffuseMapOffset.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_DIFFUSETEXTURE_OFFSET]);
}
if(bSpecMap && !bSameSpecularOffset && m_specularMapOffset != default_offset) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET],
m_specularMapOffset.x,
m_specularMapOffset.y
));
m_specularMapOffset.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SPECULARTEXTURE_OFFSET]);
}
if(bReflectionMap && !bSameReflectionOffset && m_reflectionMapOffset != default_offset) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET],
m_reflectionMapOffset.x,
m_reflectionMapOffset.y
));
m_reflectionMapOffset.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_REFLECTIONTEXTURE_OFFSET]);
}
if(bNormalMap && !bSameNormalOffset && m_normalMapOffset != default_offset) {
GLDEBUG(glUniform2f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET],
m_normalMapOffset.x,
m_normalMapOffset.y
));
m_normalMapOffset.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_NORMALTEXTURE_OFFSET]);
}
GLDEBUG(glUniform1f(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_ALPHA], m_tr));

18
KREngine/KREngine/Classes/KRPointLight.cpp
View File

@@ -75,13 +75,7 @@ void KRPointLight::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &viewMa
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR],
m_color.x,
m_color.y,
m_color.z
));
m_color.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_COLOR]);
GLDEBUG(glUniform1f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_INTENSITY],
@@ -98,15 +92,7 @@ void KRPointLight::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &viewMa
KRLIGHT_MIN_INFLUENCE
));
GLDEBUG(glUniform3f(
pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_POSITION],
light_position.x,
light_position.y,
light_position.z
));
light_position.setUniform(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_POSITION]);
if(bVisualize) {
// Enable additive blending

42
KREngine/KREngine/Classes/KRShader.cpp
View File

@@ -215,29 +215,29 @@ bool KRShader::bind(KRCamera *pCamera, KRMat4 &matModel, KRMat4 &matView, KRMat4
GLDEBUG(glUseProgram(m_iProgram));
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRENGINE_UNIFORM_MVP], 1, GL_FALSE, mvpMatrix.getPointer()));
mvpMatrix.setUniform(m_uniforms[KRENGINE_UNIFORM_MVP]);
KRMat4 matModelViewInverseTranspose = matView * matModel;
matModelViewInverseTranspose.transpose();
matModelViewInverseTranspose.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE], 1, GL_FALSE, matModelViewInverseTranspose.getPointer()));
matModelViewInverseTranspose.setUniform(m_uniforms[KRENGINE_UNIFORM_MODEL_VIEW_INVERSE_TRANSPOSE]);
KRMat4 matModelInverseTranspose = matModel;
matModelInverseTranspose.transpose();
matModelInverseTranspose.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE], 1, GL_FALSE, matModelInverseTranspose.getPointer()));
matModelInverseTranspose.setUniform(m_uniforms[KRENGINE_UNIFORM_MODEL_INVERSE_TRANSPOSE]);
KRMat4 matInvProjection;
matInvProjection = pCamera->getProjectionMatrix();
matInvProjection.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_INVP], 1, GL_FALSE, matInvProjection.getPointer()));
matInvProjection.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_INVP]);
KRMat4 matInvMVP = mvpMatrix;
matInvMVP.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP], 1, GL_FALSE, matInvMVP.getPointer()));
matInvMVP.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP]);
KRMat4 matInvMVPNoTranslate = matModel * matView;
// Remove the translation
@@ -250,27 +250,21 @@ bool KRShader::bind(KRCamera *pCamera, KRMat4 &matModel, KRMat4 &matView, KRMat4
matInvMVPNoTranslate.getPointer()[15] = 1.0;
matInvMVPNoTranslate = matInvMVPNoTranslate * pCamera->getProjectionMatrix();
matInvMVPNoTranslate.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE], 1, GL_FALSE, matInvMVPNoTranslate.getPointer()));
matInvMVPNoTranslate.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_INVMVP_NO_TRANSLATE]);
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_MODEL_MATRIX], 1, GL_FALSE, matModel.getPointer()));
matModel.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_MODEL_MATRIX]);
{
KRMat4 matModelToView2 = KRMat4() * matModel * matView;
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_M2V], 1, GL_FALSE, matModelToView2.getPointer()));
matModelToView2.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_M2V]);
KRVector3 view_space_model_origin = KRMat4::Dot(matModelToView2, KRVector3::Zero()); // Origin point of model space is the light source position. No perspective, so no w divide required
GLDEBUG(glUniform3f(
m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_POSITION_VIEW_SPACE],
view_space_model_origin.x,
view_space_model_origin.y,
view_space_model_origin.z
));
view_space_model_origin.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_LIGHT_POSITION_VIEW_SPACE]);
KRMat4 matViewToModel = matModelToView2;
matViewToModel.invert();
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRShader::KRENGINE_UNIFORM_V2M], 1, GL_FALSE, matViewToModel.getPointer()));
matViewToModel.setUniform(m_uniforms[KRShader::KRENGINE_UNIFORM_V2M]);
}
@@ -278,20 +272,10 @@ bool KRShader::bind(KRCamera *pCamera, KRMat4 &matModel, KRMat4 &matView, KRMat4
nLightDir.normalize();
// Bind the light direction vector
GLDEBUG(glUniform3f(
m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION],
(GLfloat)nLightDir.x,
(GLfloat)nLightDir.y,
(GLfloat)nLightDir.z
));
nLightDir.setUniform(m_uniforms[KRENGINE_UNIFORM_LIGHT_DIRECTION]);
// Bind the camera position, in model space
GLDEBUG(glUniform3f(
m_uniforms[KRENGINE_UNIFORM_CAMERAPOS],
(GLfloat)cameraPosition.x,
(GLfloat)cameraPosition.y,
(GLfloat)cameraPosition.z
));
cameraPosition.setUniform(m_uniforms[KRENGINE_UNIFORM_CAMERAPOS]);
GLDEBUG(glUniform4f(
m_uniforms[KRENGINE_UNIFORM_VIEWPORT],
@@ -303,7 +287,7 @@ bool KRShader::bind(KRCamera *pCamera, KRMat4 &matModel, KRMat4 &matView, KRMat4
// Bind the shadowmap space matrices
for(int iShadow=0; iShadow < cShadowBuffers; iShadow++) {
GLDEBUG(glUniformMatrix4fv(m_uniforms[KRENGINE_UNIFORM_SHADOWMVP1 + iShadow], 1, GL_FALSE, pShadowMatrices[iShadow].getPointer()));
pShadowMatrices[iShadow].setUniform(m_uniforms[KRENGINE_UNIFORM_SHADOWMVP1 + iShadow]);
}
// Sets the diffuseTexture variable to the first texture unit