//applying the light at the "stencil-approved" areas
void DefRenderer::LightPass(Camera *cam, Renderer *r)
{
//setting to pass the stencil test when != 0
glStencilFunc(GL_NOTEQUAL, 0, 0xFF);
//writing only on top of the colors from geometry pass
glDrawBuffer(GL_COLOR_ATTACHMENT0);
glDisable(GL_DEPTH_TEST);
//using additive blending to mix the light and scene fragments
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
//try to render from the back to preserve depth information
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
r->Ready();
mat4 model = r->GetParentGO()->GetModelMatrix();
mat4 mvp = cam->Get() * model;
r->GetProgram()->SetUniform("Model", value_ptr(model));
r->GetProgram()->SetUniform("MVP", value_ptr(mvp));
vec4 deviceCenter = vec4(mvp * vec4(0, 0, 0, 1)); //center in device coords
vec3 center(deviceCenter.x, deviceCenter.y, deviceCenter.z);
r->GetProgram()->SetUniform("Center", ¢er);
Light *l = r->GetParentGO()->GetLight();
float intensity = l->GetIntensity();
r->GetProgram()->SetUniform("Intensity", &intensity);
vec4 color = l->GetColor();
r->GetProgram()->SetUniform("Color", &color);
r->Render();
glCullFace(GL_BACK);
glDisable(GL_BLEND);
CHECK_GL_ERROR();
}
void Game::LoadResources()
{
resourceManager = new ResourceManager();
currentScene = new Scene(resourceManager);
sceneManager = new SceneManager(resourceManager);
DefRenderer::Init();
PostProcessing::Init();
CHECK_GL_ERROR();
//======================== TEXTURES ========================
//HIDE THIS AWAY IN TO SCENE MANAGER LOADER AT SOME POINT!
Texture* skyTexture = new Texture(TEXTURE_PATH + "right.jpg", TEXTURE_PATH + "left.jpg", TEXTURE_PATH + "top.jpg", TEXTURE_PATH + "bottom.jpg", TEXTURE_PATH + "back.jpg", TEXTURE_PATH + "front.jpg");
resourceManager->AddTexture("skyTexture", skyTexture);
Texture* skyNightTexture = new Texture(TEXTURE_PATH + "night_right.jpg", TEXTURE_PATH + "night_left.jpg", TEXTURE_PATH + "night_top.jpg", TEXTURE_PATH + "night_bottom.jpg", TEXTURE_PATH + "night_back.jpg", TEXTURE_PATH + "night_front.jpg");
resourceManager->AddTexture("skyNightTexture", skyNightTexture);
//======================== MODELS ========================
Model *terrainModel = new Model();
terrainModel->SetUpAttrib(0, 3, GL_FLOAT, 0); //pos
terrainModel->SetUpAttrib(1, 4, GL_FLOAT, sizeof(vec3)); //coeffs
terrainModel->SetUpAttrib(2, 2, GL_FLOAT, sizeof(vec3) + sizeof(vec4)); //uv
terrainModel->SetUpAttrib(3, 3, GL_FLOAT, sizeof(vec3) + sizeof(vec4) + sizeof(vec2)); //normals
resourceManager->AddModel("Terrain", terrainModel);
Model *skyModel = new Model();
vector<Vertex> *verts = new vector<Vertex>(skyBoxverts);
vector<int> *indcs = new vector<int>(skyBoxIndices);
skyModel->SetVertices(verts, GL_STATIC_DRAW, true);
skyModel->SetIndices(indcs, GL_STATIC_DRAW, true);
skyModel->FlushBuffers();
skyModel->SetUpAttrib(0, 3, GL_FLOAT, 0);
resourceManager->AddModel("skyModel", skyModel);
//======================== SCENEMANAGEMENT ====================
sceneManager->LoadSceneDirectories();
sceneManager->LoadScene(0, currentScene);
}
void ComputeBasicGLSL::drawImage(GLuint texture)
{
float const vertexPosition[] = {
m_aspectRatio, -1.0f,
-m_aspectRatio, -1.0f,
m_aspectRatio, 1.0f,
-m_aspectRatio, 1.0f
};
float const textureCoord[] = {
1.0f, 0.0f,
0.0f, 0.0f,
1.0f, 1.0f,
0.0f, 1.0f
};
glClearColor(0.2f, 0.0f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(m_blitProg->getProgram());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(m_blitProg->getUniformLocation("uSourceTex"), 0);
int aPosCoord = m_blitProg->getAttribLocation("aPosition");
int aTexCoord = m_blitProg->getAttribLocation("aTexCoord");
glVertexAttribPointer(aPosCoord, 2, GL_FLOAT, GL_FALSE, 0, vertexPosition);
glVertexAttribPointer(aTexCoord, 2, GL_FLOAT, GL_FALSE, 0, textureCoord);
glEnableVertexAttribArray(aPosCoord);
glEnableVertexAttribArray(aTexCoord);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
CHECK_GL_ERROR();
}
MotionBlurShader(void) :
BaseProjNormalShader("shaders/motionblur.vert",
"shaders/motionblur.frag"),
viewMatUHandle(-1),
currentModelMatUHandle(-1),
previousModelMatUHandle(-1),
stretchScaleUHandle(-1),
colorTexUHandle(-1)
{
// uniforms
viewMatUHandle =
getUniformLocation("u_mViewMat");
currentModelMatUHandle =
getUniformLocation("u_mCurrentModelMat");
previousModelMatUHandle =
getUniformLocation("u_mPreviousModelMat");
stretchScaleUHandle =
getUniformLocation("u_fStretchScale");
colorTexUHandle =
getUniformLocation("u_tColorTex");
CHECK_GL_ERROR();
}
void CascadedShadowMapping::initRendering(void) {
printGLString("Version", GL_VERSION);
printGLString("Vendor", GL_VENDOR);
printGLString("Renderer", GL_RENDERER);
printGLString("Extensions", GL_EXTENSIONS);
GLint depthBits;
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
LOGI("depth bits = %d\n", depthBits);
if (!requireMinAPIVersion(NvGfxAPIVersionGL4_3()))
return;
if (!requireExtension("GL_NV_viewport_array2"))
return;
if (!requireExtension("GL_NV_geometry_shader_passthrough"))
return;
m_renderer->initRendering();
CHECK_GL_ERROR();
}
void Mercury::reshape(int32_t width, int32_t height)
{
glViewport( 0, 0, (GLint) width, (GLint) height );
// Rescale FBO and RBO as well
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[0]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[1]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindTexture(GL_TEXTURE_2D, gbuffer_tex[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
glBindRenderbuffer(GL_RENDERBUFFER, rbo_depth);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
CHECK_GL_ERROR();
}
void OptimizationApp::initRendering(void) {
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
NvAssetLoaderAddSearchPath("es2-aurora/OptimizationApp");
#ifdef GL_OES_texture_3D
if (requireExtension("GL_EXT_framebuffer_blit", false)) {
glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))
getGLContext()->getGLProcAddress("glBlitFramebufferEXT");
} else if (getGLContext()->getConfiguration().apiVer != NvGfxAPIVersionES2()) {
glBlitFramebufferFunc = (void (KHRONOS_APIENTRY *) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter))
getGLContext()->getGLProcAddress("glBlitFramebuffer");
} else {
glBlitFramebufferFunc = NULL;
}
#else
glBlitFramebufferFunc = glBlitFramebuffer;
#endif
if (getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2()) {
gFloatTypeEnum = 0x8D61; // GL_HALF_FLOAT_OES, not declared in GL
gLumaTypeEnum = GL_LUMINANCE;
} else {
gFloatTypeEnum = GL_FLOAT;
gLumaTypeEnum = 0x1903; // GL_RED, not declared in ES
}
m_sceneRenderer = new SceneRenderer(
getGLContext()->getConfiguration().apiVer == NvGfxAPIVersionES2());
CHECK_GL_ERROR();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glClearColor(0.0, 0.0, 1.0, 1.0);
}
GLuint ParticleSystem::createShaderPipelineProgram(GLuint target, const char* src)
{
GLuint object;
GLint status;
const GLchar* fullSrc[2] = { m_shaderPrefix, src };
object = glCreateShaderProgramv( target, 2, fullSrc);
{
GLint logLength;
glGetProgramiv(object, GL_INFO_LOG_LENGTH, &logLength);
char *log = new char [logLength];
glGetProgramInfoLog(object, logLength, 0, log);
LOGI("Shader pipeline program not valid:\n%s\n", log);
delete [] log;
}
glBindProgramPipeline(m_programPipeline);
glUseProgramStages(m_programPipeline, GL_COMPUTE_SHADER_BIT, object);
glValidateProgramPipeline(m_programPipeline);
glGetProgramPipelineiv(m_programPipeline, GL_VALIDATE_STATUS, &status);
if (status != GL_TRUE) {
GLint logLength;
glGetProgramPipelineiv(m_programPipeline, GL_INFO_LOG_LENGTH, &logLength);
char *log = new char [logLength];
glGetProgramPipelineInfoLog(m_programPipeline, logLength, 0, log);
LOGI("Shader pipeline not valid:\n%s\n", log);
delete [] log;
}
glBindProgramPipeline(0);
CHECK_GL_ERROR();
return object;
}
void GLTexture::allocBuffer(GLuint w, GLuint h) {
_realWidth = w;
_realHeight = h;
if (!_refresh) {
if (npot_supported && _filter == GL_LINEAR) {
// Check if we already allocated a correctly-sized buffer
// This is so we don't need to duplicate the last row/column
if (w == _textureWidth && h == _textureHeight)
return;
} else {
// Check if we already have a large enough buffer
if (w <= _textureWidth && h <= _textureHeight)
return;
}
}
if (npot_supported) {
_textureWidth = w;
_textureHeight = h;
} else {
_textureWidth = nextHigher2(w);
_textureHeight = nextHigher2(h);
}
// Select this OpenGL texture
glBindTexture(GL_TEXTURE_2D, _textureName); CHECK_GL_ERROR();
// Set the texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, _filter); CHECK_GL_ERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, _filter); CHECK_GL_ERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); CHECK_GL_ERROR();
// Allocate room for the texture
glTexImage2D(GL_TEXTURE_2D, 0, _internalFormat,
_textureWidth, _textureHeight, 0, _glFormat, _glType, NULL); CHECK_GL_ERROR();
_refresh = false;
}
static void bind_texture(texture_asset* texture) {
Assert(texture->resource_handle != 0);
glBindTexture(GL_TEXTURE_2D, texture->resource_handle);
CHECK_GL_ERROR();
current_texture_asset = texture->handle;
}
static uint32 create_texture() {
uint32 id = 0;
glGenTextures(1, &id);
CHECK_GL_ERROR();
return id;
}
static void set_uniform_int(int32 location, int32 value) {
glUniform1i(location, value);
CHECK_GL_ERROR();
}
static void set_uniform_matrix4(int32 location, const glm::mat4& matrix) {
glUniformMatrix4fv(location, 1, false, glm::value_ptr(matrix));
CHECK_GL_ERROR();
}
static void set_vertex_attribute(vertex_attribute index, int components, int stride, void* pointer) {
glVertexAttribPointer((GLuint) index, components, GL_FLOAT, GL_FALSE, stride, pointer);
CHECK_GL_ERROR();
glEnableVertexAttribArray((GLuint) index);
CHECK_GL_ERROR();
}
static void draw_vertex_array(gl_vertex_array* vertex_array) {
glDrawElements(vertex_array->mode, vertex_array->index_count, GL_UNSIGNED_INT, vertex_array->index_buffer.memory);
CHECK_GL_ERROR();
}
static void create_vertex_array(gl_vertex_array* vertex_array) {
glGenVertexArrays(1, &vertex_array->id);
CHECK_GL_ERROR();
vertex_array->mode = GL_TRIANGLES;
vertex_array->index_buffer.target = GL_ELEMENT_ARRAY_BUFFER;
}
static void destroy_vertex_array(gl_vertex_array* vertex_array) {
glDeleteVertexArrays(1, &vertex_array->id);
CHECK_GL_ERROR();
}
void
OpenSubdivPtexShader::draw(const MHWRender::MDrawContext &mDrawContext,
OsdPtexMeshData *data)
{
MStatus status;
glPushAttrib(GL_POLYGON_BIT|GL_ENABLE_BIT);
// in ptexviewer, cull back face even in wireframe mode (for performance)
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
if (_wireframe) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
} else {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
CHECK_GL_ERROR("draw begin\n");
// If shader source attribute has changed, update effectRegistry
updateRegistry();
GLuint bPosition = data->bindPositionVBO();
GLuint bNormal = data->bindNormalVBO();
OpenSubdiv::OsdGLDrawContext *osdDrawContext = data->getDrawContext();
glBindBuffer(GL_ARRAY_BUFFER, bPosition);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);
glEnableVertexAttribArray(0);
if (not _adaptive) {
glBindBuffer(GL_ARRAY_BUFFER, bNormal);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 3, 0);
glEnableVertexAttribArray(1);
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, osdDrawContext->patchIndexBuffer);
OpenSubdiv::OsdPatchArrayVector const & patches =
osdDrawContext->patchArrays;
for (size_t i = 0; i < patches.size(); ++i) {
OpenSubdiv::OsdPatchArray const & patch = patches[i];
GLint surfaceProgram = bindProgram(mDrawContext, osdDrawContext, patch);
if (patch.desc.type != OpenSubdiv::kNonPatch) {
glPatchParameteri(GL_PATCH_VERTICES, patch.desc.GetPatchSize());
if (osdDrawContext->GetVertexTextureBuffer()) {
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_BUFFER,
osdDrawContext->GetVertexTextureBuffer());
glTexBuffer(GL_TEXTURE_BUFFER, GL_R32F, bPosition);
}
if (osdDrawContext->GetVertexValenceTextureBuffer()) {
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_BUFFER,
osdDrawContext->GetVertexValenceTextureBuffer());
}
if (osdDrawContext->GetQuadOffsetsTextureBuffer()) {
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_BUFFER,
osdDrawContext->GetQuadOffsetsTextureBuffer());
}
if (osdDrawContext->GetPatchParamTextureBuffer()) {
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_BUFFER,
osdDrawContext->GetPatchParamTextureBuffer());
}
glActiveTexture(GL_TEXTURE0);
glDrawElements(GL_PATCHES,
patch.numIndices, GL_UNSIGNED_INT,
reinterpret_cast<void *>(patch.firstIndex *
sizeof(unsigned int)));
} else {
GLint nonAdaptiveLevel = glGetUniformLocation(surfaceProgram,
"nonAdaptiveLevel");
if (nonAdaptiveLevel != -1) {
glProgramUniform1i(surfaceProgram, nonAdaptiveLevel, _level);
}
glDrawElements(_scheme == OsdPtexMeshData::kLoop ? GL_TRIANGLES : GL_LINES_ADJACENCY,
patch.numIndices, GL_UNSIGNED_INT,
reinterpret_cast<void *>(patch.firstIndex *
sizeof(unsigned int)));
}
CHECK_GL_ERROR("post draw\n");
}
glUseProgram(0);
glDisableVertexAttribArray(0);
if (not _adaptive)
glDisableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glPopAttrib();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
CHECK_GL_ERROR("draw end\n");
}
static void bind_vertex_array(gl_vertex_array* vertex_array) {
glBindVertexArray(vertex_array->id);
CHECK_GL_ERROR();
bind_gl_buffer(&vertex_array->index_buffer);
bind_gl_buffer(&vertex_array->vertex_buffer);
}
GLuint
OpenSubdivPtexShader::bindProgram(const MHWRender::MDrawContext & mDrawContext,
OpenSubdiv::OsdGLDrawContext *osdDrawContext,
const OpenSubdiv::OsdPatchArray & patch)
{
CHECK_GL_ERROR("bindProgram begin\n");
// Build shader
Effect effect;
effect.color = _enableColor;
effect.occlusion = _enableOcclusion;
effect.displacement = _enableDisplacement;
effect.normal = _enableNormal;
EffectDesc effectDesc( patch.desc, effect );
EffectDrawRegistry::ConfigType *
config = effectRegistry.GetDrawConfig(effectDesc);
// Install shader
GLuint program = config->program;
glUseProgram(program);
// Update and bind transform state
struct Transform {
float ModelViewMatrix[16];
float ProjectionMatrix[16];
float ModelViewProjectionMatrix[16];
} transformData;
setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewMtx),
transformData.ModelViewMatrix);
setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kProjectionMtx),
transformData.ProjectionMatrix);
setMatrix(mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewProjMtx),
transformData.ModelViewProjectionMatrix);
if (!g_transformUB) {
glGenBuffers(1, &g_transformUB);
glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(transformData), NULL, GL_STATIC_DRAW);
};
glBindBuffer(GL_UNIFORM_BUFFER, g_transformUB);
glBufferSubData(GL_UNIFORM_BUFFER,
0, sizeof(transformData), &transformData);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindBufferBase(GL_UNIFORM_BUFFER, g_transformBinding, g_transformUB);
// Update and bind tessellation state
struct Tessellation {
float TessLevel;
int GregoryQuadOffsetBase;
int PrimitiveIdBase;
} tessellationData;
tessellationData.TessLevel = static_cast<float>(1 << _tessFactor);
tessellationData.GregoryQuadOffsetBase = patch.GetQuadOffsetBase;
tessellationData.PrimitiveIdBase = patch.GetPatchIndex();;
if (!g_tessellationUB) {
glGenBuffers(1, &g_tessellationUB);
glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(tessellationData), NULL, GL_STATIC_DRAW);
};
glBindBuffer(GL_UNIFORM_BUFFER, g_tessellationUB);
glBufferSubData(GL_UNIFORM_BUFFER,
0, sizeof(tessellationData), &tessellationData);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindBufferBase(GL_UNIFORM_BUFFER,
g_tessellationBinding,
g_tessellationUB);
#ifdef USE_NON_IMAGE_BASED_LIGHTING
// Update and bind lighting state
int numLights = mDrawContext.numberOfActiveLights();
struct Lighting {
struct Light {
float position[4];
float diffuse[4];
float ambient[4];
float specular[4];
} lightSource[2];
} lightingData;
memset(&lightingData, 0, sizeof(lightingData));
for (int i = 0; i < numLights && i < 1; ++i) {
MFloatPointArray positions;
MFloatVector direction;
float intensity;
MColor color;
bool hasDirection, hasPosition;
mDrawContext.getLightInformation(i, positions, direction, intensity,
color, hasDirection, hasPosition);
Lighting::Light &light = lightingData.lightSource[i];
if (hasDirection) {
light.position[0] = -direction[0];
light.position[1] = -direction[1];
light.position[2] = -direction[2];
for (int j = 0; j < 4; ++j) {
light.diffuse[j] = color[j] * intensity;
light.ambient[j] = color[j] * intensity;
light.specular[j] = color[j] * intensity;
}
}
}
if (!g_lightingUB) {
glGenBuffers(1, &g_lightingUB);
glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(lightingData), NULL, GL_STATIC_DRAW);
};
glBindBuffer(GL_UNIFORM_BUFFER, g_lightingUB);
glBufferSubData(GL_UNIFORM_BUFFER,
0, sizeof(lightingData), &lightingData);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindBufferBase(GL_UNIFORM_BUFFER, g_lightingBinding, g_lightingUB);
#endif
GLint eye = glGetUniformLocation(program, "eyePositionInWorld");
MPoint e = MPoint(0, 0, 0) *
mDrawContext.getMatrix(MHWRender::MDrawContext::kWorldViewInverseMtx);
glProgramUniform3f(program, eye,
static_cast<float>(e.x),
static_cast<float>(e.y),
static_cast<float>(e.z));
// update other uniforms
float color[4] = { 0, 0, 0, 1 };
_diffuse.get(color);
glProgramUniform4fv(program,
glGetUniformLocation(program, "diffuseColor"),
1, color);
_ambient.get(color);
glProgramUniform4fv(program,
glGetUniformLocation(program, "ambientColor"),
1, color);
_specular.get(color);
glProgramUniform4fv(program,
glGetUniformLocation(program, "specularColor"),
1, color);
glProgramUniform1f(program,
glGetUniformLocation(program, "fresnelBias"),
_fresnelBias);
glProgramUniform1f(program,
glGetUniformLocation(program, "fresnelScale"),
_fresnelScale);
glProgramUniform1f(program,
glGetUniformLocation(program, "fresnelPower"),
_fresnelPower);
// Ptex bindings
// color ptex
if (effectRegistry.getPtexColorValid()) {
GLint texData = glGetUniformLocation(program, "textureImage_Data");
glProgramUniform1i(program, texData, CLR_TEXTURE_UNIT + 0);
GLint texPacking = glGetUniformLocation(program, "textureImage_Packing");
glProgramUniform1i(program, texPacking, CLR_TEXTURE_UNIT + 1);
GLint texPages = glGetUniformLocation(program, "textureImage_Pages");
glProgramUniform1i(program, texPages, CLR_TEXTURE_UNIT + 2);
}
// displacement ptex
if (effectRegistry.getPtexDisplacementValid()) {
GLint texData = glGetUniformLocation(program, "textureDisplace_Data");
glProgramUniform1i(program, texData, DISP_TEXTURE_UNIT + 0);
GLint texPacking = glGetUniformLocation(program, "textureDisplace_Packing");
glProgramUniform1i(program, texPacking, DISP_TEXTURE_UNIT + 1);
GLint texPages = glGetUniformLocation(program, "textureDisplace_Pages");
glProgramUniform1i(program, texPages, DISP_TEXTURE_UNIT + 2);
}
// occlusion ptex
if (effectRegistry.getPtexOcclusionValid()) {
GLint texData = glGetUniformLocation(program, "textureOcclusion_Data");
glProgramUniform1i(program, texData, OCC_TEXTURE_UNIT + 0);
GLint texPacking = glGetUniformLocation(program, "textureOcclusion_Packing");
glProgramUniform1i(program, texPacking, OCC_TEXTURE_UNIT + 1);
GLint texPages = glGetUniformLocation(program, "textureOcclusion_Pages");
glProgramUniform1i(program, texPages, OCC_TEXTURE_UNIT + 2);
}
// diffuse environment map
if (effectRegistry.getDiffuseEnvironmentId() != 0) {
GLint difmap = glGetUniformLocation(program, "diffuseEnvironmentMap");
glProgramUniform1i(program, difmap, DIFF_TEXTURE_UNIT);
}
// specular environment map
if (effectRegistry.getSpecularEnvironmentId() != 0) {
GLint envmap = glGetUniformLocation(program, "specularEnvironmentMap");
glProgramUniform1i(program, envmap, ENV_TEXTURE_UNIT);
}
glActiveTexture(GL_TEXTURE0);
CHECK_GL_ERROR("bindProgram leave\n");
return program;
}
static void set_uniform_vector4f(int32 location, vector4f vector) {
glUniform4fv(location, 1, &vector.x);
CHECK_GL_ERROR();
}
static uint32 create_shader(uint32 type) {
uint32 id = glCreateShader(type);
CHECK_GL_ERROR();
return id;
}
static void set_uniform_float(int32 location, float value) {
glUniform1f(location, value);
CHECK_GL_ERROR();
}
static void destroy_shader(uint32 id) {
Assert(id != 0);
glDeleteShader(id);
CHECK_GL_ERROR();
}
static void bind_shader_program(shader_asset* shader) {
Assert(shader->program_id != 0);
current_shader_asset = shader->handle;
glUseProgram(shader->program_id);
CHECK_GL_ERROR();
}
static void attach_fragment_shader(uint32 shader_program, uint32 fragment_shader) {
glAttachShader(shader_program, fragment_shader);
CHECK_GL_ERROR();
}
static void destroy_texture(uint32 id) {
Assert(id != 0);
glDeleteTextures(1, &id);
CHECK_GL_ERROR();
}
static void bind_gl_buffer(gl_buffer* buffer) {
Assert(buffer->id != 0);
glBindBuffer(buffer->target, buffer->id);
CHECK_GL_ERROR();
}
JNIEXPORT void JNICALL JNIFUNCTION_NATIVE(nativeDrawFrame(JNIEnv* env, jobject obj))
{
float width, height;
float viewProjection[16];
if (!videoInited) {
#ifdef DEBUG
LOGI("nativeDrawFrame !VIDEO\n");
#endif
return; // No point in trying to draw until video is inited.
}
#ifdef DEBUG
LOGI("nativeDrawFrame\n");
#endif
if (!gARViewInited) {
if (!initARView()) return;
}
if (gARViewLayoutRequired) layoutARView();
// Upload new video frame if required.
if (videoFrameNeedsPixelBufferDataUpload) {
arglPixelBufferDataUploadBiPlanar(gArglSettings, gVideoFrame, gVideoFrame + videoWidth*videoHeight);
videoFrameNeedsPixelBufferDataUpload = false;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the buffers for new frame.
// Display the current frame
arglDispImage(gArglSettings);
if (!program) {
GLuint vertShader = 0, fragShader = 0;
// A simple shader pair which accepts just a vertex position and colour, no lighting.
const char vertShaderString[] =
"attribute vec4 position;\n"
"attribute vec4 colour;\n"
"uniform mat4 modelViewProjectionMatrix;\n"
"varying vec4 colourVarying;\n"
"void main()\n"
"{\n"
"gl_Position = modelViewProjectionMatrix * position;\n"
"colourVarying = colour;\n"
"}\n";
const char fragShaderString[] =
"#ifdef GL_ES\n"
"precision mediump float;\n"
"#endif\n"
"varying vec4 colourVarying;\n"
"void main()\n"
"{\n"
"gl_FragColor = colourVarying;\n"
"}\n";
if (program) arglGLDestroyShaders(0, 0, program);
program = glCreateProgram();
if (!program) {
ARLOGe("drawCube: Error creating shader program.\n");
arglGLDestroyShaders(vertShader, fragShader, program);
return;
}
if (!arglGLCompileShaderFromString(&vertShader, GL_VERTEX_SHADER, vertShaderString)) {
ARLOGe("drawCube: Error compiling vertex shader.\n");
arglGLDestroyShaders(vertShader, fragShader, program);
return;
}
if (!arglGLCompileShaderFromString(&fragShader, GL_FRAGMENT_SHADER, fragShaderString)) {
ARLOGe("drawCube: Error compiling fragment shader.\n");
arglGLDestroyShaders(vertShader, fragShader, program);
return;
}
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
glBindAttribLocation(program, ATTRIBUTE_VERTEX, "position");
glBindAttribLocation(program, ATTRIBUTE_COLOUR, "colour");
if (!arglGLLinkProgram(program)) {
ARLOGe("drawCube: Error linking shader program.\n");
arglGLDestroyShaders(vertShader, fragShader, program);
return;
}
arglGLDestroyShaders(vertShader, fragShader, 0); // After linking, shader objects can be deleted.
// Retrieve linked uniform locations.
uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX] = glGetUniformLocation(program, "modelViewProjectionMatrix");
}
glUseProgram(program);
// Set up 3D mode.
mtxLoadIdentityf(viewProjection);
mtxMultMatrixf(viewProjection, cameraLens);
glStateCacheEnableDepthTest();
// Set any initial per-frame GL state you require here.
// --->
// Lighting and geometry that moves with the camera should be added here.
// (I.e. should be specified before camera pose transform.)
// --->
// Draw an object on all valid markers.
for (int i = 0; i < markersSquareCount; i++) {
if (markersSquare[i].valid) {
float viewProjection2[16];
mtxLoadMatrixf(viewProjection2, viewProjection);
mtxMultMatrixf(viewProjection2, markersSquare[i].pose.T);
drawCube(viewProjection2, 40.0f, 0.0f, 0.0f, 20.0f);
}
}
if (cameraPoseValid) {
mtxMultMatrixf(viewProjection, cameraPose);
// All lighting and geometry to be drawn in world coordinates goes here.
// --->
}
// If you added external OpenGL code above, and that code doesn't use the glStateCache routines,
// then uncomment the line below.
//glStateCacheFlush();
// Set up 2D mode.
mtxLoadIdentityf(viewProjection);
width = (float)viewPort[viewPortIndexWidth];
height = (float)viewPort[viewPortIndexHeight];
mtxOrthof(viewProjection, 0.0f, width, 0.0f, height, -1.0f, 1.0f);
glStateCacheDisableDepthTest();
// Add your own 2D overlays here.
// --->
// If you added external OpenGL code above, and that code doesn't use the glStateCache routines,
// then uncomment the line below.
//glStateCacheFlush();
#ifdef DEBUG
// Example of 2D drawing. It just draws a white border line. Change the 0 to 1 to enable.
const GLfloat square_vertices [4][3] = { {0.5f, 0.5f, 0.0f}, {0.5f, height - 0.5f, 0.0f}, {width - 0.5f, height - 0.5f, 0.0f}, {width - 0.5f, 0.5f, 0.0f} };
const GLubyte square_vertex_colors_white [4][4] = {
{255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}};
glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX], 1, GL_FALSE, viewProjection);
glVertexAttribPointer(ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_FALSE, 0, square_vertices);
glEnableVertexAttribArray(ATTRIBUTE_VERTEX);
glVertexAttribPointer(ATTRIBUTE_COLOUR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, square_vertex_colors_white);
glEnableVertexAttribArray(ATTRIBUTE_COLOUR);
if (!arglGLValidateProgram(program)) {
ARLOGe("Error: shader program %d validation failed.\n", program);
return;
}
glDrawArrays(GL_LINE_LOOP, 0, 4);
#endif
#ifdef DEBUG
CHECK_GL_ERROR();
#endif
}
static void upload_gl_buffer_data(gl_buffer* buffer) {
Assert(buffer->memory && buffer->id != 0 && buffer->size != 0);
bind_gl_buffer(buffer);
glBufferData(buffer->target, buffer->size, buffer->memory, buffer->usage);
CHECK_GL_ERROR();
}
