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();
}
Exemplo n.º 2
0
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);
}
Exemplo n.º 3
0
void display(void)
{
	glClear(GL_COLOR_BUFFER_BIT);
	glBindVertexArray(vao);
	glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 7);
	glFlush();
}
Exemplo n.º 4
0
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();
}
Exemplo n.º 8
0
/*
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);
}
Exemplo n.º 9
0
// 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);
}
Exemplo n.º 10
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();
}
Exemplo n.º 11
0
	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;
	}
Exemplo n.º 14
0
	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;
	}
Exemplo n.º 15
0
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");
}
Exemplo n.º 16
0
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);
}
Exemplo n.º 17
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;
	}
Exemplo n.º 19
0
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();
}
Exemplo n.º 20
0
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");
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
	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;
	}
Exemplo n.º 23
0
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);
}
Exemplo n.º 24
0
		void DrawArraysInstanced(
			const EMode::Value Mode,
			const GLint First,
			const GLsizei Count,
			const GLsizei PrimCount)
		{
			glDrawArraysInstanced(Mode, First, Count, PrimCount);
		}
Exemplo n.º 25
0
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());
}
Exemplo n.º 26
0
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();
}
Exemplo n.º 27
0
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();
}
Exemplo n.º 29
0
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;
	}