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;
bEnableDiffuse = true;
bEnableSpecular = true;
bEnableShadowMap = false;
bDebugSuperShiny = false;
dAmbientR = 0.25f;
dAmbientG = 0.25f;
dAmbientB = 0.35f;

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

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

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

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

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

@@ -32,9 +32,11 @@
#include <iostream>
#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_modelMatrix = modelMatrix;
m_shadowMap = shadow_map;
m_pShadowMap = NULL;
}
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) {
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;
if(!bRenderShadowMap) {
projectionMatrix = pCamera->getProjectionMatrix();
@@ -62,7 +77,7 @@ void KRInstance::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager,
KRVector3 cameraPosObject = inverseModelMatrix.dot(cameraPosition);
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 {
public:
KRInstance(KRModel *pModel, const KRMat4 modelMatrix);
KRInstance(KRModel *pModel, const KRMat4 modelMatrix, std::string shadow_map);
~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);
@@ -58,6 +58,8 @@ public:
private:
KRModel *m_pModel;
KRMat4 m_modelMatrix;
KRTexture *m_pShadowMap;
std::string m_shadowMap;
};

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

@@ -142,8 +142,9 @@ bool KRMaterial::isTransparent() {
return m_tr != 0.0;
}
#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 bShadowMap = pShadowMap && pCamera->bEnableShadowMap;
if(!m_pAmbientMap && m_ambientMap.size()) {
m_pAmbientMap = pTextureManager->getTexture(m_ambientMap.c_str());
@@ -163,7 +164,7 @@ void KRMaterial::bind(KRMaterial **prevBoundMaterial, char *szPrevShaderKey, KRC
bool bSpecMap = m_pSpecularMap != NULL && pCamera->bEnableSpecMap;
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;
if(!bSameShader) {

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

@@ -72,7 +72,7 @@ public:
char *getName();
#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

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_NORMAL);
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));
@@ -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_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;
}
@@ -264,7 +265,7 @@ KRMesh::VertexData *KRMesh::getVertexData() {
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();
@@ -317,8 +318,13 @@ void KRMesh::LoadData(std::vector<KRVector3> vertices, std::vector<KRVector2> uv
}
if(uva.size() > iVertex) {
KRVector2 source_uva = uva[iVertex];
pVertex->texcoord.u = source_uva.x;
pVertex->texcoord.v = source_uva.y;
pVertex->uva.u = source_uva.x;
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) {
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) {
TexCoord st1; // = pVertex[2].texcoord;
TexCoord st2; // = pVertex[1].texcoord;
st1.u = pVertex[1].texcoord.u - pVertex[0].texcoord.u;
st1.v = pVertex[1].texcoord.v - pVertex[0].texcoord.v;
st2.u = pVertex[2].texcoord.u - pVertex[0].texcoord.u;
st2.v = pVertex[2].texcoord.v - pVertex[0].texcoord.v;
st1.u = pVertex[1].uva.u - pVertex[0].uva.u;
st1.v = pVertex[1].uva.v - pVertex[0].uva.v;
st2.u = pVertex[2].uva.u - pVertex[0].uva.u;
st2.v = pVertex[2].uva.v - pVertex[0].uva.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));

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

@@ -64,7 +64,7 @@ public:
virtual std::string getExtension();
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);
@@ -99,7 +99,8 @@ public:
Vertex3D vertex;
KRVector3D normal;
KRVector3D tangent;
TexCoord texcoord;
TexCoord uva;
TexCoord uvb;
} VertexData;
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;
int iPrevBuffer = -1;
char szPrevShaderKey[128];
@@ -79,7 +79,7 @@ void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, boo
if(pMaterial != NULL) {
if(pMaterial->isTransparent()) {
if(!pMaterial->isTransparent()) {
// Exclude transparent and semi-transparent meshes from shadow maps
m_pMesh->renderSubmesh(iSubmesh, &iPrevBuffer);
}
@@ -93,7 +93,7 @@ void KRModel::render(KRCamera *pCamera, KRMaterialManager *pMaterialManager, boo
KRMaterial *pMaterial = m_materials[iSubmesh];
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);
}
}

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

@@ -52,7 +52,7 @@ public:
KRModel(std::string path, KRMaterialManager *pMaterialManager);
~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();

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 ----====----
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);
}

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);
std::vector<KRVector3> vertices;
std::vector<KRVector2> uva;
std::vector<KRVector2> uvb;
std::vector<KRVector3> normals;
std::vector<KRVector3> tangents;
std::vector<int> submesh_lengths;
@@ -341,7 +342,7 @@ std::vector<KRResource *> KRResource::LoadObj(const std::string& path)
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();
clearExtents();
}
KRInstance *KRScene::addInstance(KRModel *pModel, KRMat4 modelMatrix) {
KRInstance *KRScene::addInstance(KRModel *pModel, KRMat4 modelMatrix, std::string shadow_map) {
clearExtents();
KRInstance *pInstance = new KRInstance(pModel, modelMatrix);
KRInstance *pInstance = new KRInstance(pModel, modelMatrix, shadow_map);
m_instances.push_back(pInstance);
return pInstance;
}

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

@@ -50,7 +50,7 @@ class KRScene {
public:
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);
KRBoundingVolume getExtents();
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.
// This needs to be done prior to linking.
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_NORMAL, "myNormal");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TANGENT, "myTangent");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUV, "myUV");
glBindAttribLocation(m_iProgram, KRENGINE_ATTRIB_TEXUVA, "myUV");
// Link program.
glLinkProgram(m_iProgram);

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

@@ -57,7 +57,8 @@ public:
KRENGINE_ATTRIB_VERTEX,
KRENGINE_ATTRIB_NORMAL,
KRENGINE_ATTRIB_TANGENT,
KRENGINE_ATTRIB_TEXUV,
KRENGINE_ATTRIB_TEXUVA,
KRENGINE_ATTRIB_TEXUVB,
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];
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 << "\n#define HAS_NORMAL_MAP " << (bNormalMap ? "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 DEBUG_PSSM " << (pCamera->bDebugPSSM ? "1" : "0");
stream << "\n#define SHADOW_QUALITY " << iShadowQuality;
stream << "\n#define ENABLE_AMBIENT " << (pCamera->bEnableAmbient ? "1" : "0");
stream << "\n#define ENABLE_DIFFUSE " << (pCamera->bEnableDiffuse ? "1" : "0");
stream << "\n#define ENABLE_SPECULAR " << (pCamera->bEnableSpecular ? "1" : "0");
stream.setf(ios::fixed,ios::floatfield);
stream << "\n";

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

@@ -50,7 +50,7 @@ public:
KRShaderManager(const GLchar *szVertShaderSource, const GLchar *szFragShaderSource);
~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:
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;
#endif
#if HAS_SHADOW_MAP == 1
uniform sampler2D shadowTexture1;
varying mediump vec2 shadowCoord;
#endif
#if SHADOW_QUALITY >= 2
uniform sampler2D shadowTexture2;
varying highp vec4 shadowMapCoord2;
@@ -176,6 +181,15 @@ void main()
gl_FragColor += vec4(material_specular * specularFactor, 0.0);
#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
}

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

@@ -32,6 +32,7 @@
attribute highp vec3 myVertex, myNormal;
attribute highp vec3 myTangent;
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 lowp vec3 material_ambient, material_diffuse, material_specular;
uniform highp vec3 lightDirection; // Must be normalized before entering shader
@@ -45,6 +46,11 @@ uniform mediump float material_shininess;
varying mediump vec2 texCoord;
#endif
#if HAS_SHADOW_MAP == 1
varying mediump vec2 shadowCoord;
#endif
#if ENABLE_PER_PIXEL == 1
varying mediump vec3 lightVec;
varying mediump vec3 halfVec;
@@ -81,6 +87,11 @@ void main()
texCoord = myUV.st;
#endif
#if HAS_SHADOW_MAP == 1
// Pass shadow UV co-ordinates
shadowCoord = shadowuv.st;
#endif
#if SHADOW_QUALITY >= 1
shadowMapCoord1 = myShadowMVPMatrix1 * vec4(myVertex,1.0);
#endif

2
objview/Classes/KRObjViewGLView.mm
View File

@@ -127,7 +127,7 @@
//m_scene.addInstance(pModelManager->getModel("fachwerkhaus12"), KRMat4());
//m_scene.addInstance(pModelManager->getModel("ballroom"), 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 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.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, "");
}
}