void InitializeProgram() { UniformColor = LoadProgram("\\shaders\\PosOnlyWorldTransformUBO.vert", "\\shaders\\ColorUniform.frag"); ObjectColor = LoadProgram("\\shaders\\PosColorWorldTransformUBO.vert", "\\shaders\\ColorPassthrough.frag"); UniformColorTint = LoadProgram("\\shaders\\PosColorWorldTransformUBO.vert", "\\shaders\\ColorMultUniform.frag"); glGenBuffers(1, &g_GlobalMatricesUBO); glBindBuffer(GL_UNIFORM_BUFFER, g_GlobalMatricesUBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, NULL, GL_STREAM_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferRange(GL_UNIFORM_BUFFER, g_iGlobalMatricesBindingIndex, g_GlobalMatricesUBO, 0, sizeof(glm::mat4) * 2); }
void renderFB() { glm::vec2 WindowSize(this->getWindowSize()); glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE); glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y); glClearNamedFramebufferfv(0, GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]); glBindFramebuffer(GL_FRAMEBUFFER, 0); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], this->UniformBlockSize, this->UniformBlockSize); glBindTextureUnit(0, TextureName[texture::COLORBUFFER]); glBindVertexArray(VertexArrayName); glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, nullptr, 1, 0, 0); }
void GLHelper::attachUBOs(const GLuint program) const {//Attach the light block to our UBO GLuint lightAttachPoint = 0, playerAttachPoint = 1; int uniformIndex = glGetUniformBlockIndex(program, "LightSourceBlock"); if (uniformIndex >= 0) { glBindBuffer(GL_UNIFORM_BUFFER, lightUBOLocation); glUniformBlockBinding(program, uniformIndex, lightAttachPoint); glBindBufferRange(GL_UNIFORM_BUFFER, lightAttachPoint, lightUBOLocation, 0, (sizeof(glm::mat4) + 2 * sizeof(glm::vec4)) * NR_POINT_LIGHTS); //FIXME calculating the size should not be like that glBindBuffer(GL_UNIFORM_BUFFER, 0); } int uniformIndex2 = glGetUniformBlockIndex(program, "PlayerTransformBlock"); if (uniformIndex2 >= 0) { glBindBuffer(GL_UNIFORM_BUFFER, playerUBOLocation); glUniformBlockBinding(program, uniformIndex2, playerAttachPoint); glBindBufferRange(GL_UNIFORM_BUFFER, playerAttachPoint, playerUBOLocation, 0, 3 * sizeof(glm::mat4)); glBindBuffer(GL_UNIFORM_BUFFER, 0); } }
void ProgramShaderCache::UploadConstants() { if(PixelShaderManager::dirty || VertexShaderManager::dirty) { auto buffer = s_buffer->Map(s_ubo_buffer_size, s_ubo_align); memcpy(buffer.first, &PixelShaderManager::constants, sizeof(PixelShaderConstants)); memcpy(buffer.first + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align), &VertexShaderManager::constants, sizeof(VertexShaderConstants)); s_buffer->Unmap(s_ubo_buffer_size); glBindBufferRange(GL_UNIFORM_BUFFER, 1, s_buffer->m_buffer, buffer.second, sizeof(PixelShaderConstants)); glBindBufferRange(GL_UNIFORM_BUFFER, 2, s_buffer->m_buffer, buffer.second + ROUND_UP(sizeof(PixelShaderConstants), s_ubo_align), sizeof(VertexShaderConstants)); PixelShaderManager::dirty = false; VertexShaderManager::dirty = false; ADDSTAT(stats.thisFrame.bytesUniformStreamed, s_ubo_buffer_size); } }
GLuint Model::setupShaders() { modelShaderProgram.loadShaderProgram(mResourcePath, "/resources/shaders/standard.v.glsl", "/resources/shaders/standard.f.glsl"); GLuint p = modelShaderProgram.shader.program; glBindFragDataLocation(p, 0, "color"); glBindAttribLocation(p,vertexLoc,"vertexPosition_modelspace"); glBindAttribLocation(p,normalLoc,"vertexNormal_modelspace"); glBindAttribLocation(p,texCoordLoc,"vertexUV"); glLinkProgram(p); glValidateProgram(p); GLuint k = glGetUniformBlockIndex(p,"Matrices"); glUniformBlockBinding(p, k, matricesUniLoc); glUniformBlockBinding(p, glGetUniformBlockIndex(p,"Material"), materialUniLoc); texUnit = glGetUniformLocation(p,"textureIn"); ModelUniformLocations[0] = glGetUniformLocation(modelShaderProgram.shader.program, "MVP"); ModelUniformLocations[1] = glGetUniformLocation(modelShaderProgram.shader.program, "V"); ModelUniformLocations[2] = glGetUniformLocation(modelShaderProgram.shader.program, "M"); ModelUniformLocations[3] = glGetUniformLocation(modelShaderProgram.shader.program, "textureIn"); ModelUniformLocations[4] = glGetUniformLocation(modelShaderProgram.shader.program, "MV"); ModelUniformLocations[5] = glGetUniformLocation(groundShaderProgram.shader.program, "LightPosition_worldspace"); ModelAttribLocations[0] = glGetAttribLocation(modelShaderProgram.shader.program, "vertexPosition_modelspace"); ModelAttribLocations[1] = glGetAttribLocation(modelShaderProgram.shader.program, "vertexNormal_modelspace"); ModelAttribLocations[2] = glGetAttribLocation(modelShaderProgram.shader.program, "vertexUV"); // // Uniform Block // glGenBuffers(1,&matricesUniBuffer); glBindBuffer(GL_UNIFORM_BUFFER, matricesUniBuffer); glBufferData(GL_UNIFORM_BUFFER, MatricesUniBufferSize,NULL,GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, matricesUniLoc, matricesUniBuffer, 0, MatricesUniBufferSize); //setUniforms(); glBindBuffer(GL_UNIFORM_BUFFER,0); // glEnable(GL_MULTISAMPLE); return(p); }
//Called after the window and OpenGL are initialized. Called exactly once, before the main loop. void init() { InitializeProgram(); InitializeVertexData(); LoadTextures(); //Setup our Uniform Buffers glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, g_projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); }
void GL3Descriptor::bind() { switch (_data.type) { case DescriptorType::UniformBuffer: glBindBufferRange(GL_UNIFORM_BUFFER, mapDescriptorSetPartLocation(_data.part), _data.descriptor_data.buffer.buffer->getHandle(), _data.descriptor_data.buffer.offset, _data.descriptor_data.buffer.size); break; case DescriptorType::Texture: _data.descriptor_data.texture.bind(mapDescriptorSetPartLocation(_data.part)); break; } _active = true; }
XCamReturn GLBuffer::bind_buffer_range (uint32_t index, uint32_t offset, uint32_t size) { XCamReturn ret = bind (); XCAM_FAIL_RETURN ( ERROR, xcam_ret_is_ok (ret), ret, "GL bind buffer failed, buf_id:%d", _buf_id); glBindBufferRange (_target, index, _buf_id, offset, size); GLenum error = gl_error (); XCAM_FAIL_RETURN ( ERROR, error == GL_NO_ERROR, XCAM_RETURN_ERROR_GLES, "GL bind buffer range failed. buf_id:%d failed, idx:%d, error flag: %s", _buf_id, index, gl_error_string (error)); return XCAM_RETURN_NO_ERROR; }
void gr_opengl_bind_uniform_buffer(uniform_block_type bind_point, size_t offset, size_t size, int buffer) { GR_DEBUG_SCOPE("Bind uniform buffer range"); GLuint buffer_handle = 0; if (buffer != -1) { Assert(buffer >= 0); Assert((size_t)buffer < GL_buffer_objects.size()); opengl_buffer_object &buffer_obj = GL_buffer_objects[buffer]; Assertion(buffer_obj.type == GL_UNIFORM_BUFFER, "Only uniform buffers are valid for this function!"); buffer_handle = buffer_obj.buffer_id; } glBindBufferRange(GL_UNIFORM_BUFFER, static_cast<GLuint>(bind_point), buffer_handle, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size)); }
void WindowsShadowRenderer::setupDraw() { Core::SmartPtr<Rendering::BufferBase> dynamicBuffer = BufferManager::get()->getDynamicBuffer(); unsigned int dynamicBufferID = BufferManager::get()->getDynamicBuffer()->getCurrBufferID(); if (_fbo == 0) createFrameBuffer(); glViewport(0, 0, _bufferWidth, _bufferHeight); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glBindFramebuffer(GL_FRAMEBUFFER, _fbo); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); checkFrameBufferStatus(); //const float one = 1.0f; //glClearBufferfv(GL_DEPTH, 0, &one); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glUseProgram(_program); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glBindBufferRange(GL_UNIFORM_BUFFER, 13, dynamicBufferID, _sliceMatrixBase, _sliceMatrixSize); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); }
void Test4::Init(){ cout<<endl<<"INIT TEST 4 FLAT SHADING "<<endl; /*************** 0 -- Retrec l'apuntador al objecte VIDEO MANAGER per no fer una indireccio més cada cop */ VideoManager *m_video_manager_pointer = VideoManager::GetInstance(); /************ 1 -- CARREGO OBJECTES ********************/ m_mesh1 = new Mesh_OBJ2(); m_mesh1->CarregaFitxer("donut.obj"); //m_mesh1->CarregaFitxer("esfera32.obj"); //m_mesh1->CarregaFitxer("cub.obj"); //m_mesh1->CarregaFitxer("doscubs_Scene.obj"); /************ 2 -- CREO UN PROGRAMA AMB ELS SHADERS ***************/ m_GL_program = new CGLProgram(); m_GL_program->AttachShader("recursos/shaders/Test4.vert",GL_VERTEX_SHADER); m_GL_program->AttachShader("recursos/shaders/Test4.frag",GL_FRAGMENT_SHADER); // FAIG QUE EL ATRIBUT 0 (QUE SON LES CORDENADES DELS VERTEX) ENTRIN a "in_Position" al vertex shader m_GL_program->Bind_Attribute_Location(0,"in_Position"); m_GL_program->Bind_Attribute_Location(1,"in_Normals"); m_GL_program->Link(); //CARREGO UNIFORMS GLuint l_block_index = glGetUniformBlockIndex(m_GL_program->m_ID,"MatriusGlobals"); glUniformBlockBinding(m_GL_program->m_ID,l_block_index,0); glBindBufferRange(GL_UNIFORM_BUFFER,0,m_video_manager_pointer->Get_UBO_Matrius_globals_location(),0 * sizeof(glm::mat4),2*sizeof(glm::mat4)); //CARREGO UNA LLUM m_llum = new CGLLlum(vec3(0.0,32.0,0.0),vec3(0.8,0.7,0.5),0.2); }
void piglit_init(int argc, char **argv) { float verts[] = { -1, -1, 1, -1, 1, 1, -1, 1 }; GLuint vbo, xfb, vs, fs, prog; const char *varying = "gl_Position"; piglit_require_extension("GL_EXT_transform_feedback"); piglit_require_gl_version(30); piglit_require_transform_feedback(); glGenBuffersARB(1, &vbo); glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo); glBufferDataARB(GL_ARRAY_BUFFER_ARB, 8 * sizeof(float), verts, GL_DYNAMIC_DRAW); glGenBuffersARB(1, &xfb); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb); glBufferDataARB(GL_TRANSFORM_FEEDBACK_BUFFER, 4096, NULL, GL_DYNAMIC_DRAW); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source); prog = glCreateProgram(); glAttachShader(prog, vs); glAttachShader(prog, fs); glTransformFeedbackVaryings(prog, 1, &varying, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!fs || !vs || !prog) piglit_report_result(PIGLIT_FAIL); if (!piglit_link_check_status(prog)) piglit_report_result(PIGLIT_FAIL); glUseProgram(prog); glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb, 0, 4096); }
void renderFBO() { glEnable(GL_MULTISAMPLE); glEnable(GL_SAMPLE_SHADING); glMinSampleShading(4.0f); glClipControl(GL_LOWER_LEFT, GL_NEGATIVE_ONE_TO_ONE); glViewportIndexedf(0, 0, 0, static_cast<float>(FRAMEBUFFER_SIZE.x), static_cast<float>(FRAMEBUFFER_SIZE.y)); glClearNamedFramebufferfv(FramebufferName[framebuffer::RENDER], GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]); glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName[framebuffer::RENDER]); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], 0, this->UniformBlockSize); glBindSamplers(0, 1, &SamplerName); glBindTextureUnit(0, TextureName[texture::TEXTURE]); glBindVertexArray(VertexArrayName); glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, nullptr, 1, 0, 0); glDisable(GL_MULTISAMPLE); }
void draw() { VK_CHECK_RESULT(Swapchain.acquire(presentCompleteSemaphore, ¤tBuffer)); VK_CHECK_RESULT(vkWaitForFences(device, 1, &waitFences[currentBuffer], VK_TRUE, UINT64_MAX)); VK_CHECK_RESULT(vkResetFences(device, 1, &waitFences[currentBuffer])); glo::context* Context = (glo::context*)this->Context; Context->temp_set_framebuffer(frameBuffers[currentBuffer]); Context->temp_set_renderpass(renderPass, 0, 0, width, height); wglMakeCurrentGTC(this->DeviceContext, this->Context); VkCommandBuffer CommandBuffer = Context->temp_get_command_buffer(); glViewportIndexedf(0, 0, 0, width, height); glScissor(0, 0, width, height); vkCmdBindPipeline(CommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline); glBindBufferRange(GL_UNIFORM_BUFFER, 0, uniformDataVS.buffer, 0, sizeof(uboVS)); glBindVertexBuffer(VERTEX_BUFFER_BIND_ID, vertices.buffer, 0, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices.buffer); glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, indices.count, GL_UNSIGNED_INT, NULL, 1, 0, 0); glFlush(); VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; VkSubmitInfo submitInfo = {}; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submitInfo.pWaitDstStageMask = &waitStageMask; submitInfo.pWaitSemaphores = &presentCompleteSemaphore; submitInfo.waitSemaphoreCount = 1; submitInfo.pSignalSemaphores = &renderCompleteSemaphore; submitInfo.signalSemaphoreCount = 1; submitInfo.pCommandBuffers = &CommandBuffer; submitInfo.commandBufferCount = 1; VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, waitFences[currentBuffer])); VK_CHECK_RESULT(Swapchain.present(queue, currentBuffer, renderCompleteSemaphore)); }
void WindowsShadowRenderer::cleanupDraw() { glUseProgram(0); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glBindFramebuffer(GL_FRAMEBUFFER, _prevFB); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); int width, height; DriverInterface::DriverInterfaceBase::get()->getFrameBufferSize(width, height); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); Core::SmartPtr<Rendering::BufferBase> dynamicBuffer = BufferManager::get()->getDynamicBuffer(); unsigned int dynamicBufferID = BufferManager::get()->getDynamicBuffer()->getCurrBufferID(); glBindBufferRange(GL_UNIFORM_BUFFER, 9, dynamicBufferID, _viewToSliceMatrixBase, _sliceMatrixSize); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glActiveTexture(GL_TEXTURE0); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glBindTexture(GL_TEXTURE_2D_ARRAY, _texture); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_NONE); DriverInterface::DriverInterfaceBase::checkError(__FILE__, __LINE__); glViewport(0, 0, width, height); }
void renderFBO(GLuint Framebuffer) { glEnable(GL_DEPTH_TEST); glBindProgramPipeline(PipelineName[program::THROUGH]); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], 0, this->UniformBlockSize); glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y); glBindFramebuffer(GL_FRAMEBUFFER, Framebuffer); float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glBindTextures(0, 1, &TextureName[texture::DIFFUSE]); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 5); glDisable(GL_DEPTH_TEST); }
void Scene::DrawObject(const Framework::Mesh *pMesh, const std::string &meshName, const ProgramData &prog, int materialBlockIndex, int mtlIx, const glutil::MatrixStack &modelMatrix) { glBindBufferRange(GL_UNIFORM_BUFFER, materialBlockIndex, m_materialUniformBuffer, mtlIx * m_sizeMaterialBlock, sizeof(MaterialBlock)); glm::mat3 normMatrix(modelMatrix.Top()); normMatrix = glm::transpose(glm::inverse(normMatrix)); glUseProgram(prog.theProgram); glUniformMatrix4fv(prog.modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(modelMatrix.Top())); glUniformMatrix3fv(prog.normalModelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(normMatrix)); pMesh->Render(meshName); glUseProgram(0); glBindBufferBase(GL_UNIFORM_BUFFER, materialBlockIndex, 0); }
// Inicjalizuje meshe i parametry opengl void init() { initializeShaders(); try { g_pCylinderMesh = new Framework::Mesh("UnitCylinder.xml"); g_pShpere1Mesh = new Framework::Mesh("Sphere1.xml"); g_pShpere2Mesh = new Framework::Mesh("Sphere2.xml"); g_pPlaneMesh = new Framework::Mesh("LargePlane.xml"); g_pCubeMesh = new Framework::Mesh("UnitCube.xml"); g_pTetrahedron1Mesh = new Framework::Mesh("UnitTetrahedron1.xml"); } catch(std::exception &except) { printf("%s\n", except.what()); throw; } glutMouseFunc(MouseButton); glutMotionFunc(MouseMotion); glutMouseWheelFunc(MouseWheel); glutKeyboardUpFunc(onKeyUp); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(0.0f, 1.0f); glEnable(GL_DEPTH_CLAMP); glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); }
int init() { if (!IO::Import3DFromFile(modelname)) { std::cout << "Failed 3d model import\n\n"<< std::endl; return(0); } IO::LoadGLTextures(); glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) glutGetProcAddress("glGetUniformBlockIndex"); glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) glutGetProcAddress("glUniformBlockBinding"); glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) glutGetProcAddress("glGenVertexArrays"); glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glutGetProcAddress("glBindVertexArray"); glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC) glutGetProcAddress("glBindBufferRange"); glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) glutGetProcAddress("glDeleteVertexArrays"); program = Shaders::setupShaders(vertexfile, fragmentfile); Render::genVAOsAndUniformBuffer(); glEnable(GL_DEPTH_TEST); glClearColor(1.0f, 0.0f, 1.0f, 0.0f); // // Uniform Block // glGenBuffers(1,&matricesUniBuffer); glBindBuffer(GL_UNIFORM_BUFFER, matricesUniBuffer); glBufferData(GL_UNIFORM_BUFFER, MatricesUniBufferSize,NULL,GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, matricesUniLoc, matricesUniBuffer, 0, MatricesUniBufferSize); glBindBuffer(GL_UNIFORM_BUFFER,0); glEnable(GL_MULTISAMPLE); return true; }
//Called after the window and OpenGL are initialized. Called exactly once, before the main loop. void init() { InitializeProgram(); try { g_pCylinderMesh = new Framework::Mesh("UnitCylinder.xml"); g_pPlaneMesh = new Framework::Mesh("LargePlane.xml"); } catch(std::exception &except) { printf("%s\n", except.what()); throw; } glutMouseFunc(MouseButton); glutMotionFunc(MouseMotion); glutMouseWheelFunc(MouseWheel); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(0.0f, 1.0f); glEnable(GL_DEPTH_CLAMP); glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); //Bind the static buffers. glBindBufferRange(GL_UNIFORM_BUFFER, g_projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); }
void Model::recursive_render(const aiScene *sc, const aiNode* nd, const glm::mat4 &MVP, const glm::mat4 &V, const glm::mat4 &M, bool shadowPass, const glm::mat4 &depthMVP) { aiMatrix4x4 m = nd->mTransformation; m.Transpose(); // OpenGL matrices are column major glm::mat4 transformation(m.a1, m.a2, m.a3, m.a4, m.b1, m.b2, m.b3, m.b4, m.c1, m.c2, m.c3, m.c4, m.d1, m.d2, m.d3, m.d4); glm::mat4 MVP2 = MVP*transformation; glm::mat4 M2 = M*transformation; if(shadowPass) { glUniformMatrix4fv(ShadowUniformLocations[0], 1, GL_FALSE, &MVP2[0][0]); } else { glUniformMatrix4fv(ModelUniformLocations[0], 1, GL_FALSE, &MVP2[0][0]); glUniformMatrix4fv(ModelUniformLocations[1], 1, GL_FALSE, &V[0][0]); glUniformMatrix4fv(ModelUniformLocations[2], 1, GL_FALSE, &M2[0][0]); glUniformMatrix4fv(ModelUniformLocations[4], 1, GL_FALSE, &(V*M2)[0][0]); if(ModelUniformLocations[5] > -1) glUniform3f(ModelUniformLocations[5], lightInvDir.x, lightInvDir.y, lightInvDir.z); } // draw node for (unsigned int n=0; n < nd->mNumMeshes; ++n){ glBindBufferRange(GL_UNIFORM_BUFFER, materialUniLoc, myMeshes[nd->mMeshes[n]].uniformBlockIndex, 0, sizeof(struct MyMaterial)); if(!shadowPass) { glBindTexture(GL_TEXTURE_2D, myMeshes[nd->mMeshes[n]].texIndex); } glBindVertexArray(myMeshes[nd->mMeshes[n]].vao); glDrawElements(GL_TRIANGLES,myMeshes[nd->mMeshes[n]].numFaces*3,GL_UNSIGNED_INT,0); } // draw children for (unsigned int n=0; n < nd->mNumChildren; ++n){ recursive_render(sc, nd->mChildren[n], MVP2, V, M2, shadowPass, depthMVP); } }
// render the 3D object void Object::render(Camera * camera, Light * light, GLdouble elapsedTime) { Program::useProgram(program); GLuint p = program->getProgram(); Mesh::aPositionLoc = glGetAttribLocation(p, "position"); Mesh::aTexCoordLoc = glGetAttribLocation(p, "texCoord"); Mesh::aNormalLoc = glGetAttribLocation(p, "normal"); Node::uModelMatrixLoc = glGetUniformLocation(p, "modelMatrix"); Camera::uViewMatrixLoc = glGetUniformLocation(p, "viewMatrix"); Camera::uProjMatrixLoc = glGetUniformLocation(p, "projMatrix"); Material::uboMaterialLoc = glGetUniformBlockIndex(p, "Material"); Light::uboLightLoc = glGetUniformBlockIndex(p, "Light"); Texture::uTextureCountLoc = glGetUniformLocation(p, "texCount"); Camera::uViewPosLoc = glGetUniformLocation(p, "viewPos"); glUniformMatrix4fv(Camera::uViewMatrixLoc, 1, GL_FALSE, glm::value_ptr(camera->getViewMatrix())); glUniformMatrix4fv(Camera::uProjMatrixLoc, 1, GL_FALSE, glm::value_ptr(camera->getProjectionMatrix())); glm::vec3 viewPos = camera->getViewPoint(); glUniform3f(Camera::uViewPosLoc, viewPos.x, viewPos.y, viewPos.z); #ifdef PRINT_CAMERA_POSITION cout << "Camera Pos:\t" << viewPos << endl; #endif if (light != NULL){ glBindBufferRange(GL_UNIFORM_BUFFER, Light::uboLightLoc, light->getUBOLight(), 0, sizeof(LightMaterial)); #ifdef PRINT_LIGHT_SOURCE cout << *(light->uLight) << endl; #endif } model->render(); }
void renderFBO() { //glEnable(GL_SAMPLE_MASK); //glSampleMaski(0, 0xFF); glEnable(GL_MULTISAMPLE); glEnable(GL_SAMPLE_SHADING); glMinSampleShading(4.0f); glViewportIndexedf(0, 0, 0, static_cast<float>(FRAMEBUFFER_SIZE.x), static_cast<float>(FRAMEBUFFER_SIZE.y)); glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName[framebuffer::RENDER]); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]); glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], 0, this->UniformBlockSize); glBindSampler(0, SamplerName); glBindMultiTextureEXT(GL_TEXTURE0, GL_TEXTURE_2D, TextureName[texture::TEXTURE]); glBindVertexArray(VertexArrayName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, nullptr, 1, 0, 0); glDisable(GL_MULTISAMPLE); }
void recursive_render(const aiNode* nd) { // Get node transformation matrix aiMatrix4x4 m = nd->mTransformation; // OpenGL matrices are column major m.Transpose(); // save model matrix and apply node transformation pushMatrix(); float aux[16]; memcpy(aux,&m,sizeof(float) * 16); MathHelp::multMatrix(modelMatrix, aux); setModelMatrix(); // draw all meshes assigned to this node for (unsigned int n=0; n < nd->mNumMeshes; ++n) { // bind material uniform glBindBufferRange(GL_UNIFORM_BUFFER, materialUniLoc, myMeshes[nd->mMeshes[n]].uniformBlockIndex, 0, sizeof(struct Helper::MyMaterial)); // bind texture glBindTexture(GL_TEXTURE_2D, myMeshes[nd->mMeshes[n]].texIndex); // bind VAO glBindVertexArray(myMeshes[nd->mMeshes[n]].vao); // draw glDrawElements(GL_TRIANGLES,myMeshes[nd->mMeshes[n]].numFaces*3,GL_UNSIGNED_INT,0); } // draw all children for (unsigned int n=0; n < nd->mNumChildren; ++n) { recursive_render(nd->mChildren[n]); } popMatrix(); }
GLUSboolean init() { initPrograms(); g_pCylinderMesh = new Mesh("./model/UnitCylinder.xml"); g_pPlaneMesh = new Mesh("./model/LargePlane.xml"); g_pCubeMesh = new Mesh("./model/UnitCube.xml"); glusWindowSetMouseFunc(mouseButton); glusWindowSetMouseMoveFunc(mouseMotion); glusWindowSetMouseWheelFunc(mouseWheel); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); const float depthZNear = 0.0f; const float depthZFar = 1.0f; glEnable(GL_DEPTH_TEST); glDepthMask(GL_TRUE); glDepthFunc(GL_LEQUAL); glDepthRange(depthZNear, depthZFar); glEnable(GL_DEPTH_CLAMP); glGenBuffers(1, &g_projectionUniformBuffer); glBindBuffer(GL_UNIFORM_BUFFER, g_projectionUniformBuffer); glBufferData(GL_UNIFORM_BUFFER, sizeof(ProjectionBlock), NULL, GL_DYNAMIC_DRAW); glBindBufferRange(GL_UNIFORM_BUFFER, g_projectionBlockIndex, g_projectionUniformBuffer, 0, sizeof(ProjectionBlock)); glBindBuffer(GL_UNIFORM_BUFFER, 0); return GLUS_TRUE; }
void LightManager::initializeUniformLightBloc(ShaderProgram& aProgram, std::string aUniformLightBlocName) { mLightUniformLightBlocName = aUniformLightBlocName; try { aProgram.loadUniformBloc(aUniformLightBlocName); mUniformBlockIndex = aProgram.getUniformBloc(aUniformLightBlocName); mUniformBlockBindingIndex = ShaderProgram::getNextGlobalUniformBlockBindingPointAvailable(); glUniformBlockBinding(aProgram.getProgram(), mUniformBlockIndex, mUniformBlockBindingIndex); glGenBuffers(1, &mUniformBufferIndex); glBindBuffer(GL_UNIFORM_BUFFER, mUniformBufferIndex); //Init the buffer with zero everywhere size_t uniformBufferSize = sizeof(Light)*mMaxLights; char* zeroBuf = new char[uniformBufferSize](); glBufferData(GL_UNIFORM_BUFFER, uniformBufferSize, zeroBuf, GL_DYNAMIC_DRAW); delete[] zeroBuf; glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferRange(GL_UNIFORM_BUFFER, mUniformBlockBindingIndex, mUniformBufferIndex, 0, uniformBufferSize); } catch(ShaderProgramUniformNotLoadedException &e) { std::cerr << e.what() << std::endl; } catch(ShaderProgramUniformNotFoundException &e) { std::cerr << e.what() << std::endl; } }
void Buffer::bindRange(GLenum target, GLuint index, GLintptr offset, GLsizeiptr size) { glBindBufferRange(target, index, m_id, offset, size); CheckGLError(); }
void piglit_init(int argc, char **argv) { GLint vertex_data[1] = { GEOM_OUT_VERTS }; bool pass = true; GLuint vs, gs, prog, array_buf, query_result, xfb_buf, generated_query, written_query, vao; GLint vertex_count_loc; const GLint *readback; int i; vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext); gs = piglit_compile_shader_text(GL_GEOMETRY_SHADER, gstext); prog = glCreateProgram(); glAttachShader(prog, vs); glAttachShader(prog, gs); glTransformFeedbackVaryings(prog, 1, varyings, GL_INTERLEAVED_ATTRIBS); glLinkProgram(prog); if (!piglit_link_check_status(prog)) { glDeleteProgram(prog); piglit_report_result(PIGLIT_FAIL); } glUseProgram(prog); /* Setup inputs */ glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &array_buf); glBindBuffer(GL_ARRAY_BUFFER, array_buf); glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), &vertex_data, GL_STATIC_DRAW); vertex_count_loc = glGetAttribLocation(prog, "vertex_count"); glVertexAttribIPointer(vertex_count_loc, 1, GL_INT, sizeof(GLint), 0); glEnableVertexAttribArray(vertex_count_loc); /* Setup transform feedback buffer */ glGenBuffers(1, &xfb_buf); glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buf); glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, GEOM_OUT_VERTS * sizeof(GLint), NULL, GL_STREAM_READ); glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf, 0, GEOM_OUT_VERTS * sizeof(GLint)); /* Setup queries */ glGenQueries(1, &generated_query); glGenQueries(1, &written_query); glBeginQuery(GL_PRIMITIVES_GENERATED, generated_query); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, written_query); /* Do drawing */ glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, 1); glEndTransformFeedback(); /* Check query results */ glEndQuery(GL_PRIMITIVES_GENERATED); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glGetQueryObjectuiv(generated_query, GL_QUERY_RESULT, &query_result); if (query_result != GEOM_OUT_VERTS) { printf("GL_PRIMITIVES_GENERATED query failed." " Expected %d, got %d.\n", GEOM_OUT_VERTS, query_result); pass = false; } glGetQueryObjectuiv(written_query, GL_QUERY_RESULT, &query_result); if (query_result != GEOM_OUT_VERTS) { printf("GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query failed." " Expected %d, got %d.\n", GEOM_OUT_VERTS, query_result); pass = false; } /* Check transform feedback data */ readback = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY); for (i = 0; i < GEOM_OUT_VERTS; i++) { if (readback[i] != i) { printf("Incorrect data for vertex %d." " Expected %d, got %d.", i, i, readback[i]); pass = false; } } glUnmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER); /* Check for errors */ pass = piglit_check_gl_error(GL_NO_ERROR) && pass; piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
static void test_transform_feedback(int n, int separate) { GLint width, height, ret, i; GLuint texturename = 0, texture_handle, tf; GLfloat vVertices[] = { // front -0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0 }; const char *varyings[] = { "pos", "pos2", "pos3", "pos4", "pos5", "pos6", "pos7", //"posen[0]", //"posen[1]", //"posen[2]", //"posen[8]", //"posen[5]", }; GLuint tf_bufs[ARRAY_SIZE(varyings)] = { 0 }; EGLSurface surface; RD_START("transform-feedback", "n=%d, separate=%d", n, separate); display = get_display(); /* get an appropriate EGL frame buffer configuration */ ECHK(eglChooseConfig(display, config_attribute_list, &config, 1, &num_config)); DEBUG_MSG("num_config: %d", num_config); /* create an EGL rendering context */ ECHK(context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attribute_list)); surface = make_window(display, config, 255, 255); ECHK(eglQuerySurface(display, surface, EGL_WIDTH, &width)); ECHK(eglQuerySurface(display, surface, EGL_HEIGHT, &height)); DEBUG_MSG("Buffer: %dx%d", width, height); /* connect the context to the surface */ ECHK(eglMakeCurrent(display, surface, surface, context)); printf("EGL Version %s\n", eglQueryString(display, EGL_VERSION)); printf("EGL Vendor %s\n", eglQueryString(display, EGL_VENDOR)); printf("EGL Extensions %s\n", eglQueryString(display, EGL_EXTENSIONS)); printf("GL Version %s\n", glGetString(GL_VERSION)); printf("GL extensions: %s\n", glGetString(GL_EXTENSIONS)); program = get_program(vertex_shader_source, fragment_shader_source); if (n > 0) GCHK(glEnable(GL_RASTERIZER_DISCARD)); GCHK(glBindAttribLocation(program, 0, "in_position")); if (n > 0) { GCHK(glTransformFeedbackVaryings(program, n, varyings, separate ? GL_SEPARATE_ATTRIBS : GL_INTERLEAVED_ATTRIBS)); } link_program(program); GCHK(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices)); GCHK(glEnableVertexAttribArray(0)); if (n > 0) { GCHK(glGenBuffers(n, tf_bufs)); for (i = 0; i < (separate ? n : 1); i++) { GCHK(glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, tf_bufs[i])); GCHK(glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024, NULL, GL_STREAM_DRAW)); GCHK(glBindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, i, tf_bufs[i], 32 * i, 1024)); } } //GCHK(glGenTransformFeedbacks(1, &tf)); //GCHK(glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tf)); if (n > 0) GCHK(glBeginTransformFeedback(GL_POINTS)); GCHK(glDrawArrays(GL_POINTS, 0, 4)); if (n > 0) GCHK(glEndTransformFeedback()); //ECHK(eglSwapBuffers(display, surface)); GCHK(glFlush()); sleep(1); ECHK(eglDestroySurface(display, surface)); ECHK(eglTerminate(display)); RD_END(); }
void RendererBase::BindUniformBuffer(UniformBuffer * resource, ShaderProgram * program) { BindShaderProgram(program); UniformBufferPimpl * resource_pimpl = (UniformBufferPimpl *) resource->PRIVATE; if (resource->index == 0) { ShaderProgramPimpl * shader_pimpl = (ShaderProgramPimpl *) program->PRIVATE; //ShaderDomain & shader_domain = program->domains[resource->domain]; //ShaderDomainPimpl * domain_pimpl = (ShaderDomainPimpl *) shader_domain.PRIVATE; if (shader_pimpl->bound_uniform_buffers[0] != resource) { shader_pimpl->bound_uniform_buffers[0] = resource; for (unsigned int i = 0; i < program->uniforms.GetSize(); ++i) { if (program->GetUniformBufferIndex(i)) continue; unsigned char rows = program->GetUniformRows(i); unsigned char columns = program->GetUniformColumns(i); GLuint location = shader_pimpl->uniform_locations[i]; unsigned int count = program->GetUniformArrayLength(i); float * data = (float *) (resource_pimpl->cpu_data + program->GetUniformBufferOffset(i)); switch(rows) { case 1: switch (columns) { case 1: glUniform1fv(location, count, data); break; case 2: glUniform2fv(location, count, data); break; case 3: glUniform3fv(location, count, data); break; case 4: glUniform4fv(location, count, data); break; } break; case 2: switch (columns) { case 2: glUniformMatrix2fv(location, count, false, data); break; case 3: glUniformMatrix2x3fv(location, count, false, data); break; case 4: glUniformMatrix2x4fv(location, count, false, data); break; } break; case 3: switch (columns) { case 2: glUniformMatrix3x2fv(location, count, false, data); break; case 3: glUniformMatrix3fv(location, count, false, data); break; case 4: glUniformMatrix3x4fv(location, count, false, data); break; } break; case 4: switch (columns) { case 2: glUniformMatrix4x2fv(location, count, false, data); break; case 3: glUniformMatrix4x3fv(location, count, false, data); break; case 4: glUniformMatrix4fv(location, count, false, data); break; } break; } } //resource_pimpl->dirty_data = false; } } else if (GLEW_ARB_uniform_buffer_object) { ShaderProgramPimpl * shader_pimpl = (ShaderProgramPimpl *) program->PRIVATE; glBindBufferRange(GL_UNIFORM_BUFFER, shader_pimpl->block_bind_points[resource->index], resource_pimpl->buffer, 0, resource->byte_count); //glBindBufferBase(GL_UNIFORM_BUFFER, domain_pimpl->block_bind_points[resource->index], resource_pimpl->buffer); } }