void Renderer::DrawWater()
{
SetCurrentShader(reflectShader);
SetShaderLight(*light);
glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "cameraPos"), 1, (float*)&camera->GetPosition());
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "cubeTex"), 2);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMap);
float heightX = (RAW_WIDTH * HEIGHTMAP_X / 2.0f);
float heightY = 256 * HEIGHTMAP_Y / 3.0f;
float heightZ = (RAW_HEIGHT * HEIGHTMAP_Z /2.0f);
modelMatrix =
Matrix4::Translation(Vector3(heightX, heightY, heightZ)) *
Matrix4::Scale(Vector3(heightX, 1, heightZ)) *
Matrix4::Rotation(90, Vector3(1.0f, 0.0f, 0.0f));
textureMatrix = Matrix4::Scale(Vector3(10.0f,10.0f,10.0f)) *
Matrix4::Rotation(waterRotate, Vector3(0.0f, 0.0f, 1.0f));
UpdateShaderMatrices();
quad->Draw();
glUseProgram(0);
}
//Performs a fog effect based upon a linearized depth buffer
void Renderer::Fog(){
//Bind our processing FBO and attach the next buffer to be drawn to to it
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GetDrawTarget(), 0);
//Clear it
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
SetCurrentShader(fogShader);
glUniform2f(glGetUniformLocation(currentShader->GetProgram(), "pixelSize"),
1.0f / width, 1.0f / height);
UpdateShaderMatrices();
glUniform1f(glGetUniformLocation(currentShader->GetProgram(),
"threshold"), 0.2f);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(),
"depthTex"), 2);
glUniform1f(glGetUniformLocation(currentShader->GetProgram(),
"nearPlane"), 1.0);
glUniform1f(glGetUniformLocation(currentShader->GetProgram(),
"farPlane"), 15000.0f);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, bufferDepthTex);
quad->SetTexture(GetLastDrawn());
quad->Draw();
PPDrawn();
}
void Renderer::DrawPostProcess() {
glBindFramebuffer(GL_FRAMEBUFFER, processFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, bufferColourTex[1], 0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
SetCurrentShader(combineShader);
projMatrix = Matrix4::Orthographic(-1, 1, 1, -1, -1, 1);
viewMatrix.ToIdentity();
UpdateShaderMatrices();
glDisable(GL_DEPTH_TEST);
glUniform2f(glGetUniformLocation(currentShader->GetProgram(), "pixelSize"), 1.0f / width, 1.0f / height);
for (int i = 0; i < POST_PASSES; ++i) {
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, bufferColourTex[1], 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "isVertical"), 0);
quad->SetTexture(bufferColourTex[0]);
quad->Draw();
// swap buffers, second blur pass
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "isVertical"), 1);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, bufferColourTex[0], 0);
quad->SetTexture(bufferColourTex[1]);
quad->Draw();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glUseProgram(0);
glEnable(GL_DEPTH_TEST);
}
//Presents which ever scene was the last to be drawn to to the back buffer
void Renderer::PresentScene(){
//We draw the final result to the default framebuffer (the back buffer)
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
//We must render the final texture orthographically in front of the screen
SetCurrentShader(passThrough);
projMatrix = Matrix4::Orthographic(-1,1,1,-1,-1,1);
viewMatrix.ToIdentity();
modelMatrix.ToIdentity();
UpdateShaderMatrices();
//The results of post processing is held in bufferColourTex[0]
if (Window::GetKeyboard()->KeyDown(KEYBOARD_NUMPAD4)){
quad->SetTexture(lightEmissiveTex);
} else if (Window::GetKeyboard()->KeyDown(KEYBOARD_NUMPAD5)) {
quad->SetTexture(lightSpecularTex);
} else if (Window::GetKeyboard()->KeyDown(KEYBOARD_NUMPAD6)) {
quad->SetTexture(bufferNormalTex);
} else {
quad->SetTexture(GetLastDrawn());
}
quad->Draw();
glUseProgram(0);
}
void Scene::DrawCominedScene()
{
SetCurrentShader(SceneShader);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "bumpTex"), 1);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "shadowTex1"), 2);
glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "cameraPos"), 1, (float*)&m_Camera->GetPosition());
SetShaderLightList(lightList);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, shadowTex);
//glActiveTexture(GL_TEXTURE3);
//glBindTexture(GL_TEXTURE_2D, shadowTexs[0]);
projMatrix = Matrix4::Perspective(1.0f, 1000.0f, (float)width / (float)height, 45.0f);
viewMatrix = m_Camera->BuildViewMatrix();
/*Vector3 translate = Vector3((lightList.at(0)).GetPosition());
translate += Vector3(0, 90, 0);
viewMatrix = Matrix4::BuildViewMatrix((lightList.at(0)).GetPosition(), translate);*/
UpdateShaderMatrices();
//draw the object
DrawNodes(true);
glUseProgram(0);
}
void Renderer::RenderScene() {
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
if(camera) {
SetCurrentShader(simpleShader);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
textureMatrix.ToIdentity();
modelMatrix.ToIdentity();
viewMatrix = camera->BuildViewMatrix();
projMatrix = Matrix4::Perspective(1.0f,10000.0f,(float)width / (float) height, 60.0f);
frameFrustum.FromMatrix(projMatrix * viewMatrix);
UpdateShaderMatrices();
//Return to default 'usable' state every frame!
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDisable(GL_STENCIL_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
BuildNodeLists(root);
SortNodeLists();
DrawNodes();
ClearNodeLists();
}
glUseProgram(0);
SwapBuffers();
}
bool VertexShaderCache::CompileVertexShader(VERTEXSHADER& vs, const char* pstrprogram)
{
// Reset GL error before compiling shaders. Yeah, we need to investigate the causes of these.
GLenum err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR)
{
ERROR_LOG(VIDEO, "glError %08x before VS!", err);
}
#if defined HAVE_CG && HAVE_CG
char stropt[64];
sprintf(stropt, "MaxLocalParams=256,MaxInstructions=%d", s_nMaxVertexInstructions);
const char *opts[] = {"-profileopts", stropt, "-O2", "-q", NULL};
CGprogram tempprog = cgCreateProgram(g_cgcontext, CG_SOURCE, pstrprogram, g_cgvProf, "main", opts);
if (!cgIsProgram(tempprog)) {
if (s_displayCompileAlert) {
PanicAlert("Failed to create vertex shader");
s_displayCompileAlert = false;
}
cgDestroyProgram(tempprog);
ERROR_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext));
ERROR_LOG(VIDEO, "%s", pstrprogram);
return false;
}
if (cgGetError() != CG_NO_ERROR)
{
WARN_LOG(VIDEO, "Failed to load vs %s:", cgGetLastListing(g_cgcontext));
WARN_LOG(VIDEO, "%s", pstrprogram);
}
// This looks evil - we modify the program through the const char * we got from cgGetProgramString!
// It SHOULD not have any nasty side effects though - but you never know...
char *pcompiledprog = (char*)cgGetProgramString(tempprog, CG_COMPILED_PROGRAM);
char *plocal = strstr(pcompiledprog, "program.local");
while (plocal != NULL) {
const char* penv = " program.env";
memcpy(plocal, penv, 13);
plocal = strstr(plocal + 13, "program.local");
}
glGenProgramsARB(1, &vs.glprogid);
SetCurrentShader(vs.glprogid);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pcompiledprog), pcompiledprog);
err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR) {
ERROR_LOG(VIDEO, "%s", pstrprogram);
ERROR_LOG(VIDEO, "%s", pcompiledprog);
}
cgDestroyProgram(tempprog);
#endif
#if defined(_DEBUG) || defined(DEBUGFAST)
vs.strprog = pstrprogram;
#endif
return true;
}
void Renderer::DrawSkybox()
{
glDepthMask(GL_FALSE);
SetCurrentShader(skyboxShader);
UpdateShaderMatrices();
quad->Draw();
glUseProgram(0);
glDepthMask(GL_TRUE);
}
void Renderer::PresentScene() {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
SetCurrentShader(sceneShader);
projMatrix = Matrix4::Orthographic(-1, 1, 1, -1, -1, 1);
viewMatrix.ToIdentity();
UpdateShaderMatrices();
quad->SetTexture(bufferColourTex[1]);
quad->Draw();
glUseProgram(0);
}
void Renderer::DrawScene() {
glBindFramebuffer(GL_FRAMEBUFFER, bufferFBO);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
SetCurrentShader(sceneShader);
projMatrix = Matrix4::Perspective(1.0f, 10000.0f, (float)width / (float)height, 45.0f);
UpdateShaderMatrices();
heightMap->Draw();
glUseProgram(0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void Renderer::DrawHeightMap()
{
SetCurrentShader(lightShader);
SetShaderLight(*light);
glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "cameraPos"), 1, (float*)&camera->GetPosition());
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "bumpTex"), 1);
modelMatrix.ToIdentity();
textureMatrix.ToIdentity();
UpdateShaderMatrices();
heightMap->Draw();
glUseProgram(0);
}
//Blooms each fragment based on its local fragments
void Renderer::Bloom(){
//Bind our processing FBO and attach the next buffer to be drawn to to it
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GetDrawTarget(), 0);
//Clear it
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
SetCurrentShader(bloomShader);
glUniform2f(glGetUniformLocation(currentShader->GetProgram(), "pixelSize"),
1.0f / width, 1.0f / height);
UpdateShaderMatrices();
quad->SetTexture(GetLastDrawn());
quad->Draw();
PPDrawn();
}
//Performs a gaussian blur on the FBO
void Renderer::Blur(){
//Bind our processing FBO and attach bufferColourTex[1] to it
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GetDrawTarget(), 0);
//Clear it
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
SetCurrentShader(blurShader);
glUniform2f(glGetUniformLocation(currentShader->GetProgram(), "pixelSize"),
1.0f / width, 1.0f / height);
UpdateShaderMatrices();
//One pass is actually 2!
for (int i=0; i < BLUR_PASSES*2; ++i){
//Bind our buffer colortex[1] to it as a colour attachment
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GetDrawTarget(), 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(),
"isVertical"), 0);
quad->SetTexture(GetLastDrawn());
//Draw the scene and blur horizontally
quad->Draw();
PPDrawn();
//Swap the buffers round between being textures and colour buffer
glUniform1i(glGetUniformLocation(currentShader->GetProgram(),
"isVertical"), 1);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, GetDrawTarget(), 0);
quad->SetTexture(GetLastDrawn());
//Draw the scene and blur vertically
quad->Draw();
PPDrawn();
}
}
void Renderer::DrawCombinedScene(){
SetCurrentShader(sceneShader);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "bumpTex"), 1);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "shadowTex"), 2);
glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "cameraPos"), 1, (float*)&camera->GetPosition());
SetShaderLight(*light);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, shadowTex);
viewMatrix = camera->BuildViewMatrix();
UpdateShaderMatrices();
DrawFloor();
DrawMesh();
glUseProgram(0);
}
//Uploads the specific skybox uniforms and draws it
void Renderer::DrawSkybox(){
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
SetCurrentShader(skyboxShader);
//No need to change model matrix
modelMatrix = Matrix4::GetIdentitiy();
viewMatrix = camera->BuildViewMatrix();
projMatrix = cameraProjMat;
glUniform1f(glGetUniformLocation(currentShader->GetProgram(),
"blend"), skyboxLight);
UpdateShaderMatrices();
quad->Draw();
glUseProgram(0);
glDepthMask(GL_TRUE);
glEnable(GL_CULL_FACE);
}
void Renderer::DrawShadowScene(){
glBindFramebuffer(GL_FRAMEBUFFER, shadowFBO);
glClear(GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, SHADOWSIZE, SHADOWSIZE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
SetCurrentShader(shadowShader);
viewMatrix = Matrix4::BuildViewMatrix(light->GetPosition(), Vector3(0,0,0));
textureMatrix = biasMatrix * (projMatrix * viewMatrix);
UpdateShaderMatrices();
DrawFloor();
DrawMesh();
glUseProgram(0);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glViewport(0, 0, width, height);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void PixelShaderCache::Init()
{
glEnable(GL_FRAGMENT_PROGRAM_ARB);
ShaderEnabled = true;
CurrentShader = 0;
last_entry = NULL;
GL_REPORT_ERRORD();
s_displayCompileAlert = true;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, (GLint *)&s_nMaxPixelInstructions);
if(s_nMaxPixelInstructions == 0) // Some combination of drivers and hardware returns zero for some reason.
s_nMaxPixelInstructions = 4096;
if (strstr((const char*)glGetString(GL_VENDOR), "Humper") != NULL) s_nMaxPixelInstructions = 4096;
#if CG_VERSION_NUM == 2100
if (strstr((const char*)glGetString(GL_VENDOR), "ATI") != NULL)
{
s_nMaxPixelInstructions = 4096;
}
#endif
int maxinst, maxattribs;
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, (GLint *)&maxinst);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, (GLint *)&maxattribs);
INFO_LOG(VIDEO, "pixel max_alu=%d, max_inst=%d, max_attrib=%d", s_nMaxPixelInstructions, maxinst, maxattribs);
char pmatrixprog[2048];
sprintf(pmatrixprog, "!!ARBfp1.0"
"TEMP R0;\n"
"TEMP R1;\n"
"PARAM K0 = { 0.5, 0.5, 0.5, 0.5};\n"
"TEX R0, fragment.texcoord[0], texture[0], RECT;\n"
"MUL R0, R0, program.env[%d];\n"
"ADD R0, R0, K0;\n"
"FLR R0, R0;\n"
"MUL R0, R0, program.env[%d];\n"
"DP4 R1.x, R0, program.env[%d];\n"
"DP4 R1.y, R0, program.env[%d];\n"
"DP4 R1.z, R0, program.env[%d];\n"
"DP4 R1.w, R0, program.env[%d];\n"
"ADD result.color, R1, program.env[%d];\n"
"END\n",C_COLORMATRIX+5,C_COLORMATRIX+6, C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4);
glGenProgramsARB(1, &s_ColorMatrixProgram);
SetCurrentShader(s_ColorMatrixProgram);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog);
GLenum err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR) {
ERROR_LOG(VIDEO, "Failed to create color matrix fragment program");
glDeleteProgramsARB(1, &s_ColorMatrixProgram);
s_ColorMatrixProgram = 0;
}
sprintf(pmatrixprog, "!!ARBfp1.0\n"
"TEMP R0;\n"
"TEMP R1;\n"
"TEMP R2;\n"
//16777215/16777216*256, 1/255, 256, 0
"PARAM K0 = { 255.99998474121, 0.003921568627451, 256.0, 0.0};\n"
"PARAM K1 = { 15.0, 0.066666666666, 0.0, 0.0};\n"
//sample the depth value
"TEX R2, fragment.texcoord[0], texture[0], RECT;\n"
//scale from [0*16777216..1*16777216] to
//[0*16777215..1*16777215], multiply by 256
"MUL R0, R2.x, K0.x;\n" // *16777215/16777216*256
//It is easy to get bad results due to low precision
//here, for example converting like this:
//MUL R0,R0,{ 65536, 256, 1, 16777216 }
//FRC R0,R0
//gives {?, 128/255, 254/255, ?} for depth value 254/255
//on some gpus
"FLR R0.x,R0;\n" //bits 31..24
"SUB R0.yzw,R0,R0.x;\n" //subtract bits 31..24 from rest
"MUL R0.yzw,R0,K0.z;\n" // *256
"FLR R0.y,R0;\n" //bits 23..16
"SUB R0.zw,R0,R0.y;\n" //subtract bits 23..16 from rest
"MUL R0.zw,R0,K0.z;\n" // *256
"FLR R0.z,R0;\n" //bits 15..8
"MOV R0.w,R0.x;\n" //duplicate bit 31..24
"MUL R0,R0,K0.y;\n" // /255
"MUL R0.w,R0,K1.x;\n" // *15
"FLR R0.w,R0;\n" //bits 31..28
"MUL R0.w,R0,K1.y;\n" // /15
"DP4 R1.x, R0, program.env[%d];\n"
"DP4 R1.y, R0, program.env[%d];\n"
"DP4 R1.z, R0, program.env[%d];\n"
"DP4 R1.w, R0, program.env[%d];\n"
"ADD result.color, R1, program.env[%d];\n"
"END\n", C_COLORMATRIX, C_COLORMATRIX+1, C_COLORMATRIX+2, C_COLORMATRIX+3, C_COLORMATRIX+4);
glGenProgramsARB(1, &s_DepthMatrixProgram);
SetCurrentShader(s_DepthMatrixProgram);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pmatrixprog), pmatrixprog);
err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR) {
ERROR_LOG(VIDEO, "Failed to create depth matrix fragment program");
glDeleteProgramsARB(1, &s_DepthMatrixProgram);
s_DepthMatrixProgram = 0;
}
}
bool PixelShaderCache::CompilePixelShader(FRAGMENTSHADER& ps, const char* pstrprogram)
{
GLenum err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR)
{
ERROR_LOG(VIDEO, "glError %08x before PS!", err);
}
#if defined HAVE_CG && HAVE_CG
char stropt[128];
sprintf(stropt, "MaxLocalParams=224,NumInstructionSlots=%d", s_nMaxPixelInstructions);
const char *opts[] = {"-profileopts", stropt, "-O2", "-q", NULL};
CGprogram tempprog = cgCreateProgram(g_cgcontext, CG_SOURCE, pstrprogram, g_cgfProf, "main", opts);
// handle errors
if (!cgIsProgram(tempprog))
{
cgDestroyProgram(tempprog);
static int num_failures = 0;
char szTemp[MAX_PATH];
sprintf(szTemp, "%sbad_ps_%04i.txt", File::GetUserPath(D_DUMP_IDX).c_str(), num_failures++);
std::ofstream file(szTemp);
file << pstrprogram;
file.close();
PanicAlert("Failed to compile pixel shader!\nThis usually happens when trying to use Dolphin with an outdated GPU or integrated GPU like the Intel GMA series.\n\nIf you're sure this is Dolphin's error anyway, post the contents of %s along with this error message at the forums.\n\nDebug info (%d):\n%s",
szTemp,
g_cgfProf,
cgGetLastListing(g_cgcontext));
return false;
}
// handle warnings
if (cgGetError() != CG_NO_ERROR)
{
WARN_LOG(VIDEO, "Warnings on compile ps %s:", cgGetLastListing(g_cgcontext));
WARN_LOG(VIDEO, "%s", pstrprogram);
}
// This looks evil - we modify the program through the const char * we got from cgGetProgramString!
// It SHOULD not have any nasty side effects though - but you never know...
char *pcompiledprog = (char*)cgGetProgramString(tempprog, CG_COMPILED_PROGRAM);
char *plocal = strstr(pcompiledprog, "program.local");
while (plocal != NULL)
{
const char *penv = " program.env";
memcpy(plocal, penv, 13);
plocal = strstr(plocal+13, "program.local");
}
glGenProgramsARB(1, &ps.glprogid);
SetCurrentShader(ps.glprogid);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, (GLsizei)strlen(pcompiledprog), pcompiledprog);
err = GL_REPORT_ERROR();
if (err != GL_NO_ERROR)
{
GLint error_pos, native_limit;
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB, &native_limit);
// Error occur
if (error_pos != -1) {
const char *program_error = (const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
char line[256];
strncpy(line, (const char *)pcompiledprog + error_pos, 255);
line[255] = 0;
ERROR_LOG(VIDEO, "Error at %i: %s", error_pos, program_error);
ERROR_LOG(VIDEO, "Line dump: \n%s", line);
} else if (native_limit != -1) {
ERROR_LOG(VIDEO, "Hit limit? %i", native_limit);
// TODO
}
ERROR_LOG(VIDEO, "%s", pstrprogram);
ERROR_LOG(VIDEO, "%s", pcompiledprog);
}
cgDestroyProgram(tempprog);
#endif
return true;
}
//int frame_idx = 0;
void Scene::RenderScene()
{
//Check to see if the window has been resized
if (m_ScreenTexWidth != width || m_ScreenTexHeight != height)
{
BuildScreenFBO();
}
//Reset all varying data
textureMatrix.ToIdentity();
modelMatrix.ToIdentity();
viewMatrix = m_Camera->BuildViewMatrix();
projMatrix = Matrix4::Perspective(0.01f, 1000.0f, (float)width / (float)height, 45.0f);
m_FrameFrustum.FromMatrix(projMatrix * viewMatrix);
//Update all Object's World Transform
UpdateWorldMatrices(m_RootGameObject, Matrix4());
NCLDebug::SetDebugDrawData(projMatrix * viewMatrix, m_Camera->GetPosition());
//Setup Default Shader Uniforms
Vector3 camPos = m_Camera->GetPosition();
//Vector3 lightPos = m_InvLightDirection * -100.0f;
Vector3 lightPos = m_InvLightDirection * -100.0f;
Vector4 lightPosEyeSpace = viewMatrix * Vector4(lightPos.x, lightPos.y, lightPos.z, 1.0f);
//SetCurrentShader(m_DefaultLightShader);
//UpdateShaderMatrices();
//glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
//glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "ambientColour"), 1, &m_AmbientColour.x);
//glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "invLightDir"), 1, &m_InvLightDirection.x);
//glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "cameraPos"), 1, &camPos.x);
//glUniform1f(glGetUniformLocation(currentShader->GetProgram(), "specularIntensity"), m_SpecularIntensity);
//SetCurrentShader(m_DefaultShadowShader);
//UpdateShaderMatrices();
//glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
//glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "ambientColour"), 1, &m_AmbientColour.x);
//SetCurrentShader(m_ShadowVolumeShader);
//UpdateShaderMatrices();
//glUniform3fv(glGetUniformLocation(currentShader->GetProgram(), "invLightDir"), 1, &m_InvLightDirection.x);
////Setup Render FBO/OpenGL States
//glBindFramebuffer(GL_FRAMEBUFFER, m_ScreenFBO);
//glStencilFunc(GL_ALWAYS, 0, 0xFF);
//glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
//glClearColor(clearcolor.x, clearcolor.y, clearcolor.z, clearcolor.w);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
/////////////////////////////////////////////////
glDisable(GL_CULL_FACE);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
//glDepthFunc(GL_ALWAYS);
glDepthMask(GL_FALSE);//disable the depth buffer, it won't write on depth buffer
SetCurrentShader(m_skyboxShader);//set skyboxShader to be currentShader
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "cubeTex"), 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMap);
UpdateShaderMatrices(); //update "modelMatrix" "viewMatrix" "projMatrix" "textureMatrix"
//SetTextureRepeating(quad->GetTexture(), true);
quad->Draw(false);
glUseProgram(0);
glDepthMask(GL_TRUE);//enable depth buffer
//glDepthFunc(GL_LEQUAL);
/////////////////////////////////////////////////
//glEnable(GL_MULTISAMPLE);
glEnable(GL_DEPTH_TEST);
//glEnable(GL_DEPTH_CLAMP);
//glEnable(GL_STENCIL_TEST);
glEnable(GL_CULL_FACE);
//glEnable(GL_BLEND);
//glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Build Render List
BuildNodeLists(m_RootGameObject);
SortNodeLists();
//Render the Scene in the Dark (As if it were a shadow)
//SetCurrentShader(m_DefaultShadowShader);
//DrawNodes(false);
//Render the Shadow Volumes to the Stencil Buffer
//SetCurrentShader(m_ShadowVolumeShader);
//glDepthFunc(GL_LESS);
//glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
//glDepthMask(GL_FALSE);
//glStencilFunc(GL_ALWAYS, 0, 0xFF);
//glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_INCR_WRAP, GL_KEEP);
//glStencilOpSeparate(GL_BACK, GL_KEEP, GL_DECR_WRAP, GL_KEEP);
//glDisable(GL_CULL_FACE);
//DrawNodes(false);
//glEnable(GL_CULL_FACE);
//
////Finally Render the Light Sections of the scene where the shadow volumes overlapped
//glDepthFunc(GL_LEQUAL);
//glStencilFunc(GL_EQUAL, 0, 0xFF);
//glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
//glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
//glDepthMask(GL_TRUE);
//SetCurrentShader(m_DefaultLightShader);
//DrawNodes(true);
viewMatrix = m_Camera->BuildViewMatrix();
projMatrix = Matrix4::Perspective(1.0f, 1000.0f, (float)width / (float)height, 45.0f);
DrawShadowScene();
DrawCominedScene();
//Clear Render List
ClearNodeLists();
//Finally draw all debug data to FBO (this fbo has anti-aliasing and the screen buffer does not)
glDisable(GL_DEPTH_TEST);
glStencilFunc(GL_ALWAYS, 0, 0xFF);
PhysicsEngine::Instance()->DebugRender();
NCLDebug::SortDebugLists();
NCLDebug::DrawDebugLists();
NCLDebug::ClearDebugLists();
/////////////////////////////////////////////////
//PARTICLE
/////////////////////////////////////////////////
//glClearColor(0, 0, 0, 1);
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
SetCurrentShader(m_ParticleShader);
glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
DrawParticleList(m_RootParticleList);
glDepthMask(GL_TRUE);
/*glUniform1f(glGetUniformLocation(currentShader->GetProgram(), "particleSize"), emitter->GetParticleSize());
emitter->SetParticleSize(0.5f);
emitter->SetParticleVariance(1.0f);
emitter->SetLaunchParticles(16.0f);
emitter->SetParticleLifetime(100.0f);
emitter->SetParticleSpeed(0.1f);
emitter->SetSourcePosition(Vector3(0, 0, 0));
UpdateShaderMatrices();
emitter->Draw();*/
//-------------------------------------------------------------
//SetCurrentShader(m_ParticleShader);
//glUniform1i(glGetUniformLocation(currentShader->GetProgram(), "diffuseTex"), 0);
/*glUniform1f(glGetUniformLocation(currentShader->GetProgram(), "particleSize"), emitter1->GetParticleSize());
emitter1->SetParticleSize(5.0f);
emitter1->SetParticleVariance(1.0f);
emitter1->SetLaunchParticles(16.0f);
emitter1->SetParticleLifetime(100.0f);
emitter1->SetParticleSpeed(0.1f);
emitter1->SetSourcePosition(Vector3(10, 10, 10));
UpdateShaderMatrices();
emitter1->Draw();*/
/////////////////////////////////////////////////
//glDepthMask(GL_TRUE);
////Present our Screen
//glBindFramebuffer(GL_FRAMEBUFFER, 0);
//PresentScreenFBO();
////Swap Buffers and get ready to repeat the process
//glUseProgram(0);
SwapBuffers();
}
void Scene::DrawShadowScene()
{
//Matrix4 tempMatrix = Matrix4::Translation(Vector3((200 * 150) / 2.0f, -90.0f, (200 * 150) / 2));
Vector3 translate = Vector3((lightList.at(0)).GetPosition());
//Matrix4 pushMatrix = Matrix4::Translation(translate);
//Matrix4 popMatrix = Matrix4::Translation(-translate);
translate += Vector3(-5, -175, 0); //top
glBindFramebuffer(GL_FRAMEBUFFER, shadowFBO);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowTex, 0);
glClear(GL_DEPTH_BUFFER_BIT);
glDrawBuffer(GL_NONE);
glViewport(0, 0, SHADOWSIZE, SHADOWSIZE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
SetCurrentShader(ShadowShader);
/*if (loop < 4) {
tempMatrix = pushMatrix *
Matrix4::Rotation(90.0f * loop, Vector3(0.0f, 1.0f, 0.0f))
* popMatrix;
}
else {
tempMatrix = pushMatrix *
Matrix4::Rotation(90.0f * (loop == 4 ? 1 : -1), Vector3(1.0f, 0.0f, 0.0f))
* popMatrix;
}*/
//if (loop == 0)
// translate += Vector3(-5,-90,0); //top
//if (loop == 1)
// translate += Vector3(-5, 90,0); // floor
//if (loop == 2)
// translate += Vector3(200,-5,0);
//if (loop == 3)
// translate += Vector3(-200,-5,0);
//if (loop == 4)
// translate += Vector3(0,-5,150);
//if (loop == 5)
// translate += Vector3(0,-5,-150);
//from the light to the middle of the height map
//viewMatrix = Matrix4::BuildViewMatrix(lightList.at(10).GetPosition(), MiddleOfScene);
projMatrix = Matrix4::Perspective(1.0f, 15000.0f, (float)width / (float)height, 200.0f);
//Vector3 pos = tempMatrix.GetPositionVector();
//Vector3 pos = translate;
//translate += Vector3(-5,-5,-5);
//cout << translate << endl;
viewMatrix = Matrix4::BuildViewMatrix((lightList.at(0)).GetPosition(), translate);
//ShadowTransMatrix = biasMatrix*(projMatrix * viewMatrix);
//viewMatrix = Matrix4::BuildViewMatrix(lightList.at(0).GetPosition(), Vector3(0,0,0));
//textureMatrix = biasMatrix * (projMatrix * viewMatrix);
(lightList.at(0)).SetlightViewProjMat(biasMatrix * (projMatrix * viewMatrix));
//Texture matrix is really = biasMatrix * (light proj Matrix * light view Matrix)
UpdateShaderMatrices();
//draw a shadow of each things
DrawNodes(true);
glUseProgram(0);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glViewport(0, 0, width, height);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
