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(); }
void VertexBuffer::DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) { ProgramObject *p = rc->GetCurProgram(); if (p) p->updateMatrices(); Bind(); glDrawArraysInstanced(mode, first, count, instanceCount); }
void display(void) { glClear(GL_COLOR_BUFFER_BIT); glBindVertexArray(vao); glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 7); glFlush(); }
void CGLGraphics::DrawInstanced(PrimitiveType primitive, size_t instanceCount, S_CBuffer elementBuffer) { if (m_currentBuffer == nullptr) { fprintf(stderr, "Tried to draw instanced with nullptr buffer!! Did you forget to call SetDrawBuffer?\n"); return; } S_CGLProgram gl_prog = std::static_pointer_cast<CGLProgram>(m_drawProgram); glUseProgram(gl_prog->GetOpenGLHandle()); GLenum gl_primitive = CGLGraphics::GetOpenGLPrimitiveTypeEnum(primitive); if (elementBuffer != nullptr) { S_CGLBuffer gl_elementBuffer = std::static_pointer_cast<CGLBuffer>(elementBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gl_elementBuffer->GetOpenGLHandle()); glDrawElementsInstanced( gl_primitive, (GLsizei)instanceCount, GL_UNSIGNED_SHORT, NULL, (GLsizei)gl_elementBuffer->GetElementCount() ); } else { glDrawArraysInstanced( gl_primitive, 0, (GLsizei)m_currentBuffer->GetElementCount(), (GLsizei)instanceCount ); } }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 1000.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; glViewport(0, 0, WindowSize.x, WindowSize.y); glScissor(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glUniform1i(UniformDiffuse, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); glBindVertexArray(VertexArrayName); for(std::size_t Index = 0; Index < viewport::MAX; ++Index) { glScissor(Viewport[Index].x, Viewport[Index].y, Viewport[Index].z, Viewport[Index].w); glBindSampler(0, SamplerName[Index]); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return true; }
void display() { 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; glProgramUniform4fv(ProgramName, UniformDiffuse, 1, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glProgramUniformMatrix4fv(ProgramName, UniformMVP, 1, GL_FALSE, &MVP[0][0]); glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y)); float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); glUseProgram(ProgramName); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, 6, 1); glf::swapBuffers(); glf::checkError("display"); }
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; glViewport(0, 0, Window.Size.x, Window.Size.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); glUseProgram(ProgramName); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindVertexArray(VertexArrayName); glPatchParameteri(GL_PATCH_VERTICES, VertexCount); glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1); glf::checkError("display"); glf::swapBuffers(); }
/* GL_POINTS, GL_LINE_STRIP, GL_LINE_LOOP, GL_LINES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN, GL_TRIANGLES GL_LINES_ADJACENCY, GL_LINE_STRIP_ADJACENCY, GL_TRIANGLES_ADJACENCY, GL_TRIANGLE_STRIP_ADJACENCY GL_PATCHES */ inline void drawArraysInstanced( DrawArraysInstancedMode mode, Integer first, GLsizei count, GLsizei primcount) { glDrawArraysInstanced(GLenum(mode),first,count,primcount); }
// draw objects with geometry shader defined by points void draw_objects(const Shader& shad, const GLuint option) { // number of objects (quads) constexpr GLuint n {100}; shad.use(); GLuint vao{}, vbo{}; if (option == 0) { gen_objects(vao, vbo, quad_vertices(), 5, 2); const auto offset_arr = offsets_array(n); const auto idx = shad.id(); for (GLuint i {0}; i < n; ++i) { const GLint loc = glGetUniformLocation(idx, std::string{"offsets_arr[" + std::to_string(i) + "]"}. c_str()); glUniform2f(loc, offset_arr[i].x, offset_arr[i].y); } } else { GLuint inst_vbo {gen_instance_buf(offsets_array(n))}; gen_objects_base(vao, vbo, quad_vertices(), 5, 2); set_instance_data(inst_vbo); } glBindVertexArray(vao); glDrawArraysInstanced(GL_TRIANGLES, 0, 6, n); glBindVertexArray(0); }
void GameOfLifeWorldRenderer::render(const GameOfLifeWorld& world) const { quads.clear(); const Grid<Cell>* grid = world.currentGrid.get(); int rowCount = world.rowCount; int columnCount = world.columnCount; for (int r = 0; r < rowCount; ++ r) { GLfloat y = 0.95f - GLfloat(1.90 * r) / rowCount; for (int c = 0; c < columnCount; ++c) { GLfloat x = 0.95f - GLfloat(1.90 * c) / columnCount; if (grid->at(r, c)) { quads.push_back({{x, y}, {0.0f, 1.0f, 0.0f}}); } else { quads.push_back({{x, y}, {0.5f, 0.0f, 0.0f}}); } } } program.use(); quadVertexArrayObject.bind(); instanceVertexBufferObject.setData(quads, GL_DYNAMIC_DRAW); glDrawArraysInstanced(GL_TRIANGLES, 0, 6, quads.size()); quadVertexArrayObject.unbind(); }
bool render() { glm::uvec2 WindowSize = this->getWindowSize(); { // Compute the MVP (Model View Projection matrix) float Aspect = (WindowSize.x * 0.33f) / (WindowSize.y * 0.50f); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, Aspect, 0.1f, 100.0f); glm::mat4 MVP = Projection * this->test::view() * glm::mat4(1.0f); *UniformPointer = MVP; } glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]); glBindProgramPipeline(PipelineName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); for(std::size_t Index = 0; Index < viewport::MAX; ++Index) { glViewportIndexedf(0, Viewport[Index].Viewport.x, Viewport[Index].Viewport.y, Viewport[Index].Viewport.z, Viewport[Index].Viewport.w); glBindVertexArray(VertexArrayName[Viewport[Index].VertexFormat]); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); } return true; }
void renderFBO(GLuint Framebuffer) { glm::mat4 Perspective = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f); glm::mat4 ViewFlip = glm::scale(glm::mat4(1.0f), glm::vec3(1.0f,-1.0f, 1.0f)); glm::mat4 ViewTranslate = glm::translate(ViewFlip, glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y * 2.0)); glm::mat4 View = glm::rotate(ViewTranslate,-15.f, glm::vec3(0.f, 0.f, 1.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Perspective * View * Model; glUseProgram(ProgramName[program::RENDER]); glUniform1i(UniformDiffuse[program::RENDER], 0); glUniformMatrix4fv(UniformMVP[program::RENDER], 1, GL_FALSE, &MVP[0][0]); glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y); glBindFramebuffer(GL_FRAMEBUFFER, Framebuffer); glClearBufferuiv(GL_COLOR, 0, &glm::uvec4(0, 128, 255, 255)[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glf::checkError("renderFBO"); }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 View = this->view(); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; glm::mat4 MV = View * Model; float Depth(1.0f); glViewport(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); glClearBufferfv(GL_DEPTH, 0, &Depth); glDisable(GL_SCISSOR_TEST); glUseProgram(ProgramName); glUniformMatrix4fv(UniformMV, 1, GL_FALSE, &MV[0][0]); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_POINTS, 0, VertexCount, 1); return true; }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); //glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 Projection = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * glm::mat4(1.0f) * Model; glViewport(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniform1i(UniformDiffuse, 0); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_RECTANGLE, TextureRectName); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); return true; }
void renderScene ( glm::vec4 const & ClearColor, glm::mat4 const & MVP, GLuint Texture2DName ) { GLint const Border = 16; glEnablei(GL_SCISSOR_TEST, 0); glScissor(Border, Border, Window.Size.x - Border * 2, Window.Size.y - Border * 2); glClearBufferfv(GL_COLOR, 0, &ClearColor[0]); // Bind the program for use glUseProgram(ProgramName); glUniform1i(UniformDiffuse, 0); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); glBindSampler(0, SamplerName); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glDisablei(GL_SCISSOR_TEST, 0); glf::checkError("renderScene"); }
void WaterBallDrawer::drawParticlesWithAlpha() { if(!drops.size()) { return; } GLenum drawbufs[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 } ; glBindFramebuffer(GL_FRAMEBUFFER, fbo); glDrawBuffers(2, drawbufs); glClear(GL_COLOR_BUFFER_BIT); glViewport(0, 0, win_w, win_h); glBindVertexArray(basic_vao); glUseProgram(basic_prog.id); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, normals_tex); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, alpha_tex); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //glBlendFunc(GL_ONE, GL_ONE); glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, drops.size()); glBindFramebuffer(GL_FRAMEBUFFER, 0); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); { float Aspect = (WindowSize.x * 0.33f) / (WindowSize.y * 0.50f); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, Aspect, 0.1f, 100.0f); glm::mat4 MVP = Projection * this->view() * glm::mat4(1.0f); *UniformPointer = MVP; } glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glBindProgramPipeline(PipelineName); glBindBuffersBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, 1, &BufferName[buffer::TRANSFORM]); glBindTextures(semantic::sampler::DIFFUSE, 1, &TextureName); glBindVertexArray(VertexArrayName); glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::VERTEX], 0, GLsizei(sizeof(vertex))); for(std::size_t Index = 0; Index < viewport::MAX; ++Index) { glViewportIndexedf(0, Viewport[Index].x, Viewport[Index].y, Viewport[Index].z, Viewport[Index].w); glBindSamplers(0, 1, &SamplerName[Index]); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); } 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 display() { // 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; glViewport(0, 0, Window.Size.x, Window.Size.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glUniform1i(UniformDiffuse, 0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D_ARRAY, Texture2DArrayName); glBindSampler(0, SamplerName); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 2); glf::checkError("display"); glf::swapBuffers(); }
void histogram_impl::render(const int pWindowId, const int pX, const int pY, const int pVPW, const int pVPH, const glm::mat4& pView, const glm::mat4& pOrient) { CheckGL("Begin histogram_impl::render"); glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); mProgram.bind(); glUniform1f(mYMaxIndex, mRange[3]); glUniform1f(mNBinsIndex, (GLfloat)mNBins); glUniformMatrix4fv(mMatIndex, 1, GL_FALSE, glm::value_ptr(pView)); glUniform1i(mPVCIndex, mIsPVCOn); glUniform1i(mPVAIndex, mIsPVAOn); glUniform4fv(mBColorIndex, 1, mColor); /* render a rectangle for each bin. Same * rectangle is scaled and translated accordingly * for each bin. OpenGL instanced rendering is used to do it.*/ histogram_impl::bindResources(pWindowId); glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, mNBins); histogram_impl::unbindResources(); mProgram.unbind(); glDisable(GL_BLEND); glDepthMask(GL_TRUE); CheckGL("End histogram_impl::render"); }
void ParticleSystem::render(const glm::mat4 & mv, const glm::mat4 & proj) { glEnable(GL_DEPTH_TEST); /* render particle system */ glBindVertexArray(m_particle_geom.vao); GLuint shader_id = 0; if (m_use_uniform_color) { m_shader_uniform_color.use(); shader_id = m_shader_uniform_color.getID(); } else { m_shader_particle_colors.use(); shader_id = m_shader_particle_colors.getID(); glBindBuffer(GL_ARRAY_BUFFER, m_particle_col_buf.getGLID()); glEnableVertexAttribArray(5); glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, sizeof(cl_float4), (void *) (0)); glVertexAttribDivisor(5, 1); } glUniformMatrix4fv(glGetUniformLocation(shader_id, "proj"), 1, GL_FALSE, glm::value_ptr(proj)); glUniformMatrix4fv(glGetUniformLocation(shader_id, "mv"), 1, GL_FALSE, glm::value_ptr(mv)); /* calculate the normal matrix (assume only rotations, i.e only rthogonal matrices) */ glm::mat3 mv_normal = glm::mat3(mv); // otherwise add glm::transpose(glm::inverse(mv)); glUniformMatrix3fv(glGetUniformLocation(shader_id, "mv_normal"), 1, GL_FALSE, glm::value_ptr(mv_normal)); glBindBuffer(GL_ARRAY_BUFFER, m_particle_pos_buf.getGLID()); glEnableVertexAttribArray(4); glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(cl_float4), (void *) (0)); glVertexAttribDivisor(4, 1); glDrawArraysInstanced(m_particle_geom.mode, 0, m_particle_geom.count, m_num_particles); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); /* render bounding volume */ if (m_draw_bounding_volume) { shader_id = m_shader_bounding_volume.getID(); glUseProgram(shader_id); glUniformMatrix4fv(glGetUniformLocation(shader_id, "proj"), 1, GL_FALSE, glm::value_ptr(proj)); glUniformMatrix4fv(glGetUniformLocation(shader_id, "mv"), 1, GL_FALSE, glm::value_ptr(mv)); glDrawArrays(GL_LINES, 0, 24); } glUseProgram(0); return; }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::vec3 MinScissor( 10000.f); glm::vec3 MaxScissor(-10000.f); { 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, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 View = this->view(); glm::mat4 Model = glm::mat4(1.0f); *Pointer = Projection * View * Model; // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); glm::mat4 Ortho = glm::ortho(0.0f, 0.0f, float(WindowSize.x), float(WindowSize.y)); for(GLsizei i = 0; i < VertexCount; ++i) { glm::vec3 Projected = glm::project( glm::vec3(VertexData[i].Position, 0.0f), View * Model, Projection, glm::ivec4(0, 0, WindowSize.x, WindowSize.y)); MinScissor = glm::min(MinScissor, glm::vec3(Projected)); MaxScissor = glm::max(MaxScissor, glm::vec3(Projected)); } } glViewport(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glScissor(GLint(MinScissor.x), GLint(MinScissor.y), GLsizei(MaxScissor.x - MinScissor.x), GLsizei(MaxScissor.y - MinScissor.y)); glEnable(GL_SCISSOR_TEST); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniform1i(UniformDiffuse, 0); glUniformBlockBinding(ProgramName, UniformTransform, semantic::uniform::TRANSFORM0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glDisable(GL_SCISSOR_TEST); return true; }
t_value ml_gldrawarraysinstanced (value mode, value first, value count, value primcount) { glDrawArraysInstanced( conv_primitive_type_table[Int_val(mode)], Int_val(first), Int_val(count), Int_val(primcount) ); return (Val_unit); }
void DrawArraysInstanced( const EMode::Value Mode, const GLint First, const GLsizei Count, const GLsizei PrimCount) { glDrawArraysInstanced(Mode, First, Count, PrimCount); }
void DrawLineShader::DrawInstances(const LineCommandBatch& instances) { glBindVertexArray(_vao); glBindBuffer(GL_ARRAY_BUFFER, _vboInstances); glBufferData(GL_ARRAY_BUFFER, sizeof(DrawLineCommand) * instances.size(), instances.data(), GL_STREAM_DRAW); glDrawArraysInstanced(GL_LINES, 0, 2, (GLsizei)instances.size()); }
void ParticleSceneNode::draw_this(QOpenGLFunctions *func, glm::mat4 matrix, DrawInfo &info) { glm::vec3 right, up; if (std::shared_ptr<Camera> camera = info.active_camera.lock()) { right = camera->right_vector(); up = camera->up_vector(); } m_program->bind(); int camera_up_id = m_program->uniformLocation("camera_up"); int camera_right_id = m_program->uniformLocation("camera_right"); int mvpID = m_program->uniformLocation("mvp"); int textureID = m_program->uniformLocation("particle_tex"); func->glUniformMatrix4fv(mvpID, 1, GL_FALSE, &matrix[0][0]); func->glUniform3fv(camera_right_id, 1, &right[0]); func->glUniform3fv(camera_up_id, 1, &up[0]); //func->glUniform1i(textureID, 0); //draw particle buffers m_vao.bind(); int vertsID = m_program->attributeLocation("loc"); int billboardID = m_program->attributeLocation("billboard_vert"); int uvID = m_program->attributeLocation("uv"); //vertices loc m_particle_verts_buffer.bind(); m_program->enableAttributeArray(vertsID); m_program->setAttributeBuffer(vertsID, GL_FLOAT, m_loc_offset, m_loc_count, m_loc_stride); m_particle_verts_buffer.release(); //billboard m_square_buffer.bind(); m_program->enableAttributeArray(billboardID); m_program->setAttributeBuffer(billboardID, GL_FLOAT, 0, 3, 0); m_square_buffer.release(); //uv m_tex_uv_buffer.bind(); m_program->enableAttributeArray(uvID); m_program->setAttributeBuffer(uvID, GL_FLOAT, 0, 2, 0); m_tex_uv_buffer.release(); glVertexAttribDivisor(vertsID, 1); glVertexAttribDivisor(billboardID, 0); glVertexAttribDivisor(uvID, 0); glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, m_billboard_verts_count, m_particle_verts_count); m_program->disableAttributeArray(vertsID); m_vao.release(); m_program->release(); }
void ParticleSystemProxy::drawNotFlip() { glDepthMask(GL_FALSE); glDisable(GL_CULL_FACE); glEnable(GL_BLEND); if (m_alpha_additive) glBlendFunc(GL_SRC_ALPHA, GL_ONE); else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glUseProgram(SimpleParticleRender::Program); glEnableVertexAttribArray(SimpleParticleRender::attrib_pos); glEnableVertexAttribArray(SimpleParticleRender::attrib_lf); glEnableVertexAttribArray(SimpleParticleRender::attrib_quadcorner); glEnableVertexAttribArray(SimpleParticleRender::attrib_texcoord); glEnableVertexAttribArray(SimpleParticleRender::attrib_sz); float screen[2] = { (float)UserConfigParams::m_width, (float)UserConfigParams::m_height }; bindUniformToTextureUnit(SimpleParticleRender::uniform_texture, texture, 0); bindUniformToTextureUnit(SimpleParticleRender::uniform_normal_and_depths, normal_and_depth, 1); glUniformMatrix4fv(SimpleParticleRender::uniform_invproj, 1, GL_FALSE, irr_driver->getInvProjMatrix().pointer()); glUniform2f(SimpleParticleRender::uniform_screen, screen[0], screen[1]); glUniformMatrix4fv(SimpleParticleRender::uniform_matrix, 1, GL_FALSE, irr_driver->getProjMatrix().pointer()); glUniformMatrix4fv(SimpleParticleRender::uniform_viewmatrix, 1, GL_FALSE, irr_driver->getViewMatrix().pointer()); glBindBuffer(GL_ARRAY_BUFFER, quad_vertex_buffer); glVertexAttribPointer(SimpleParticleRender::attrib_quadcorner, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0); glVertexAttribPointer(SimpleParticleRender::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid *)(2 * sizeof(float))); glBindBuffer(GL_ARRAY_BUFFER, tfb_buffers[0]); glVertexAttribPointer(SimpleParticleRender::attrib_pos, 3, GL_FLOAT, GL_FALSE, sizeof(ParticleData), 0); glVertexAttribPointer(SimpleParticleRender::attrib_lf, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(3 * sizeof(float))); glVertexAttribPointer(SimpleParticleRender::attrib_sz, 1, GL_FLOAT, GL_FALSE, sizeof(ParticleData), (GLvoid *)(7 * sizeof(float))); glVertexAttribDivisor(SimpleParticleRender::attrib_lf, 1); glVertexAttribDivisor(SimpleParticleRender::attrib_pos, 1); glVertexAttribDivisor(SimpleParticleRender::attrib_sz, 1); glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, count); glVertexAttribDivisor(SimpleParticleRender::attrib_lf, 0); glVertexAttribDivisor(SimpleParticleRender::attrib_pos, 0); glVertexAttribDivisor(SimpleParticleRender::attrib_sz, 0); glDisableVertexAttribArray(SimpleParticleRender::attrib_pos); glDisableVertexAttribArray(SimpleParticleRender::attrib_lf); glDisableVertexAttribArray(SimpleParticleRender::attrib_quadcorner); glDisableVertexAttribArray(SimpleParticleRender::attrib_texcoord); glDisableVertexAttribArray(SimpleParticleRender::attrib_sz); glBindBuffer(GL_ARRAY_BUFFER, 0); glActiveTexture(GL_TEXTURE0); glDisable(GL_BLEND); }
void display() { // Update of the uniform buffer { 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::perspectiveFov(45.f, 640.f, 480.f, 0.1f, 100.0f); glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 8.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); *Pointer = Projection * View * Model; // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); } glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glViewport(0, 0, Window.Size.x, Window.Size.y); glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName[framebuffer::DEPTH_MULTISAMPLE]); float Depth(1.0f); glClearBufferfv(GL_DEPTH , 0, &Depth); // Bind rendering objects glUseProgram(ProgramName[program::TEXTURE]); glUniformBlockBinding(ProgramName[program::TEXTURE], UniformTransform, glf::semantic::uniform::TRANSFORM0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glBindVertexArray(VertexArrayName[program::TEXTURE]); glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 2, 0); // Pass 2 glDisable(GL_DEPTH_TEST); glBindFramebuffer(GL_FRAMEBUFFER, 0); glUseProgram(ProgramName[program::SPLASH]); glActiveTexture(GL_TEXTURE0); glBindVertexArray(VertexArrayName[program::SPLASH]); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, TextureName[texture::MULTISAMPLE]); glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1); glf::swapBuffers(); }
void display() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glUseProgram(shader); //Hämtar tidsvariabeln glUniform1f(elapsedTimeUniform, glutGet(GLUT_ELAPSED_TIME) / 1000.0f); //Binder partikeldata till partikelbuffern glBindBuffer(GL_ARRAY_BUFFER, particlePositionBuffer); glBufferData(GL_ARRAY_BUFFER, MAX_PARTICLES * 4 * 4 * sizeof(GLfloat), NULL, GL_STREAM_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, MAX_PARTICLES * sizeof(GLfloat) * 4 * 4, particlePositionData); //Binder vertex array object glBindVertexArray(vertexArray); //Laddar attributdata int pos = glGetAttribLocation(shader, "transformmatrix"); glEnableVertexAttribArray(pos); glEnableVertexAttribArray(pos + 1); glEnableVertexAttribArray(pos + 2); glEnableVertexAttribArray(pos + 3); glBindBuffer(GL_ARRAY_BUFFER, particlePositionBuffer); glVertexAttribPointer(pos , 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4*4, (void*)(0)); glVertexAttribPointer(pos + 1, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4*4, (void*)(sizeof(float)*4)); glVertexAttribPointer(pos + 2, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4*4, (void*)(sizeof(float)*8)); glVertexAttribPointer(pos + 3, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4*4, (void*)(sizeof(float)*12)); //Partikel vertexar: always reuse the same 4 vertices -> 0 glVertexAttribDivisor(0, 0); glVertexAttribDivisor(pos , 1); glVertexAttribDivisor(pos + 1, 1); glVertexAttribDivisor(pos + 2, 1); glVertexAttribDivisor(pos + 3, 1); //Tillåter förändring av storlek på GL_POINTS glEnable(GL_PROGRAM_POINT_SIZE); //Ritar partiklarna glDrawArraysInstanced(GL_POINTS, 0, 4, MAX_PARTICLES); //Rensar data glDisableVertexAttribArray(0); glDisableVertexAttribArray(pos); glDisableVertexAttribArray(pos + 1); glDisableVertexAttribArray(pos + 2); glDisableVertexAttribArray(pos + 3); glBindVertexArray(0); glutSwapBuffers(); glutPostRedisplay(); }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; // Set the display viewport glViewport(0, 0, WindowSize.x, WindowSize.y); // Clear color buffer glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // First draw, capture the attributes // Disable rasterisation, vertices processing only! glEnable(GL_RASTERIZER_DISCARD); glUseProgram(ProgramName[program::TRANSFORM]); glUniformMatrix4fv(TransformUniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, BufferName[program::FEEDBACK]); glBindVertexArray(VertexArrayName[program::TRANSFORM]); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, QueryName); glBeginTransformFeedback(GL_TRIANGLES); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glDisable(GL_RASTERIZER_DISCARD); // Second draw, reuse the captured attributes glUseProgram(ProgramName[program::FEEDBACK]); GLuint PrimitivesWritten = 0; glGetQueryObjectuiv(QueryName, GL_QUERY_RESULT, &PrimitivesWritten); glBindVertexArray(VertexArrayName[program::FEEDBACK]); glDrawArraysInstanced(GL_TRIANGLES, 0, PrimitivesWritten * 3, 1); return true; }