//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(); }