void EndPatchRenderer::prerenderSetup(int level, std::function<void (const glm::vec4 &)> setDrawColor) { assert(indexBufferGenerated); assert(ibo != std::numeric_limits<GLuint>::max()); assert(vboRef == controlMesh->vbo); setDrawColor(glm::vec4(0.f, 1.f, 1.f, 1.f)); // Debug glUseProgram(program); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, controlMesh->vbo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, ovbo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, nibo); glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 9, uvBuffer); if (controlMesh->hasTexture) { glBindTextureUnit(4, controlMesh->diffuseMap); } if (controlMesh->hasDisplacementMap) { glBindTextureUnit(5, controlMesh->displacementMap); } glPatchParameteri(GL_PATCH_VERTICES, 3); }
void GSceneManager::drawScene(GSceneNode* sn_p_drawNode, SceneTyp sct_typ, GLuint& glui_shaderProgram) { // Vertexliste zeichnen // Für alle Knoten zeichnen bindUniformModelMatrix(sn_p_drawNode, glui_shaderProgram); for (GLuint glui_meshIter = 0; glui_meshIter < (sn_p_drawNode->returnNumOfMesh()); glui_meshIter++) { // Texture anbinden (GL_TEXTURE_0) und an Shader übergeben if (sct_typ == INTERACT || sct_typ == DYNAMIC) bindUniformTextureMaterial (sn_p_drawNode->returnMesh(glui_meshIter)->returnRMaterial(), glui_shaderProgram); // EZR: Umgebungstexturen anbinden else if (sct_typ == WORLD || sct_typ == SKYBOX) bindUniformEnvironmentTextureMaterial(sct_typ, glui_shaderProgram); glBindVertexArray( sn_p_drawNode->returnMeshVA(glui_meshIter) ); if (sct_typ == INTERACT) { bindUniformCameraPosition(glui_shaderProgram); glPatchParameteri(GL_PATCH_VERTICES, 3); glDrawElements(GL_PATCHES, sn_p_drawNode->returnNumOfMeshFaces(glui_meshIter)*3, GL_UNSIGNED_INT, 0); } else glDrawElements(GL_TRIANGLES, sn_p_drawNode->returnNumOfMeshFaces(glui_meshIter)*3 , GL_UNSIGNED_INT, 0); } //Rekursiv alle Kinderknoten aufrufen und zeichnen for (unsigned int ui_numNode = 0; ui_numNode < sn_p_drawNode->returnChildrenVector().size(); ui_numNode++) { drawScene(sn_p_drawNode->returnChildrenVector()[ui_numNode], sct_typ, glui_shaderProgram); } }
void TesselationApp::draw() { int maxTess = 30; float tessStartDistance = 8; float scale = maxTess - (camera->position.length() - tessStartDistance); std::stringstream tess; tess << "Tess " << int(scale); // fontOverlay->updateText("tess",tess.str()); std::stringstream dist; dist << "Dist " << camera->position.length(); // fontOverlay->updateText("dist",dist.str()); if (scale > 1){ shader->use(); shader->setUniform("TessLevelInner",scale); shader->setUniform("TessLevelOuter",scale); } OpenGL::Instance().clear(); glEnable(GL_DEPTH_TEST); // glEnable(GL_CULL_FACE); groundNode->setView(camera); glError; #ifdef USE_OPENGL4 glPatchParameteri(GL_PATCH_VERTICES, 3); groundNode->draw(); #endif glError; }
bool Init() { Vector3f Pos(0.0f, 1.5f, -6.5f); Vector3f Target(0.0f, -0.2f, 1.0f); Vector3f Up(0.0, 1.0f, 0.0f); m_pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT, Pos, Target, Up); if (!m_lightingEffect.Init()) { printf("Error initializing the lighting technique\n"); return false; } GLint MaxPatchVertices = 0; glGetIntegerv(GL_MAX_PATCH_VERTICES, &MaxPatchVertices); printf("Max supported patch vertices %d\n", MaxPatchVertices); glPatchParameteri(GL_PATCH_VERTICES, 3); m_lightingEffect.Enable(); m_lightingEffect.SetColorTextureUnit(COLOR_TEXTURE_UNIT_INDEX); m_lightingEffect.SetDirectionalLight(m_directionalLight); m_pMesh = new Mesh(); return m_pMesh->LoadMesh("../Content/monkey.obj"); }
void display() { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]); glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size)[0]); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); glBindProgramPipeline(PipelineName); glBindVertexArray(VertexArrayName); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1); glf::checkError("display"); glf::swapBuffers(); }
static void render_ob(t_env const *e, t_ob *ob) { t_model const *const mo = MOOFOB(e, ob); t_mesh const *const me = MEOFMO(e, mo); t_program const *const p = POFME(e, me); if (mo->update_uniforms != NULL) NORM_AT_42_IS_WTF(e, ob, mo); if (mo->texture != sp_no_texture) sp_activate_texture(p, sp_image1_texslot, TOFMO(e, mo), "ourTexture"); if (p->gltexi[sp_sbox_texslot] >= 0) sp_activate_texture(p, sp_sbox_texslot, &e->sbox_texture, "depthMap"); if (me->program == sp_landrender_program) { sp_activate_texture(p, sp_image1_texslot, &e->land_tex1, "ymap"); sp_activate_texture(p, sp_image2_texslot, &e->land_tex2, "colmap"); sp_activate_texture(p, sp_image3_texslot, &e->land_tex3, "normap"); } glBindVertexArray(me->handles[0]); if (p->tcshader != sp_no_tcshader) { glPatchParameteri(GL_PATCH_VERTICES, 3); glDrawElements(GL_PATCHES, me->faces3, GL_UNSIGNED_INT, 0); } else glDrawElements(GL_TRIANGLES, me->faces3, GL_UNSIGNED_INT, 0); glBindVertexArray(0); return ; }
void VSTerrainLODSingleScaledLib::render() { glPatchParameteri( GL_PATCH_VERTICES, 1 ); mVSML->pushMatrix(VSMathLib::MODEL); mVSML->multMatrix(VSMathLib::MODEL, mMesh.transform); mVSML->matricesToGL(); VSShaderLib::setBlock(mMaterialBlockName, &(mMesh.mat)); // bind textures for (int t = 0; t < VSShaderLib::MAX_TEXTURES; t++) { if (mMesh.texUnits[t] != 0) { glActiveTexture(GL_TEXTURE0 + t); glBindTexture(GL_TEXTURE_2D, mMesh.texUnits[t]); } } // bind VAO glBindVertexArray(mMesh.vao); glDrawArrays(mMesh.type,0,mMesh.numIndices); for (int t = 0; t < VSShaderLib::MAX_TEXTURES; t++) { if (mMesh.texUnits[t] != 0) { glActiveTexture(GL_TEXTURE0 + t); glBindTexture(GL_TEXTURE_2D, 0); } } glBindVertexArray(0); mVSML->popMatrix(VSMathLib::MODEL); }
void PartialPatchSharpRenderer::prerenderSetup(int level, std::function<void(const glm::vec4 &)> setDrawColor) { setDrawColor(glm::vec4(1.f, 0.f, 0.f, 1.f)); // Debug glPolygonMode(GL_FRONT_AND_BACK, g_shadingMode); glPatchParameteri(GL_PATCH_VERTICES, 16); }
void display() { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Compute the MVP (Model View Projection matrix) glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; // Set the display viewport glViewport(0, 0, Window.Size.x, Window.Size.y); // Clear color buffer with black glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); // Bind program glUseProgram(ProgramName); // Set the value of MVP uniform. glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); // Bind vertex array & draw glBindVertexArray(VertexArrayName); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1); glf::checkError("display"); glf::swapBuffers(); }
void SCE_RUseProgram (SCE_RProgram *prog) { if (prog) { glUseProgram (prog->id); /* useless 'if' statements in a full GL3 renderer */ if (prog->use_vmap) SCE_RUseVertexAttributesMap (prog->map); else SCE_RDisableVertexAttributesMap (); if (prog->use_mmap) { sce_rmatindex = prog->mat_map; SCE_RMapMatrices (prog->funs); } else { /* useless in a full GL3 renderer */ SCE_RMapMatrices (NULL); } if (prog->use_tess) { glPatchParameteri (GL_PATCH_VERTICES, prog->patch_vertices); /* tell the renderer to use GL_PATCHES as primitive type */ SCE_RUsePatches (); } else SCE_RUsePrimitives (); } else { SCE_RUsePrimitives (); glUseProgram (0); /* useless calls in a full GL3 renderer */ SCE_RDisableVertexAttributesMap (); SCE_RMapMatrices (NULL); } }
void SoftBody::RenderPatches() { glPatchParameteri(GL_PATCH_VERTICES, 3); glBindVertexArray(vao); glDrawElements(GL_PATCHES, indices.size(), GL_UNSIGNED_INT, (void *)0); glBindVertexArray(0); }
void Mesh::render() { int vertexAttributeCount = m_vertexAttributes.size(); for (int i = 0; i < vertexAttributeCount; i++) { m_vertexAttributes[i].applyState(); } // Index buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBuffer); if (m_glPrimitiveType == GL_PATCHES) { glPatchParameteri(GL_PATCH_VERTICES, m_patchVertCount); } if (m_instanceCount > 1) { glDrawElementsInstanced(m_glPrimitiveType, m_indexCount, GL_UNSIGNED_INT, (void*)0, // element array buffer offset m_instanceCount ); } else { glDrawElements(m_glPrimitiveType, m_indexCount, GL_UNSIGNED_INT, (void*)0 // element array buffer offset ); } for (int i = 0; i < vertexAttributeCount; i++) { m_vertexAttributes[i].unapplyState(); } }
void PezRender(GLuint fbo) { glUniform1f(Uniforms.TessLevel, TessLevel); glUniform1f(Uniforms.TessLevelOuter, TessLevelOuter); glUniform1f(Uniforms.NormalModel, NormalModel); glUniform1f(Uniforms.Tesselation, Tesselation); glUniform1f(Uniforms.Wireframe, Wireframe); glUniform1f(Uniforms.Tagg, Tagg); glUniform1f(Uniforms.ColNorm, ColNorm); glUniform1f(Uniforms.DCol, DCol); Vector4 lightPosition = V4MakeFromElems(0.25, 0.25, 1, 0); glUniform3fv(Uniforms.LightPosition, 1, &lightPosition.x); glUniformMatrix4fv(Uniforms.Projection, 1, 0, &ProjectionMatrix.col0.x); glUniformMatrix4fv(Uniforms.Modelview, 1, 0, &ModelviewMatrix.col0.x); Matrix3 nm = M3Transpose(NormalMatrix); float packed[9] = { nm.col0.x, nm.col1.x, nm.col2.x, nm.col0.y, nm.col1.y, nm.col2.y, nm.col0.z, nm.col1.z, nm.col2.z }; glUniformMatrix3fv(Uniforms.NormalMatrix, 1, 0, &packed[0]); // Render the scene: glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPatchParameteri(GL_PATCH_VERTICES, 3); glUniform3f(Uniforms.AmbientMaterial, 0.04f, 0.04f, 0.04f); glUniform3f(Uniforms.DiffuseMaterial, 0, 0.75, 0.75); glDrawElements(GL_PATCHES, IndexCount, GL_UNSIGNED_INT, 0); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]); glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize)[0]); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); glBindProgramPipeline(PipelineName); glBindVertexArray(VertexArrayName); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); assert(!validate(ProgramName[program::VERT])); glDrawArraysInstancedBaseInstance(GL_PATCHES, 0, VertexCount, 1, 0); return true; }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x * 0.5f / WindowSize.y, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); glBindVertexArray(VertexArrayName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBufferName); glViewport(0, 0, static_cast<GLsizei>(WindowSize.x * 0.5f), static_cast<GLsizei>(WindowSize.y)); glUseProgram(ProgramName[0]); glUniformMatrix4fv(UniformMVP[0], 1, GL_FALSE, &MVP[0][0]); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1); glViewport(static_cast<GLint>(WindowSize.x * 0.5f), 0, static_cast<GLsizei>(WindowSize.x * 0.5f), static_cast<GLsizei>(WindowSize.y)); glUseProgram(ProgramName[1]); glUniformMatrix4fv(UniformMVP[1], 1, GL_FALSE, &MVP[0][0]); glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0); return true; }
void CurveCurvature::SetScene() { Example::zNear = 0.1f; Example::zFar = 20.0; Example::camStep = 0.1f; this->kDisplacement = 1.0; //Velocidad de movimiento Example::camPos = glm::vec3(1.5, 1.5, 2); Example::camCenter = glm::vec3(1.5, 1.5, 0); Example::camUp = glm::vec3(0, 1, 0); Example::camEyeTarget = glm::normalize(Example::camCenter - Example::camPos); this->RecalcMatrices(); this->tessellate = true; this->maxTess = 32.0; this->tessDefault = 32.0; this->hasMouseExtended = false; this->selectedPoint = 0; this->numLines = 2.0; this->curvFactor = 10.0; glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glFrontFace(GL_CW); glPatchParameteri(GL_PATCH_VERTICES, this->VERTICES_PER_PATCH); }
bool render() { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glm::vec2 WindowSize(this->getWindowSize()); { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glm::mat4* Pointer = (glm::mat4*)glMapBufferRange( GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f); *Pointer = Projection * this->view() * glm::mat4(1.0f); // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); } glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize)[0]); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); glBindProgramPipeline(PipelineName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindVertexArray(VertexArrayName); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); assert(!validate(ProgramName[program::VERT])); glDrawArraysInstancedBaseInstance(GL_PATCHES, 0, VertexCount, 1, 0); return true; }
void display() { glm::mat4 Projection = glm::perspective(45.0f, float(Window.Size.x / 2) / float(Window.Size.y), 0.1f, 100.0f); glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y)); glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; glViewport(0, 0, Window.Size.x, Window.Size.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); glBindVertexArray(VertexArrayName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ElementBufferName); glViewport(0, 0, Window.Size.x / 2, Window.Size.y); glUseProgram(ProgramName[0]); glUniformMatrix4fv(UniformMVP[0], 1, GL_FALSE, &MVP[0][0]); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1); glViewport(Window.Size.x / 2, 0, Window.Size.x / 2, Window.Size.y); glUseProgram(ProgramName[1]); glUniformMatrix4fv(UniformMVP[1], 1, GL_FALSE, &MVP[0][0]); glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0); glf::checkError("display"); glf::swapBuffers(); }
Renderer::Renderer(const Desc & desc) : RendererHelper<1>("PerlinNoiseOceanRenderer", "PerlinNoiseOceanWireFrameRenderer", Renderer::ERenderPass::Deferred_Pass) , mHeightMapCS(nullptr) , mCubeMapTexture(Engine::GetInstance()->GetTextureManager()->LoadTextureCubeMap(desc.mSkyboxCubeMapTextureFilename)) , mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->LoadTexture2D("medias/textures/OceanColor256.tif", GL_REPEAT, GL_REPEAT)) //, mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->GetDefaultTexture2D()) , mHeightMapTextureSize(desc.mHeightMapTextureSize) , mMapSize(desc.mMapWidth, desc.mMapDepth) , mPatchCount(desc.mMapWidth / 64, desc.mMapDepth / 64) , mMapCount(0) , mDrawNormalShader("TerrainDrawNormals") { PRINT_BEGIN_SECTION; PRINT_MESSAGE("Initialize PerlinNoiseOceanRenderer....."); const glm::vec3 vertices[] = { glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(1.0f, 0.0f, 1.0f) }; //setup vao and vbo stuff CreateBuffers(); glBindVertexArray(mVaoID); glBindBuffer(GL_ARRAY_BUFFER, mVboIDs[VertexArrayBufferIndex]); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GL_CHECK_ERRORS; glEnableVertexAttribArray(Shader::POSITION_ATTRIBUTE); glVertexAttribPointer(Shader::POSITION_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0); GL_CHECK_ERRORS; glPatchParameteri(GL_PATCH_VERTICES, 4); glBindVertexArray(0); GL_CHECK_ERRORS; mMapCount = (GLint)desc.mMaps.size(); PerMapData * modelMatrixBuffer = new PerMapData[mMapCount]; for (int i = 0; i < mMapCount; ++i) { modelMatrixBuffer[i].mModelDQ = desc.mMaps[i].mModelDQ; } mModelMatrixBuffer.CreateResource(GL_STATIC_DRAW, GL_RGBA32F, (mMapCount * sizeof(PerMapData)), modelMatrixBuffer); LoadShaders(desc); mIsInitialized = true; PRINT_MESSAGE(".....PerlinNoiseOceanRenderer initialized!"); PRINT_END_SECTION; }
void objMesh::drawTesselation() { glBindVertexArray(vao); glBindTexture(GL_TEXTURE_2D, textureIndex); glPatchParameteri(GL_PATCH_VERTICES, 3); glDrawArrays(GL_PATCHES, 0, nVertices); glBindVertexArray(0); }
void Demo05::Initialize() { shaderManager.CreateShaderProgram("Shader"); shaderManager.AttachShader("ShaderVertex" , VERTEX); shaderManager.AttachShader("ShaderTessCont", TESS_CNTRL); shaderManager.AttachShader("ShaderTessEval", TESS_EVAL); shaderManager.AttachShader("ShaderGeometry", GEOMETRY); shaderManager.AttachShader("ShaderFragment", FRAGMENT); shaderManager.LoadShaderSource("ShaderVertex" , "data/shaders/demo05/tessellation.vert.glsl"); shaderManager.LoadShaderSource("ShaderTessCont", "data/shaders/demo05/tessellation.cont.glsl"); shaderManager.LoadShaderSource("ShaderTessEval", "data/shaders/demo05/tessellation.eval.glsl"); shaderManager.LoadShaderSource("ShaderGeometry", "data/shaders/demo05/tessellation.geom.glsl"); shaderManager.LoadShaderSource("ShaderFragment", "data/shaders/demo05/tessellation.frag.glsl"); shaderManager.CompileShader("ShaderVertex"); shaderManager.CompileShader("ShaderTessCont"); shaderManager.CompileShader("ShaderTessEval"); shaderManager.CompileShader("ShaderGeometry"); shaderManager.CompileShader("ShaderFragment"); shaderManager.AttachShaderToProgram("Shader", "ShaderVertex"); shaderManager.AttachShaderToProgram("Shader", "ShaderTessCont"); shaderManager.AttachShaderToProgram("Shader", "ShaderTessEval"); shaderManager.AttachShaderToProgram("Shader", "ShaderGeometry"); shaderManager.AttachShaderToProgram("Shader", "ShaderFragment"); shaderManager.BindAttribute("Shader", 0, "a_vertex"); shaderManager.LinkProgramObject("Shader"); shaderManager["Shader"]->Activate(); std::auto_ptr<ObjModel> model(new ObjModel); model->Load("data/model/obj/bunny.obj"); triangleCount = model->faces.size(); GLsizei vertexCount = model->vertices.size(); glGenBuffers(2, &vboID[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboID[0]); // elements glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint)*3*triangleCount, &*model->faces.begin(), GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, vboID[1]); // vertices glBufferData(GL_ARRAY_BUFFER, sizeof(GLuint)*3*vertexCount, &*model->vertices.begin(), GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glGenVertexArrays(1, &vaoID[0]); glBindVertexArray(vaoID[0]); glBindBuffer(GL_ARRAY_BUFFER, vboID[1]); shaderManager["Shader"]->VertexAttribPointer("a_vertex", 3, GL_FLOAT, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); shaderManager["Shader"]->EnableAttribArray("a_vertex"); glBindVertexArray(0); glClearDepth(1.0f); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); // We work with 4 points per patch. glPatchParameteri(GL_PATCH_VERTICES, 3); }
void Reyes::RendererGLWire::prepare() { glDisable(GL_BLEND); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glPatchParameteri(GL_PATCH_VERTICES, 4); }
void Patch::draw(const Program &program) { bindTessLevel(program); // TODO should be called once glPatchParameteri(GL_PATCH_VERTICES, vertexCountPerPatch); //this->drawingMode = GL_PATCHES; Mesh::draw(program); }
void TerrainRenderer::paint() { dp::sg::renderer::rix::gl::SceneRendererSharedPtr renderer = getSceneRenderer().staticCast<dp::sg::renderer::rix::gl::SceneRenderer>(); if ( !m_renderEngine.empty() && renderer->getRenderEngine() != m_renderEngine ) { std::cout << "Setting renderengine: " << m_renderEngine << std::endl; renderer->setRenderEngine( m_renderEngine ); } renderer->setShaderManager( m_shaderManager); glPatchParameteri( GL_PATCH_VERTICES, 1 ); // TODO temporary, terrain patch has only 1 'virtual' vertex per patch //glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); dp::util::FrameProfiler::instance().beginFrame(); if ( m_benchmarkFrames != ~0 || m_duration != 0.0 ) { if ( m_renderedFrames == 1 ) { m_benchmarkTimer.start(); m_benchmarkProgressTimer.start(); } SceneRendererWidget::paint(); if ( m_benchmarkProgressTimer.getTime() > 1.0 ) { m_benchmarkProgressTimer.restart(); std::ostringstream os; os << "Benchmark Progress: "; if ( m_benchmarkFrames != ~0 ) { os << m_renderedFrames << "/" << m_benchmarkFrames; } else { os << std::setprecision(2) << m_benchmarkTimer.getTime() << "/" << m_duration; } setWindowTitle( os.str() ); } if ( (m_benchmarkFrames != ~0 && m_renderedFrames == m_benchmarkFrames) || (m_duration > 0.0 && m_benchmarkTimer.getTime() > m_duration) ) { m_benchmarkTimer.stop(); m_exitCode = int(double(m_renderedFrames) / m_benchmarkTimer.getTime()); glutLeaveMainLoop(); } // at the end since the first frame does not count ++m_renderedFrames; } else { SceneRendererWidget::paint(); } dp::util::FrameProfiler::instance().endFrame(); }
void xprGpuDrawPatch(size_t offset, size_t count, size_t vertexPerPatch, size_t flags) { #if !defined(XPR_GLES_2) GLenum mode = GL_PATCHES; if(nullptr != glPatchParameteri) { glPatchParameteri(GL_PATCH_VERTICES, vertexPerPatch); glDrawArrays(mode, offset, count); } #endif }
/** **************************************************************************************************** @brief Draws object by calling it's display list. Before this object is transformed and rotated to it's current position. Then attached material is rendered(TMaterial::RenderMaterial()) There are specific types of settings, when object is not rendered (e.g. when rendering into shadow map is active and object don't cast shadows) @param tessellate draw object with HW tessellation enabled? ****************************************************************************************************/ void TObject::Draw(bool tessellate) { //don't draw object with draw_object flag set to false if(!m_draw_object) return; #ifdef VERBOSE cout<<"Drawing "<<m_name << endl; #endif if(m_type != INSTANCE) glBindVertexArray(m_vbo.vao); //set patch parameter int patch = m_drawmode; if(tessellate) { if(m_drawmode == GL_TRIANGLE_STRIP) glPatchParameteri(GL_PATCH_VERTICES, 4); else glPatchParameteri(GL_PATCH_VERTICES, 3); patch = GL_PATCHES; } //different drawing mode: simple vertex array or array with element indices if(m_element_indices) { //it's possible to use geometry instancing (if there is more than 1 object instance) if(m_instances > 1) glDrawElementsInstanced(patch, m_vbo.indices, GL_UNSIGNED_INT , 0, m_instances); else glDrawElements(patch, m_vbo.indices, GL_UNSIGNED_INT , 0); } else { if(m_instances > 1) glDrawArraysInstanced(patch, 0, m_vbo.indices * 3, m_instances); else glDrawArrays(patch, 0, m_vbo.indices * 3); } #ifdef VERBOSE cout<<"...done\n"; #endif }
void PipelineImpl::setTessellationState(GlState& state) const { if(!m_tessellation || state.m_stateHashes.m_tessellation == m_hashes.m_tessellation) { return; } state.m_stateHashes.m_tessellation = m_hashes.m_tessellation; glPatchParameteri(GL_PATCH_VERTICES, m_in.m_tessellation.m_patchControlPointCount); }
void xprGpuDrawPatchIndexed(size_t offset, size_t count, size_t minIdx, size_t maxIdx, size_t vertexPerPatch, size_t flags) { #if !defined(XPR_GLES_2) GLenum mode = GL_PATCHES; GLenum indexType = xprGL_INDEX_TYPE[flags & 0x000F]; if(nullptr != glPatchParameteri) { glPatchParameteri(GL_PATCH_VERTICES, vertexPerPatch); glDrawRangeElements(mode, minIdx, maxIdx, count, indexType, (void*)offset); } #endif }
void drawExplosion(double time){ GLuint loc; glUseProgram(explosion_shader); loc = glGetUniformLocation(explosion_shader, "time"); glUniform1f(loc, time); glBindVertexArray(explosion_vao); glPatchParameteri(GL_PATCH_VERTICES, 1); glDrawArrays(GL_POINTS, 0, MAX_EXPLOSION / 3); }
void Terrain::render(Shader *shader) { computeModelMatrix(); glUniformMatrix4fv(shader->loc_model_matrix, 1, false, glm::value_ptr(Model)); glUniform1ui(shader->loc_displacement_factor, displacement_factor); glBindVertexArray(VAO); glPatchParameteri(GL_PATCH_VERTICES, 3); glDrawElements(GL_PATCHES, n_indices, GL_UNSIGNED_INT, NULL); glBindVertexArray(0); }