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

Light mapping implemented

Browse Source 
--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%4023
This commit is contained in:
kearwood
2012-03-29 19:39:28 +00:00
parent 35d138c31c
commit 5498499b51
23 changed files with 136 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -45,8 +45,10 @@ KRCamera::KRCamera() {
bEnableAmbient = true; bEnableAmbient = true;
bEnableDiffuse = true; bEnableDiffuse = true;
bEnableSpecular = true; bEnableSpecular = true;
bEnableShadowMap = false;
bDebugSuperShiny = false; bDebugSuperShiny = false;
dAmbientR = 0.25f; dAmbientR = 0.25f;
dAmbientG = 0.25f; dAmbientG = 0.25f;
dAmbientB = 0.35f; dAmbientB = 0.35f;

1
KREngine/KREngine/Classes/KRCamera.h
View File

@@ -47,6 +47,7 @@ public:
bool bEnableDiffuseMap; bool bEnableDiffuseMap;
bool bEnableNormalMap; bool bEnableNormalMap;
bool bEnableSpecMap; bool bEnableSpecMap;
bool bEnableShadowMap;
bool bDebugPSSM; bool bDebugPSSM;
bool bDebugSuperShiny; bool bDebugSuperShiny;
bool bShowShadowBuffer; bool bShowShadowBuffer;

76
KREngine/KREngine/Classes/KREngine.mm
View File

@@ -482,11 +482,12 @@ double const PI = 3.141592653589793f;
// Bind attribute locations. // Bind attribute locations.
// This needs to be done prior to linking. // This needs to be done prior to linking.
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_VERTEX, "position"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_VERTEX, "position");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUV, "inputTextureCoordinate"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUVA, "inputTextureCoordinate");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUVB, "shadowuv");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_VERTEX, "myVertex"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_VERTEX, "myVertex");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_NORMAL, "myNormal"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_NORMAL, "myNormal");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TANGENT, "myTangent"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TANGENT, "myTangent");
glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUV, "myUV"); glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUVA, "myUV");
// Link program. // Link program.
if (![self linkProgram:*programPointer]) if (![self linkProgram:*programPointer])
@@ -667,8 +668,8 @@ double const PI = 3.141592653589793f;
// Update attribute values. // Update attribute values.
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, squareVertices);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX);
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, 0, textureVertices); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, 0, textureVertices);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUV); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -692,8 +693,8 @@ double const PI = 3.141592653589793f;
// Update attribute values. // Update attribute values.
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, 0, textureVertices); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, 0, textureVertices);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUV); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA);
for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) { for(int iShadow=0; iShadow < m_cShadowBuffers; iShadow++) {
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
@@ -760,8 +761,8 @@ double const PI = 3.141592653589793f;
dTexScale * iCol + dTexScale, dTexScale * iRow dTexScale * iCol + dTexScale, dTexScale * iRow
}; };
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, 0, charTexCoords); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, 0, charTexCoords);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUV); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA);
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, charVertices); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 2, GL_FLOAT, 0, 0, charVertices);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX);
@@ -786,7 +787,7 @@ double const PI = 3.141592653589793f;
-(NSString *)getParameterNameWithIndex: (int)i -(NSString *)getParameterNameWithIndex: (int)i
{ {
NSString *parameter_names[30] = { NSString *parameter_names[31] = {
@"camera_fov", @"camera_fov",
@"sun_direction", @"sun_direction",
@"sun_attitude", @"sun_attitude",
@@ -795,6 +796,7 @@ double const PI = 3.141592653589793f;
@"enable_diffuse_map", @"enable_diffuse_map",
@"enable_normal_map", @"enable_normal_map",
@"enable_spec_map", @"enable_spec_map",
@"enable_shadow_map",
@"ambient_r", @"ambient_r",
@"ambient_g", @"ambient_g",
@"ambient_b", @"ambient_b",
@@ -822,7 +824,7 @@ double const PI = 3.141592653589793f;
} }
-(NSString *)getParameterLabelWithIndex: (int)i -(NSString *)getParameterLabelWithIndex: (int)i
{ {
NSString *parameter_labels[30] = { NSString *parameter_labels[31] = {
@"Camera FOV", @"Camera FOV",
@"Sun Direction", @"Sun Direction",
@"Sun Attitude", @"Sun Attitude",
@@ -831,6 +833,7 @@ double const PI = 3.141592653589793f;
@"Enable diffuse map", @"Enable diffuse map",
@"Enable normal map", @"Enable normal map",
@"Enable specular map", @"Enable specular map",
@"Enable shadow map",
@"Ambient light red intensity", @"Ambient light red intensity",
@"Ambient light green intensity", @"Ambient light green intensity",
@"Ambient light blue intensity", @"Ambient light blue intensity",
@@ -847,7 +850,7 @@ double const PI = 3.141592653589793f;
@"Enable Vignette", @"Enable Vignette",
@"Vignette Radius", @"Vignette Radius",
@"Vignette Falloff", @"Vignette Falloff",
@"Debug - View Shadow Map", @"Debug - View Shadow Volume",
@"Debug - PSSM", @"Debug - PSSM",
@"Debug - Enable Ambient", @"Debug - Enable Ambient",
@"Debug - Enable Diffuse", @"Debug - Enable Diffuse",
@@ -858,7 +861,7 @@ double const PI = 3.141592653589793f;
} }
-(KREngineParameterType)getParameterTypeWithIndex: (int)i -(KREngineParameterType)getParameterTypeWithIndex: (int)i
{ {
KREngineParameterType types[30] = { KREngineParameterType types[31] = {
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
@@ -867,6 +870,7 @@ double const PI = 3.141592653589793f;
KRENGINE_PARAMETER_BOOL, KRENGINE_PARAMETER_BOOL,
KRENGINE_PARAMETER_BOOL, KRENGINE_PARAMETER_BOOL,
KRENGINE_PARAMETER_BOOL, KRENGINE_PARAMETER_BOOL,
KRENGINE_PARAMETER_BOOL,
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
KRENGINE_PARAMETER_FLOAT, KRENGINE_PARAMETER_FLOAT,
@@ -894,7 +898,7 @@ double const PI = 3.141592653589793f;
} }
-(double)getParameterValueWithIndex: (int)i -(double)getParameterValueWithIndex: (int)i
{ {
double values[30] = { double values[31] = {
m_camera.perspective_fov, m_camera.perspective_fov,
sun_yaw, sun_yaw,
sun_pitch, sun_pitch,
@@ -903,6 +907,7 @@ double const PI = 3.141592653589793f;
m_camera.bEnableDiffuseMap ? 1.0f : 0.0f, m_camera.bEnableDiffuseMap ? 1.0f : 0.0f,
m_camera.bEnableNormalMap ? 1.0f : 0.0f, m_camera.bEnableNormalMap ? 1.0f : 0.0f,
m_camera.bEnableSpecMap ? 1.0f : 0.0f, m_camera.bEnableSpecMap ? 1.0f : 0.0f,
m_camera.bEnableShadowMap ? 1.0f : 0.0f,
m_camera.dAmbientR, m_camera.dAmbientR,
m_camera.dAmbientG, m_camera.dAmbientG,
m_camera.dAmbientB, m_camera.dAmbientB,
@@ -964,109 +969,112 @@ double const PI = 3.141592653589793f;
m_camera.bEnableSpecMap = bNewBoolVal; m_camera.bEnableSpecMap = bNewBoolVal;
break; break;
case 8: case 8:
m_camera.dAmbientR = v; m_camera.bEnableShadowMap = bNewBoolVal;
break; break;
case 9: case 9:
m_camera.dAmbientG = v; m_camera.dAmbientR = v;
break; break;
case 10: case 10:
m_camera.dAmbientB = v; m_camera.dAmbientG = v;
break; break;
case 11: case 11:
m_camera.dSunR = v; m_camera.dAmbientB = v;
break; break;
case 12: case 12:
m_camera.dSunG = v; m_camera.dSunR = v;
break; break;
case 13: case 13:
m_camera.dSunB = v; m_camera.dSunG = v;
break; break;
case 14: case 14:
m_camera.dSunB = v;
break;
case 15:
if(m_camera.dof_quality != (int)v) { if(m_camera.dof_quality != (int)v) {
m_camera.dof_quality = (int)v; m_camera.dof_quality = (int)v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 15: case 16:
if(m_camera.dof_depth != v) { if(m_camera.dof_depth != v) {
m_camera.dof_depth = v; m_camera.dof_depth = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 16: case 17:
if(m_camera.dof_falloff != v) { if(m_camera.dof_falloff != v) {
m_camera.dof_falloff = v; m_camera.dof_falloff = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 17: case 18:
if(m_camera.bEnableFlash != bNewBoolVal) { if(m_camera.bEnableFlash != bNewBoolVal) {
m_camera.bEnableFlash = bNewBoolVal; m_camera.bEnableFlash = bNewBoolVal;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 18: case 19:
if(m_camera.flash_intensity != v) { if(m_camera.flash_intensity != v) {
m_camera.flash_intensity = v; m_camera.flash_intensity = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 19: case 20:
if(m_camera.flash_depth != v) { if(m_camera.flash_depth != v) {
m_camera.flash_depth = v; m_camera.flash_depth = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 20: case 21:
if(m_camera.flash_falloff != v) { if(m_camera.flash_falloff != v) {
m_camera.flash_falloff = v; m_camera.flash_falloff = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 21: case 22:
if(m_camera.bEnableVignette != bNewBoolVal) { if(m_camera.bEnableVignette != bNewBoolVal) {
m_camera.bEnableVignette = bNewBoolVal; m_camera.bEnableVignette = bNewBoolVal;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 22: case 23:
if(m_camera.vignette_radius != v) { if(m_camera.vignette_radius != v) {
m_camera.vignette_radius = v; m_camera.vignette_radius = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 23: case 24:
if(m_camera.vignette_falloff != v) { if(m_camera.vignette_falloff != v) {
m_camera.vignette_falloff = v; m_camera.vignette_falloff = v;
[self invalidatePostShader]; [self invalidatePostShader];
} }
break; break;
case 24: case 25:
if(m_camera.bShowShadowBuffer != bNewBoolVal) { if(m_camera.bShowShadowBuffer != bNewBoolVal) {
m_camera.bShowShadowBuffer = bNewBoolVal; m_camera.bShowShadowBuffer = bNewBoolVal;
} }
break; break;
case 25: case 26:
if(m_camera.bDebugPSSM != bNewBoolVal) { if(m_camera.bDebugPSSM != bNewBoolVal) {
m_camera.bDebugPSSM = bNewBoolVal; m_camera.bDebugPSSM = bNewBoolVal;
} }
break; break;
case 26: case 27:
if(m_camera.bEnableAmbient != bNewBoolVal) { if(m_camera.bEnableAmbient != bNewBoolVal) {
m_camera.bEnableAmbient = bNewBoolVal; m_camera.bEnableAmbient = bNewBoolVal;
} }
break; break;
case 27: case 28:
if(m_camera.bEnableDiffuse != bNewBoolVal) { if(m_camera.bEnableDiffuse != bNewBoolVal) {
m_camera.bEnableDiffuse = bNewBoolVal; m_camera.bEnableDiffuse = bNewBoolVal;
} }
break; break;
case 28: case 29:
if(m_camera.bEnableSpecular != bNewBoolVal) { if(m_camera.bEnableSpecular != bNewBoolVal) {
m_camera.bEnableSpecular = bNewBoolVal; m_camera.bEnableSpecular = bNewBoolVal;
} }
break; break;
case 29: case 30:
if(m_camera.bDebugSuperShiny != bNewBoolVal) { if(m_camera.bDebugSuperShiny != bNewBoolVal) {
m_camera.bDebugSuperShiny = bNewBoolVal; m_camera.bDebugSuperShiny = bNewBoolVal;
} }

19
KREngine/KREngine/Classes/KRInstance.cpp
View File

@@ -32,9 +32,11 @@
#include <iostream> #include <iostream>
#import "KRInstance.h" #import "KRInstance.h"
KRInstance::KRInstance(KRModel *pModel, const KRMat4 modelMatrix) { KRInstance::KRInstance(KRModel *pModel, const KRMat4 modelMatrix, std::string shadow_map) {
m_pModel = pModel; m_pModel = pModel;
m_modelMatrix = modelMatrix; m_modelMatrix = modelMatrix;
m_shadowMap = shadow_map;
m_pShadowMap = NULL;
} }
KRInstance::~KRInstance() { KRInstance::~KRInstance() {
@@ -50,6 +52,19 @@ KRModel *KRInstance::getModel() {
void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) { void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) {
if(m_pShadowMap == NULL && m_shadowMap.size()) {
m_pShadowMap = pTextureManager->getTexture(m_shadowMap.c_str());
}
if(cShadowBuffers == 0 && m_pShadowMap && pCamera->bEnableShadowMap && !bRenderShadowMap) {
int iTextureName = m_pShadowMap->getName();
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, iTextureName);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}
KRMat4 projectionMatrix; KRMat4 projectionMatrix;
if(!bRenderShadowMap) { if(!bRenderShadowMap) {
projectionMatrix = pCamera->getProjectionMatrix(); projectionMatrix = pCamera->getProjectionMatrix();
@@ -62,7 +77,7 @@ void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager,
KRVector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition); KRVector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition);
KRVector3 lightDirObject = inverseModelMatrix.dot(lightDirection); KRVector3 lightDirObject = inverseModelMatrix.dot(lightDirection);
m_pModel->render(pCamera, pMaterialManager, bRenderShadowMap, mvpmatrix, cameraPosObject, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager); m_pModel->render(pCamera, pMaterialManager, bRenderShadowMap, mvpmatrix, cameraPosObject, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager, m_pShadowMap);
} }

4
KREngine/KREngine/Classes/KRInstance.h
View File

@@ -46,7 +46,7 @@ class KRBoundingVolume;
class KRInstance { class KRInstance {
public: public:
KRInstance(KRModel *pModel, const KRMat4 modelMatrix); KRInstance(KRModel *pModel, const KRMat4 modelMatrix, std::string shadow_map);
~KRInstance(); ~KRInstance();
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager); void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager);
@@ -58,6 +58,8 @@ public:
private: private:
KRModel *m_pModel; KRModel *m_pModel;
KRMat4 m_modelMatrix; KRMat4 m_modelMatrix;
KRTexture *m_pShadowMap;
std::string m_shadowMap;
}; };

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

@@ -142,8 +142,9 @@ bool KRMaterial::isTransparent() {
return m_tr != 0.0; return m_tr != 0.0;
} }
#if TARGET_OS_IPHONE #if TARGET_OS_IPHONE
void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) { void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pShadowMap) {
bool bSameMaterial = *prevBoundMaterial == this; bool bSameMaterial = *prevBoundMaterial == this;
bool bShadowMap = pShadowMap && pCamera->bEnableShadowMap;
if(!m_pAmbientMap && m_ambientMap.size()) { if(!m_pAmbientMap && m_ambientMap.size()) {
m_pAmbientMap = pTextureManager->getTexture(m_ambientMap.c_str()); m_pAmbientMap = pTextureManager->getTexture(m_ambientMap.c_str());
@@ -163,12 +164,12 @@ void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC
bool bSpecMap = m_pSpecularMap != NULL && pCamera->bEnableSpecMap; bool bSpecMap = m_pSpecularMap != NULL && pCamera->bEnableSpecMap;
if(!bSameMaterial) { if(!bSameMaterial) {
KRShader *pShader = pShaderManager->getShader(pCamera, bDiffuseMap, bNormalMap, bSpecMap, cShadowBuffers); KRShader *pShader = pShaderManager->getShader(pCamera, bDiffuseMap, bNormalMap, bSpecMap, cShadowBuffers, bShadowMap);
bool bSameShader = strcmp(pShader->getKey(), szPrevShaderKey) == 0; bool bSameShader = strcmp(pShader->getKey(), szPrevShaderKey) == 0;
if(!bSameShader) { if(!bSameShader) {
pShader->bind(pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers); pShader->bind(pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers);
glUniform1f(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SHININESS], pCamera->bDebugSuperShiny ? 20.0 : m_ns); glUniform1f(pShader->m_uniforms[KRShader::KRENGINE_UNIFORM_MATERIAL_SHININESS], pCamera->bDebugSuperShiny ? 20.0 : m_ns );
strcpy(szPrevShaderKey, pShader->getKey()); strcpy(szPrevShaderKey, pShader->getKey());
} }

2
KREngine/KREngine/Classes/KRMaterial.h
View File

@@ -72,7 +72,7 @@ public:
char *getName(); char *getName();
#if TARGET_OS_IPHONE #if TARGET_OS_IPHONE
void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager); void bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRCamera *pCamera, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pShadowMap);
#endif #endif

26
KREngine/KREngine/Classes/KRMesh.cpp
View File

@@ -231,7 +231,8 @@ void KRMesh::renderSubmesh(int iSubmesh, int *iPrevBuffer) {
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_VERTEX);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_NORMAL); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_NORMAL);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TANGENT); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TANGENT);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUV); glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVA);
glEnableVertexAttribArray(KRShader::KRENGINE_ATTRIB_TEXUVB);
} }
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(0)); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_VERTEX, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(0));
@@ -240,8 +241,8 @@ void KRMesh::renderSubmesh(int iSubmesh, int *iPrevBuffer) {
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D))); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TANGENT, 3, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D)));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUV, 2, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D) * 2)); glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVA, 2, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D) * 2));
glVertexAttribPointer(KRShader::KRENGINE_ATTRIB_TEXUVB, 2, GL_FLOAT, 0, sizeof(VertexData), BUFFER_OFFSET(sizeof(Vertex3D) + sizeof(KRVector3D) * 2 + sizeof(TexCoord)));
*iPrevBuffer = iBuffer; *iPrevBuffer = iBuffer;
} }
@@ -264,7 +265,7 @@ KRMesh::VertexData *KRMesh::getVertexData() {
return (VertexData *)(pPackMaterials + pHeader->submesh_count); return (VertexData *)(pPackMaterials + pHeader->submesh_count);
} }
void KRMesh::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names) { void KRMesh::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector2> uvb, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names) {
clearData(); clearData();
@@ -317,8 +318,13 @@ void KRMesh::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uv
} }
if(uva.size() > iVertex) { if(uva.size() > iVertex) {
KRVector2 source_uva = uva[iVertex]; KRVector2 source_uva = uva[iVertex];
pVertex->texcoord.u = source_uva.x; pVertex->uva.u = source_uva.x;
pVertex->texcoord.v = source_uva.y; pVertex->uva.v = source_uva.y;
}
if(uvb.size() > iVertex) {
KRVector2 source_uvb = uvb[iVertex];
pVertex->uvb.u = source_uvb.x;
pVertex->uvb.v = source_uvb.y;
} }
if(normals.size() > iVertex) { if(normals.size() > iVertex) {
KRVector3 source_normal = normals[iVertex]; KRVector3 source_normal = normals[iVertex];
@@ -380,10 +386,10 @@ void KRMesh::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uv
if(pVertex->tangent.x == 0 && pVertex->tangent.y == 0 && pVertex->tangent.z == 0) { if(pVertex->tangent.x == 0 && pVertex->tangent.y == 0 && pVertex->tangent.z == 0) {
TexCoord st1; // = pVertex[2].texcoord; TexCoord st1; // = pVertex[2].texcoord;
TexCoord st2; // = pVertex[1].texcoord; TexCoord st2; // = pVertex[1].texcoord;
st1.u = pVertex[1].texcoord.u - pVertex[0].texcoord.u; st1.u = pVertex[1].uva.u - pVertex[0].uva.u;
st1.v = pVertex[1].texcoord.v - pVertex[0].texcoord.v; st1.v = pVertex[1].uva.v - pVertex[0].uva.v;
st2.u = pVertex[2].texcoord.u - pVertex[0].texcoord.u; st2.u = pVertex[2].uva.u - pVertex[0].uva.u;
st2.v = pVertex[2].texcoord.v - pVertex[0].texcoord.v; st2.v = pVertex[2].uva.v - pVertex[0].uva.v;
double coef = 1/ (st1.u * st2.v - st2.u * st1.v); double coef = 1/ (st1.u * st2.v - st2.u * st1.v);
pVertex[0].tangent.x = coef * ((v1.x * st2.v) + (v2.x * -st1.v)); pVertex[0].tangent.x = coef * ((v1.x * st2.v) + (v2.x * -st1.v));

5
KREngine/KREngine/Classes/KRMesh.h
View File

@@ -64,7 +64,7 @@ public:
virtual std::string getExtension(); virtual std::string getExtension();
virtual bool save(const std::string& path); virtual bool save(const std::string& path);
void LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names); void LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uva, std::vector<KRVector2> uvb, std::vector<KRVector3> normals, std::vector<KRVector3> tangents, std::vector<int> submesh_starts, std::vector<int> submesh_lengths, std::vector<std::string> material_names);
void loadPack(std::string path); void loadPack(std::string path);
@@ -99,7 +99,8 @@ public:
Vertex3D vertex; Vertex3D vertex;
KRVector3D normal; KRVector3D normal;
KRVector3D tangent; KRVector3D tangent;
TexCoord texcoord; TexCoord uva;
TexCoord uvb;
} VertexData; } VertexData;
VertexData *getVertexData(); VertexData *getVertexData();

6
KREngine/KREngine/Classes/KRModel.cpp
View File

@@ -67,7 +67,7 @@ KRModel::~KRModel() {
} }
void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager) { void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pShadowMap) {
KRMaterial *pPrevBoundMaterial = NULL; KRMaterial *pPrevBoundMaterial = NULL;
int iPrevBuffer = -1; int iPrevBuffer = -1;
char szPrevShaderKey[128]; char szPrevShaderKey[128];
@@ -79,7 +79,7 @@ void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, boo
if(pMaterial != NULL) { if(pMaterial != NULL) {
if(pMaterial->isTransparent()) { if(!pMaterial->isTransparent()) {
// Exclude transparent and semi-transparent meshes from shadow maps // Exclude transparent and semi-transparent meshes from shadow maps
m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer); m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer);
} }
@@ -93,7 +93,7 @@ void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, boo
KRMaterial *pMaterial = m_materials[iSubmesh]; KRMaterial *pMaterial = m_materials[iSubmesh];
if(pMaterial != NULL && pMaterial == (*mat_itr)) { if(pMaterial != NULL && pMaterial == (*mat_itr)) {
pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager); pMaterial->bind(&pPrevBoundMaterial, szPrevShaderKey, pCamera, mvpMatrix, cameraPosition, lightDirection, pShadowMatrices, shadowDepthTextures, cShadowBuffers, pShaderManager, pTextureManager, pShadowMap);
m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer); m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer);
} }
} }

2
KREngine/KREngine/Classes/KRModel.h
View File

@@ -52,7 +52,7 @@ public:
KRModel(std::string path, KRMaterialManager *pMaterialManager); KRModel(std::string path, KRMaterialManager *pMaterialManager);
~KRModel(); ~KRModel();
void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager); void render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &mvpMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager, KRTexture *pShadowMap);
KRMesh *getMesh(); KRMesh *getMesh();

2
KREngine/KREngine/Classes/KRResource+fbx.cpp
View File

@@ -572,7 +572,7 @@ void LoadMesh(std::vector<KRResource *> &resources, KFbxGeometryConverter *pGeom
// ----====---- Generate Output Mesh Object ----====---- // ----====---- Generate Output Mesh Object ----====----
KRMesh *new_mesh = new KRMesh(pNode->GetName()); KRMesh *new_mesh = new KRMesh(pNode->GetName());
new_mesh->LoadData(vertices, uva, normals, tangents, submesh_starts, submesh_lengths, material_names); new_mesh->LoadData(vertices, uva, uvb, normals, tangents, submesh_starts, submesh_lengths, material_names);
resources.push_back(new_mesh); resources.push_back(new_mesh);
} }

3
KREngine/KREngine/Classes/KRResource+obj.cpp
View File

@@ -28,6 +28,7 @@ std::vector<KRResource *> KRResource::LoadObj(const std::string& path)
resources.push_back(new_mesh); resources.push_back(new_mesh);
std::vector<KRVector3> vertices; std::vector<KRVector3> vertices;
std::vector<KRVector2> uva; std::vector<KRVector2> uva;
std::vector<KRVector2> uvb;
std::vector<KRVector3> normals; std::vector<KRVector3> normals;
std::vector<KRVector3> tangents; std::vector<KRVector3> tangents;
std::vector<int> submesh_lengths; std::vector<int> submesh_lengths;
@@ -341,7 +342,7 @@ std::vector<KRResource *> KRResource::LoadObj(const std::string& path)
delete pNewMaterial; delete pNewMaterial;
} }
new_mesh->LoadData(vertices, uva, normals, tangents, submesh_starts, submesh_lengths, material_names); new_mesh->LoadData(vertices, uva, uvb, normals, tangents, submesh_starts, submesh_lengths, material_names);
} }
} }
} }

4
KREngine/KREngine/Classes/KRScene.cpp
View File

@@ -46,9 +46,9 @@ KRScene::~KRScene() {
m_instances.empty(); m_instances.empty();
clearExtents(); clearExtents();
} }
KRInstance *KRScene::addInstance(KRModel *pModel, KRMat4 modelMatrix) { KRInstance *KRScene::addInstance(KRModel *pModel, KRMat4 modelMatrix, std::string shadow_map) {
clearExtents(); clearExtents();
KRInstance *pInstance = new KRInstance(pModel, modelMatrix); KRInstance *pInstance = new KRInstance(pModel, modelMatrix, shadow_map);
m_instances.push_back(pInstance); m_instances.push_back(pInstance);
return pInstance; return pInstance;
} }

2
KREngine/KREngine/Classes/KRScene.h
View File

@@ -50,7 +50,7 @@ class KRScene {
public: public:
KRScene(); KRScene();
~KRScene(); ~KRScene();
KRInstance *addInstance(KRModel *pModel, KRMat4 modelMatrix); KRInstance *addInstance(KRModel *pModel, KRMat4 modelMatrix, std::string shadow_map);
void render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager); void render(KRCamera *pCamera, KRBoundingVolume &frustrumVolume, KRMaterialManager *pMaterialManager, bool bRenderShadowMap, KRMat4 &viewMatrix, KRVector3 &cameraPosition, KRVector3 &lightDirection, KRMat4 *pShadowMatrices, GLuint *shadowDepthTextures, int cShadowBuffers, KRShaderManager *pShaderManager, KRTextureManager *pTextureManager);
KRBoundingVolume getExtents(); KRBoundingVolume getExtents();
private: private:

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

@@ -61,11 +61,12 @@ KRShader::KRShader(char *szKey, std::string options, const GLchar *szVertShaderS
// Bind attribute locations. // Bind attribute locations.
// This needs to be done prior to linking. // This needs to be done prior to linking.
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_VERTEX, "position"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_VERTEX, "position");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUV, "inputTextureCoordinate"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVA, "inputTextureCoordinate");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVB, "shadowuv");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_VERTEX, "myVertex"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_VERTEX, "myVertex");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_NORMAL, "myNormal"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_NORMAL, "myNormal");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TANGENT, "myTangent"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TANGENT, "myTangent");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUV, "myUV"); glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVA, "myUV");
// Link program. // Link program.
glLinkProgram(m_iProgram); glLinkProgram(m_iProgram);

3
KREngine/KREngine/Classes/KRShader.h
View File

@@ -57,7 +57,8 @@ public:
KRENGINE_ATTRIB_VERTEX, KRENGINE_ATTRIB_VERTEX,
KRENGINE_ATTRIB_NORMAL, KRENGINE_ATTRIB_NORMAL,
KRENGINE_ATTRIB_TANGENT, KRENGINE_ATTRIB_TANGENT,
KRENGINE_ATTRIB_TEXUV, KRENGINE_ATTRIB_TEXUVA,
KRENGINE_ATTRIB_TEXUVB,
KRENGINE_NUM_ATTRIBUTES KRENGINE_NUM_ATTRIBUTES
}; };

6
KREngine/KREngine/Classes/KRShaderManager.cpp
View File

@@ -47,10 +47,10 @@ KRShaderManager::~KRShaderManager() {
} }
KRShader *KRShaderManager::getShader(KRCamera *pCamera, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, int iShadowQuality) { KRShader *KRShaderManager::getShader(KRCamera *pCamera, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, int iShadowQuality, bool bShadowMap) {
char szKey[128]; char szKey[128];
sprintf(szKey, "%d_%d_%d_%d_%d_%d_%d_%d_%d", pCamera->bEnablePerPixel, bDiffuseMap, bNormalMap, bSpecMap, pCamera->bDebugPSSM, iShadowQuality, /*pCamera->dAmbientR, pCamera->dAmbientG, pCamera->dAmbientB, pCamera->dSunR, pCamera->dSunG, pCamera->dSunB, */pCamera->bEnableAmbient, pCamera->bEnableDiffuse, pCamera->bEnableSpecular); sprintf(szKey, "%d_%d_%d_%d_%d_%d_%d_%d_%d_%d", pCamera->bEnablePerPixel, bDiffuseMap, bNormalMap, bSpecMap, pCamera->bDebugPSSM, iShadowQuality, /*pCamera->dAmbientR, pCamera->dAmbientG, pCamera->dAmbientB, pCamera->dSunR, pCamera->dSunG, pCamera->dSunB, */pCamera->bEnableAmbient, pCamera->bEnableDiffuse, pCamera->bEnableSpecular, bShadowMap);
/* /*
@@ -72,12 +72,14 @@ KRShader *KRShaderManager::getShader(KRCamera *pCamera, bool bDiffuseMap, bool b
stream << "#define HAS_DIFFUSE_MAP " << (bDiffuseMap ? "1" : "0"); stream << "#define HAS_DIFFUSE_MAP " << (bDiffuseMap ? "1" : "0");
stream << "\n#define HAS_NORMAL_MAP " << (bNormalMap ? "1" : "0"); stream << "\n#define HAS_NORMAL_MAP " << (bNormalMap ? "1" : "0");
stream << "\n#define HAS_SPEC_MAP " << (bSpecMap ? "1" : "0"); stream << "\n#define HAS_SPEC_MAP " << (bSpecMap ? "1" : "0");
stream << "\n#define HAS_SHADOW_MAP " << (bShadowMap ? "1" : "0");
stream << "\n#define ENABLE_PER_PIXEL " << (pCamera->bEnablePerPixel ? "1" : "0"); stream << "\n#define ENABLE_PER_PIXEL " << (pCamera->bEnablePerPixel ? "1" : "0");
stream << "\n#define DEBUG_PSSM " << (pCamera->bDebugPSSM ? "1" : "0"); stream << "\n#define DEBUG_PSSM " << (pCamera->bDebugPSSM ? "1" : "0");
stream << "\n#define SHADOW_QUALITY " << iShadowQuality; stream << "\n#define SHADOW_QUALITY " << iShadowQuality;
stream << "\n#define ENABLE_AMBIENT " << (pCamera->bEnableAmbient ? "1" : "0"); stream << "\n#define ENABLE_AMBIENT " << (pCamera->bEnableAmbient ? "1" : "0");
stream << "\n#define ENABLE_DIFFUSE " << (pCamera->bEnableDiffuse ? "1" : "0"); stream << "\n#define ENABLE_DIFFUSE " << (pCamera->bEnableDiffuse ? "1" : "0");
stream << "\n#define ENABLE_SPECULAR " << (pCamera->bEnableSpecular ? "1" : "0"); stream << "\n#define ENABLE_SPECULAR " << (pCamera->bEnableSpecular ? "1" : "0");
stream.setf(ios::fixed,ios::floatfield); stream.setf(ios::fixed,ios::floatfield);
stream << "\n"; stream << "\n";

2
KREngine/KREngine/Classes/KRShaderManager.h
View File

@@ -50,7 +50,7 @@ public:
KRShaderManager(const GLchar *szVertShaderSource, const GLchar *szFragShaderSource); KRShaderManager(const GLchar *szVertShaderSource, const GLchar *szFragShaderSource);
~KRShaderManager(); ~KRShaderManager();
KRShader *getShader(KRCamera *pCamera, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, int iShadowQuality); KRShader *getShader(KRCamera *pCamera, bool bDiffuseMap, bool bNormalMap, bool bSpecMap, int iShadowQuality, bool bShadowMap);
private: private:
std::map<std::string, KRShader *> m_shaders; std::map<std::string, KRShader *> m_shaders;

14
KREngine/KREngine/Shaders/ObjectShader.fsh
View File

@@ -49,6 +49,11 @@ uniform sampler2D shadowTexture1;
varying highp vec4 shadowMapCoord1; varying highp vec4 shadowMapCoord1;
#endif #endif
#if HAS_SHADOW_MAP == 1
uniform sampler2D shadowTexture1;
varying mediump vec2 shadowCoord;
#endif
#if SHADOW_QUALITY >= 2 #if SHADOW_QUALITY >= 2
uniform sampler2D shadowTexture2; uniform sampler2D shadowTexture2;
varying highp vec4 shadowMapCoord2; varying highp vec4 shadowMapCoord2;
@@ -175,6 +180,15 @@ void main()
#else #else
gl_FragColor += vec4(material_specular * specularFactor, 0.0); gl_FragColor += vec4(material_specular * specularFactor, 0.0);
#endif #endif
// -------------------- Multiply shadow map --------------------
#if HAS_SHADOW_MAP
mediump vec3 shadowColor = vec3(texture2D(shadowTexture1, shadowCoord));
gl_FragColor = vec4(gl_FragColor.r * shadowColor.r, gl_FragColor.g * shadowColor.g, gl_FragColor.b * shadowColor.b, 1.0);
// gl_FragColor = vec4(shadowColor, 1.0);
// gl_FragColor = vec4(shadowCoord.s, shadowCoord.t, 1.0, 1.0);
#endif
#endif #endif

11
KREngine/KREngine/Shaders/ObjectShader.vsh
View File

@@ -32,6 +32,7 @@
attribute highp vec3 myVertex, myNormal; attribute highp vec3 myVertex, myNormal;
attribute highp vec3 myTangent; attribute highp vec3 myTangent;
attribute mediump vec2 myUV; attribute mediump vec2 myUV;
attribute mediump vec2 shadowuv;
uniform highp mat4 myMVPMatrix, myShadowMVPMatrix1,myShadowMVPMatrix2,myShadowMVPMatrix3; // mvpmatrix is the result of multiplying the model, view, and projection matrices uniform highp mat4 myMVPMatrix, myShadowMVPMatrix1,myShadowMVPMatrix2,myShadowMVPMatrix3; // mvpmatrix is the result of multiplying the model, view, and projection matrices
// uniform lowp vec3 material_ambient, material_diffuse, material_specular; // uniform lowp vec3 material_ambient, material_diffuse, material_specular;
uniform highp vec3 lightDirection; // Must be normalized before entering shader uniform highp vec3 lightDirection; // Must be normalized before entering shader
@@ -45,6 +46,11 @@ uniform mediump float material_shininess;
varying mediump vec2 texCoord; varying mediump vec2 texCoord;
#endif #endif
#if HAS_SHADOW_MAP == 1
varying mediump vec2 shadowCoord;
#endif
#if ENABLE_PER_PIXEL == 1 #if ENABLE_PER_PIXEL == 1
varying mediump vec3 lightVec; varying mediump vec3 lightVec;
varying mediump vec3 halfVec; varying mediump vec3 halfVec;
@@ -81,6 +87,11 @@ void main()
texCoord = myUV.st; texCoord = myUV.st;
#endif #endif
#if HAS_SHADOW_MAP == 1
// Pass shadow UV co-ordinates
shadowCoord = shadowuv.st;
#endif
#if SHADOW_QUALITY >= 1 #if SHADOW_QUALITY >= 1
shadowMapCoord1 = myShadowMVPMatrix1 * vec4(myVertex,1.0); shadowMapCoord1 = myShadowMVPMatrix1 * vec4(myVertex,1.0);
#endif #endif

2
objview/Classes/KRObjViewGLView.mm
View File

@@ -127,7 +127,7 @@
//m_scene.addInstance(pModelManager->getModel("fachwerkhaus12"), KRMat4()); //m_scene.addInstance(pModelManager->getModel("fachwerkhaus12"), KRMat4());
//m_scene.addInstance(pModelManager->getModel("ballroom"), KRMat4()); //m_scene.addInstance(pModelManager->getModel("ballroom"), KRMat4());
//m_scene.addInstance(pModelManager->getModel("HoganCombined"), KRMat4()); //m_scene.addInstance(pModelManager->getModel("HoganCombined"), KRMat4());
m_scene.addInstance(pModelManager->getModel("degagetest"), KRMat4()); m_scene.addInstance(pModelManager->getModel("polySurface12848"), KRMat4(), "PillarLightmap1k");
[renderEngine setNearZ: 25.0]; [renderEngine setNearZ: 25.0];
[renderEngine setFarZ: 5000.0]; [renderEngine setFarZ: 5000.0];

2
objview/Classes/KRObjViewViewController.mm
View File

@@ -231,7 +231,7 @@
pos.rotate((double)rand() / (double)RAND_MAX * 6.282, Y_AXIS); pos.rotate((double)rand() / (double)RAND_MAX * 6.282, Y_AXIS);
pos.translate((double)rand() / (double)RAND_MAX * 10000 - 5000, 0.0, (double)rand() / (double)RAND_MAX * 10000 - 5000); pos.translate((double)rand() / (double)RAND_MAX * 10000 - 5000, 0.0, (double)rand() / (double)RAND_MAX * 10000 - 5000);
scene->addInstance(pModelManager->getModel(szName), pos); scene->addInstance(pModelManager->getModel(szName), pos, "");
} }
} }