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

Updated for XCode 4.5

Browse Source 
Cleanup and removal of redundant shader compiling and validation code

--HG--
extra : convert_revision : svn%3A7752d6cf-9f14-4ad2-affc-04f1e67b81a5/trunk%40101
This commit is contained in:
kearwood
2012-09-20 08:16:59 +00:00
parent 9f4608a888
commit 96c5b62e26
13 changed files with 397 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
KREngine/KREngine.xcodeproj/project.pbxproj
View File

@@ -948,7 +948,7 @@
GCC_VERSION = com.apple.compilers.llvmgcc42;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
IPHONEOS_DEPLOYMENT_TARGET = 4.3;
IPHONEOS_DEPLOYMENT_TARGET = 5.0;
MACOSX_DEPLOYMENT_TARGET = 10.7;
SDKROOT = iphoneos;
SKIP_INSTALL = YES;
@@ -963,7 +963,7 @@
GCC_VERSION = com.apple.compilers.llvmgcc42;
GCC_WARN_ABOUT_RETURN_TYPE = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
IPHONEOS_DEPLOYMENT_TARGET = 4.3;
IPHONEOS_DEPLOYMENT_TARGET = 5.0;
MACOSX_DEPLOYMENT_TARGET = 10.7;
SDKROOT = iphoneos;
SKIP_INSTALL = YES;

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

@@ -448,7 +448,6 @@ void KRCamera::createBuffers() {
GLDEBUG(glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, lightAccumulationTexture, 0));
allocateShadowBuffers();
loadShaders();
}
void KRCamera::allocateShadowBuffers() {
@@ -544,26 +543,19 @@ void KRCamera::renderShadowBuffer(KRScene &scene, int iShadow)
GLDEBUG(glDisable(GL_BLEND));
// Use shader program
GLDEBUG(glUseProgram(m_shadowShaderProgram));
KRShader *shadowShader = m_pContext->getShaderManager()->getShader("ShadowShader", this, false, false, false, 0, false, false, false, false, false, false, false, false, false, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
KRMat4 matIdentity; // Value not used by postshader
KRVector3 vec4Temp; // Value not used by postshader
shadowShader->bind(this, matIdentity, matIdentity, m_position, vec4Temp, NULL, NULL, 0, KRNode::RENDER_PASS_FORWARD_TRANSPARENT);
// Sets the diffuseTexture variable to the first texture unit
/*
glUniform1i(glGetUniformLocation(m_shadowShaderProgram, "diffuseTexture"), 0);
*/
// Validate program before drawing. This is a good check, but only really necessary in a debug build.
// DEBUG macro must be defined in your debug configurations if that's not already the case.
#if defined(DEBUG)
if (!ValidateProgram(m_shadowShaderProgram)) {
fprintf(stderr, "Failed to validate program: %d", m_shadowShaderProgram);
return;
}
#endif
// Bind our modelmatrix variable to be a uniform called mvpmatrix in our shaderprogram
GLDEBUG(glUniformMatrix4fv(m_shadowUniforms[KRENGINE_UNIFORM_SHADOWMVP1], 1, GL_FALSE, shadowmvpmatrix[iShadow].getPointer()));
GLDEBUG(glUniformMatrix4fv(shadowShader->m_uniforms[KRShader::KRENGINE_UNIFORM_SHADOWMVP1], 1, GL_FALSE, shadowmvpmatrix[iShadow].getPointer()));
// Calculate the bounding volume of the light map
@@ -592,28 +584,6 @@ void KRCamera::renderShadowBuffer(KRScene &scene, int iShadow)
GLDEBUG(glViewport(0, 0, backingWidth, backingHeight));
}
bool KRCamera::ValidateProgram(GLuint prog)
{
GLint logLength, status;
GLDEBUG(glValidateProgram(prog));
GLDEBUG(glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0)
{
GLchar *log = (GLchar *)malloc(logLength);
GLDEBUG(glGetProgramInfoLog(prog, logLength, &logLength, log));
fprintf(stderr, "Program validate log:\n%s", log);
free(log);
}
GLDEBUG(glGetProgramiv(prog, GL_VALIDATE_STATUS, &status));
if (status == 0)
return false;
return true;
}
void KRCamera::renderPost()
{
@@ -760,150 +730,6 @@ void KRCamera::invalidateShadowBuffers() {
}
}
bool KRCamera::LoadShader(KRContext &context, const std::string &name, GLuint *programPointer, const std::string &options)
{
GLuint vertexShader, fragShader;
// Create shader program.
GLDEBUG(*programPointer = glCreateProgram());
// Create and compile vertex shader.
if(!CompileShader(&vertexShader, GL_VERTEX_SHADER, context.getShaderManager()->getVertShaderSource(name), options)) {
fprintf(stderr, "Failed to compile vertex shader");
return false;
}
// Create and compile fragment shader.
if(!CompileShader(&fragShader, GL_FRAGMENT_SHADER, context.getShaderManager()->getFragShaderSource(name), options)) {
fprintf(stderr, "Failed to compile fragment shader");
return false;
}
// Attach vertex shader to program.
GLDEBUG(glAttachShader(*programPointer, vertexShader));
// Attach fragment shader to program.
GLDEBUG(glAttachShader(*programPointer, fragShader));
// Bind attribute locations.
// This needs to be done prior to linking.
GLDEBUG(glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv"));
GLDEBUG(glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_VERTEX, "vertex_position"));
GLDEBUG(glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_NORMAL, "vertex_normal"));
GLDEBUG(glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TANGENT, "vertex_tangent"));
GLDEBUG(glBindAttribLocation(*programPointer, KRShader::KRENGINE_ATTRIB_TEXUVA, "vertex_uv"));
// Link program.
if(!LinkProgram(*programPointer)) {
fprintf(stderr, "Failed to link program: %d", *programPointer);
if (vertexShader) {
GLDEBUG(glDeleteShader(vertexShader));
vertexShader = 0;
}
if (fragShader) {
GLDEBUG(glDeleteShader(fragShader));
fragShader = 0;
}
if (*programPointer) {
GLDEBUG(glDeleteProgram(*programPointer));
*programPointer = 0;
}
return false;
}
// Release vertex and fragment shaders.
if (vertexShader)
{
GLDEBUG(glDeleteShader(vertexShader));
}
if (fragShader)
{
GLDEBUG(glDeleteShader(fragShader));
}
return true;
}
bool KRCamera::CompileShader(GLuint *shader, GLenum type, const std::string &shader_source, const std::string &options)
{
GLint status;
const GLchar *source[2];
source[0] = (GLchar *)shader_source.c_str();
if (!source[0])
{
fprintf(stderr, "Failed to load vertex shader");
return false;
}
if(options.length()) {
source[1] = source[0];
source[0] = options.c_str();
}
GLDEBUG(*shader = glCreateShader(type));
GLDEBUG(glShaderSource(*shader, options.length() ? 2 : 1, source, NULL));
GLDEBUG(glCompileShader(*shader));
#if defined(DEBUG)
GLint logLength;
GLDEBUG(glGetShaderiv(*shader, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0)
{
GLchar *log = (GLchar *)malloc(logLength);
GLDEBUG(glGetShaderInfoLog(*shader, logLength, &logLength, log));
fprintf(stderr, "Shader compile log:\n%s", log);
free(log);
}
#endif
GLDEBUG(glGetShaderiv(*shader, GL_COMPILE_STATUS, &status));
if (status == 0) {
GLDEBUG(glDeleteShader(*shader));
return false;
}
return true;
}
bool KRCamera::LinkProgram(GLuint prog)
{
GLint status;
GLDEBUG(glLinkProgram(prog));
#if defined(DEBUG)
GLint logLength;
GLDEBUG(glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLength));
if (logLength > 0)
{
GLchar *log = (GLchar *)malloc(logLength);
GLDEBUG(glGetProgramInfoLog(prog, logLength, &logLength, log));
fprintf(stderr, "Program link log:\n%s", log);
free(log);
}
#endif
GLDEBUG(glGetProgramiv(prog, GL_LINK_STATUS, &status));
if (status == 0)
return false;
return true;
}
void KRCamera::loadShaders()
{
LoadShader(*m_pContext, "ShadowShader", &m_shadowShaderProgram, "");
m_shadowUniforms[KRENGINE_UNIFORM_SHADOWMVP1] = glGetUniformLocation(m_shadowShaderProgram, "shadow_mvp1");
}
void KRCamera::notify_sceneGraphCreate(KRNode *pNode)
{
fprintf(stderr, "KRCamera - notify_sceneGraphCreate");

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

@@ -38,6 +38,7 @@
#import "KRVector2.h"
#import "KRNotified.h"
#import "KRAABB.h"
#import "KRShader.h"
#define KRENGINE_MAX_SHADOW_BUFFERS 3
@@ -127,51 +128,15 @@ private:
bool shadowValid[KRENGINE_MAX_SHADOW_BUFFERS];
KRMat4 shadowmvpmatrix[KRENGINE_MAX_SHADOW_BUFFERS]; /* MVP Matrix for view from light source */
// uniform index
enum {
KRENGINE_UNIFORM_MATERIAL_AMBIENT,
KRENGINE_UNIFORM_MATERIAL_DIFFUSE,
KRENGINE_UNIFORM_MATERIAL_SPECULAR,
KRENGINE_UNIFORM_LIGHT_POSITION,
KRENGINE_UNIFORM_LIGHT_POSITION_VIEW_SPACE,
KRENGINE_UNIFORM_LIGHT_DIRECTION,
KRENGINE_UNIFORM_LIGHT_DIRECTION_VIEW_SPACE,
KRENGINE_UNIFORM_LIGHT_COLOR,
KRENGINE_UNIFORM_LIGHT_DECAY_START,
KRENGINE_UNIFORM_LIGHT_CUTOFF,
KRENGINE_UNIFORM_LIGHT_INTENSITY,
KRENGINE_UNIFORM_FLARE_SIZE,
KRENGINE_UNIFORM_MVP,
KRENGINE_UNIFORM_INVP,
KRENGINE_UNIFORM_MN2V,
KRENGINE_UNIFORM_M2V,
KRENGINE_UNIFORM_V2M,
KRENGINE_UNIFORM_SHADOWMVP1,
KRENGINE_UNIFORM_SHADOWMVP2,
KRENGINE_UNIFORM_SHADOWMVP3,
KRENGINE_UNIFORM_CAMERAPOS,
KRENGINE_UNIFORM_VIEWPORT,
KRENGINE_NUM_UNIFORMS
};
GLint m_shadowUniforms[KRENGINE_NUM_UNIFORMS];
GLuint m_shadowShaderProgram;
void renderPost();
void destroyBuffers();
void renderFrame(KRScene &scene, KRMat4 &viewMatrix, KRVector3 &lightDirection, KRVector3 &cameraPosition);
void loadShaders();
// Code using these shader functions will later be refactored to integrate with KRShaderManager
static bool ValidateProgram(GLuint prog);
static bool LoadShader(KRContext &context, const std::string &name, GLuint *programPointer, const std::string &options);
static bool CompileShader(GLuint *shader, GLenum type, const std::string &shader_source, const std::string &options);
static bool LinkProgram(GLuint prog);
class KRInstanceDistance {

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

@@ -77,7 +77,7 @@ void KRContext::loadResource(const std::string &file_name, KRDataBlock *data) {
std::string name = KRResource::GetFileBase(file_name);
std::string extension = KRResource::GetFileExtension(file_name);
fprintf(stderr, "KRContext::loadResource - Loading: %s\n", file_name.c_str());
//fprintf(stderr, "KRContext::loadResource - Loading: %s\n", file_name.c_str());
if(extension.compare("krbundle") == 0) {
m_pBundleManager->loadBundle(name.c_str(), data);

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

@@ -107,7 +107,7 @@ vector<KRMesh::Submesh *> KRMesh::getSubmeshes() {
return m_submeshes;
}
void KRMesh::renderSubmesh(int iSubmesh, int &iPrevBuffer) {
void KRMesh::renderSubmesh(int iSubmesh) {
VertexData *pVertexData = getVertexData();
pack_header *pHeader = (pack_header *)m_pData->getStart();
@@ -122,15 +122,14 @@ void KRMesh::renderSubmesh(int iSubmesh, int &iPrevBuffer) {
int cVertexes = pSubmesh->vertex_count;
while(cVertexes > 0) {
GLsizei cBufferVertexes = iBuffer < cBuffers - 1 ? MAX_VBO_SIZE : pHeader->vertex_count % MAX_VBO_SIZE;
if(iPrevBuffer != iBuffer) {
assert(pVertexData + iBuffer * MAX_VBO_SIZE >= m_pData->getStart());
int vertex_size = sizeof(VertexData) ;
void *vbo_end = (unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE + vertex_size * cBufferVertexes;
void *buffer_end = m_pData->getEnd();
assert(vbo_end <= buffer_end);
m_pContext->getModelManager()->bindVBO((unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE, sizeof(VertexData) * cBufferVertexes, true, true, true, true, true);
}
iPrevBuffer = iBuffer;
assert(pVertexData + iBuffer * MAX_VBO_SIZE >= m_pData->getStart());
int vertex_size = sizeof(VertexData) ;
void *vbo_end = (unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE + vertex_size * cBufferVertexes;
void *buffer_end = m_pData->getEnd();
assert(vbo_end <= buffer_end);
m_pContext->getModelManager()->bindVBO((unsigned char *)pVertexData + iBuffer * MAX_VBO_SIZE, vertex_size * cBufferVertexes, true, true, true, true, true);
if(iVertex + cVertexes >= MAX_VBO_SIZE) {
assert(iVertex + (MAX_VBO_SIZE - iVertex) <= cBufferVertexes);

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

@@ -69,7 +69,7 @@ public:
void loadPack(KRDataBlock *data);
void renderSubmesh(int iSubmesh, int &iPrevBuffer);
void renderSubmesh(int iSubmesh);
GLfloat getMaxDimension();

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

@@ -93,7 +93,6 @@ void KRModel::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &matModelToV
}
KRMaterial *pPrevBoundMaterial = NULL;
int iPrevBuffer = -1;
char szPrevShaderKey[128];
szPrevShaderKey[0] = '\0';
int cSubmeshes = m_pMesh->getSubmeshes().size();
@@ -105,7 +104,7 @@ void KRModel::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &matModelToV
if(!pMaterial->isTransparent()) {
// Exclude transparent and semi-transparent meshes from shadow maps
m_pMesh->renderSubmesh(iSubmesh, iPrevBuffer);
m_pMesh->renderSubmesh(iSubmesh);
}
}
@@ -123,19 +122,19 @@ void KRModel::render(KRCamera *pCamera, KRContext *pContext, KRMat4 &matModelToV
switch(pMaterial->getAlphaMode()) {
case KRMaterial::KRMATERIAL_ALPHA_MODE_OPAQUE: // Non-transparent materials
case KRMaterial::KRMATERIAL_ALPHA_MODE_TEST: // Alpha in diffuse texture is interpreted as punch-through when < 0.5
m_pMesh->renderSubmesh(iSubmesh, iPrevBuffer);
m_pMesh->renderSubmesh(iSubmesh);
break;
case KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDONESIDE: // Blended alpha with backface culling
m_pMesh->renderSubmesh(iSubmesh, iPrevBuffer);
m_pMesh->renderSubmesh(iSubmesh);
break;
case KRMaterial::KRMATERIAL_ALPHA_MODE_BLENDTWOSIDE: // Blended alpha rendered in two passes. First pass renders backfaces; second pass renders frontfaces.
// Render back faces first
GLDEBUG(glCullFace(GL_BACK));
m_pMesh->renderSubmesh(iSubmesh, iPrevBuffer);
m_pMesh->renderSubmesh(iSubmesh);
// Render front faces second
GLDEBUG(glCullFace(GL_BACK));
m_pMesh->renderSubmesh(iSubmesh, iPrevBuffer);
m_pMesh->renderSubmesh(iSubmesh);
break;
}

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

@@ -122,7 +122,7 @@ KRShader *KRShaderManager::getShader(std::string shader_name, KRCamera *pCamera,
stream << "\n";
std::string options = stream.str();
fprintf(stderr, "Shader Options:\n%s\n\n", options.c_str());
//fprintf(stderr, "Shader Options:\n%s\n\n", options.c_str());
pShader = new KRShader(szKey, options, m_vertShaderSource[shader_name], m_fragShaderSource[shader_name]);