void BoundsVisualiser::DestroyGeometry()
{
Eegeo_GL(glDeleteBuffers(1, &m_glVertexBuffer));
Eegeo_GL(glDeleteBuffers(1, &m_glIndexBuffer));
m_glVertexBuffer = 0;
m_glIndexBuffer = 0;
}
void BoundsVisualiser::Draw(const Eegeo::v3& minExtents, const Eegeo::v3& maxExtents)
{
Build(minExtents, maxExtents);
Eegeo_GL(glUseProgram(m_pShader->m_programHandle));
Eegeo::m44 mvp;
Eegeo::m44 w;
w.Identity();
Eegeo::m44::Mul(mvp, renderContext.GetViewProjectionMatrix(), w);
Eegeo_GL(glUniformMatrix4fv(m_pShader->m_mvpUniform, 1, 0, (const GLfloat*)&mvp));
Eegeo_GL(glEnableVertexAttribArray(m_pShader->m_positionSlot));
Eegeo_GL(glBindBuffer(GL_ARRAY_BUFFER, m_glVertexBuffer));
Eegeo_GL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_glIndexBuffer));
Eegeo_GL(glVertexAttribPointer(m_pShader->m_positionSlot, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0));
for(u32 j = 0; j < NumIndices; j+=3)
{
Eegeo_GL(glDrawElements(GL_LINE_LOOP, 3, GL_UNSIGNED_SHORT, (void*)(j * 2)));
}
Eegeo_GL(glBindBuffer (GL_ARRAY_BUFFER, 0));
Eegeo_GL(glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0));
DestroyGeometry();
}
void HeatmapExample::Suspend()
{
m_heatmapController.Remove(*m_pSfCrimeHeatmap);
delete m_pSfCrimeHeatmap;
m_pSfCrimeHeatmap = NULL;
if (m_heatmapTexture.textureId != 0)
{
Eegeo_GL(glDeleteTextures(1, &m_heatmapTexture.textureId));
}
if (m_gradientTexture.textureId != 0)
{
Eegeo_GL(glDeleteTextures(1, &m_gradientTexture.textureId));
}
}
void BoundsVisualiser::CompileShaders()
{
std::string vertexShaderCode = VertexShader();
std::string fragmentShaderCode = FragmentShader();
GLuint vertexShader = Eegeo::Helpers::ShaderCompiler::CompileShader(vertexShaderCode, GL_VERTEX_SHADER);
GLuint fragmentShader = Eegeo::Helpers::ShaderCompiler::CompileShader(fragmentShaderCode, GL_FRAGMENT_SHADER);
m_pShader = new Shader;
m_pShader->m_programHandle = glCreateProgram();
glAttachShader(m_pShader->m_programHandle, vertexShader);
glAttachShader(m_pShader->m_programHandle, fragmentShader);
glLinkProgram(m_pShader->m_programHandle);
GLint linkSuccess;
glGetProgramiv(m_pShader->m_programHandle, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE)
{
GLchar messages[256];
glGetProgramInfoLog(m_pShader->m_programHandle, sizeof(messages), 0, &messages[0]);
Eegeo_TTY("%s\n", &messages[0]);
return;
}
Eegeo_GL(glUseProgram(m_pShader->m_programHandle));
m_pShader->m_positionSlot = glGetAttribLocation(m_pShader->m_programHandle, "pos");
m_pShader->m_mvpUniform = glGetUniformLocation(m_pShader->m_programHandle, "mvp");
}
void ExampleMeshRenderable::Render(Eegeo::Rendering::GLState& glState) const
{
m_material->SetStatePerRenderable(this, glState);
m_mesh.BindVertexBuffers(GetVertexBinding(), glState);
Eegeo_GL(glDrawElements(GL_TRIANGLES, m_mesh.GetNumOfIndices(), GL_UNSIGNED_SHORT, (void*)(0)));
m_mesh.UnbindVertexBuffers(glState);
}
void BoundsVisualiser::InitMeshGLBuffers(Vertex* verts, u16* indices)
{
Eegeo_GL(glGenBuffers(1, &m_glVertexBuffer));
Eegeo_GL(glBindBuffer(GL_ARRAY_BUFFER, m_glVertexBuffer));
Eegeo_GL(glBufferData(GL_ARRAY_BUFFER, (sizeof(Vertex) * NumVerts), verts, GL_STATIC_DRAW));
Eegeo_GL(glBindBuffer (GL_ARRAY_BUFFER, 0));
Eegeo_GL(glGenBuffers(1, &m_glIndexBuffer));
Eegeo_GL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_glIndexBuffer));
Eegeo_GL(glBufferData(GL_ELEMENT_ARRAY_BUFFER, (sizeof(u16) * NumIndices), indices, GL_STATIC_DRAW));
Eegeo_GL(glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0));
}
void VRDistortionRenderable::Render(Eegeo::Rendering::GLState& glState) const
{
m_material->SetStatePerRenderable(this, glState);
m_pMesh->BindVertexBuffers(GetVertexBinding(), glState);
const u32 indexCount = m_pMesh->GetNumOfIndices();
Eegeo_ASSERT(indexCount != 0);
Eegeo_GL(glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, (void*)(0)));
m_pMesh->UnbindVertexBuffers(glState);
}
void AppRunner::Update(float deltaSeconds)
{
if(m_pAppHost != NULL && m_displayService.IsDisplayAvailable())
{
m_pAppHost->Update(deltaSeconds);
Eegeo_GL(eglSwapBuffers(m_displayService.GetDisplay(), m_displayService.GetSurface()));
Eegeo::Helpers::GLHelpers::ClearBuffers();
m_pAppHost->Draw(deltaSeconds);
}
}
void GlDisplayService::ReleaseDisplay(bool destroyEGL)
{
if (m_display != EGL_NO_DISPLAY)
{
Eegeo_GL(eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
if (m_surface != EGL_NO_SURFACE)
{
Eegeo_GL(eglDestroySurface(m_display, m_surface));
}
if (m_sharedSurface != EGL_NO_SURFACE)
{
Eegeo_GL(eglDestroySurface(m_display, m_sharedSurface));
}
if(destroyEGL)
{
if (m_context != EGL_NO_CONTEXT)
{
Eegeo_GL(eglDestroyContext(m_display, m_context));
}
if(m_resourceBuildSharedContext != EGL_NO_CONTEXT)
{
Eegeo_GL(eglDestroyContext(m_display, m_resourceBuildSharedContext));
}
Eegeo_GL(eglTerminate(m_display));
m_display = EGL_NO_DISPLAY;
m_context = EGL_NO_CONTEXT;
m_resourceBuildSharedContext = EGL_NO_CONTEXT;
}
}
m_surface = EGL_NO_SURFACE;
m_sharedSurface = EGL_NO_SURFACE;
m_displayBound = false;
}
bool GlDisplayService::TryBindDisplay(ANativeWindow& window)
{
EGLint w, h, dummy, format;
EGLConfig config;
EGLSurface surface;
if (!DefaultEGLChooser(m_display, EGL_WINDOW_BIT, config))
{
Eegeo_ERROR("unable to find a good display type");
return false;
}
eglGetConfigAttrib(m_display, config, EGL_NATIVE_VISUAL_ID, &format);
ANativeWindow_setBuffersGeometry(&window, 0, 0, format);
static const EGLint contextAttribs[] =
{
EGL_CONTEXT_CLIENT_VERSION,
2,
EGL_NONE
};
surface = eglCreateWindowSurface(m_display, config, &window, NULL);
if(m_context == EGL_NO_CONTEXT)
{
m_context = eglCreateContext(m_display, config, NULL, contextAttribs);
}
if (eglMakeCurrent(m_display, surface, surface, m_context) == EGL_FALSE)
{
Eegeo_ERROR("Unable to eglMakeCurrent");
return false;
}
//Eegeo_TTY("printing extensions\n");
//char * extensionsString = (char *) glGetString(GL_EXTENSIONS);
//Eegeo_TTY("%s\n",extensionsString);
Eegeo_GL(eglQuerySurface(m_display, surface, EGL_WIDTH, &w));
Eegeo_GL(eglQuerySurface(m_display, surface, EGL_HEIGHT, &h));
m_surface = surface;
#ifdef EEGEO_DROID_EMULATOR
m_sharedSurface = EGL_NO_SURFACE;
m_resourceBuildSharedContext = EGL_NO_CONTEXT;
#else
if(m_resourceBuildSharedContext == EGL_NO_CONTEXT)
{
m_resourceBuildSharedContext = eglCreateContext(m_display, config, m_context, contextAttribs);
}
EGLint pBufferAttribs[] =
{
EGL_WIDTH, 1,
EGL_HEIGHT, 1,
EGL_TEXTURE_TARGET, EGL_NO_TEXTURE,
EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE,
EGL_NONE
};
EGLConfig sharedSurfaceConfig;
if (!DefaultEGLChooser(m_display, EGL_PBUFFER_BIT, sharedSurfaceConfig))
{
Eegeo_ERROR("unabled to find a good pbuffer surface type");
}
m_sharedSurface = eglCreatePbufferSurface(m_display, sharedSurfaceConfig, pBufferAttribs);
#endif
w = w/2.0f;
m_displayWidth = w;
m_displayHeight = h;
glViewport(0, 0, m_displayWidth, m_displayHeight);
// Initialize GL state.
Eegeo_GL(glClearDepthf(1.0f));
Eegeo_GL(glClearColor(0.0f, 0.0f, 0.0f, 1.0f));
// Set up default Depth test.
Eegeo_GL(glEnable(GL_DEPTH_TEST));
Eegeo_GL(glDepthMask(GL_TRUE));
Eegeo_GL(glDepthFunc(GL_LEQUAL));
// Set up default culling.
Eegeo_GL(glEnable(GL_CULL_FACE));
Eegeo_GL(glFrontFace(GL_CW));
Eegeo_GL(glCullFace(GL_BACK));
// Turn off the stencil test.
Eegeo_GL(glDisable(GL_STENCIL_TEST));
Eegeo_GL(glStencilFunc(GL_NEVER, 0, 0xFFFFFFFF));
Eegeo_GL(glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP));
// Set the default blend mode and colour mask.
Eegeo_GL(glDisable(GL_BLEND));
Eegeo_GL(glColorMask(true, true, true, true));
Eegeo_GL(glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT));
eglSwapInterval(m_display, 1);
m_displayBound = true;
return m_displayBound;
}
