Exemplo n.º 1
0
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);
	}
Exemplo n.º 3
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);
    }


}
Exemplo n.º 4
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);
	}
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
0
//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);
}
Exemplo n.º 7
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;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 9
0
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));
}
Exemplo n.º 10
0
		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__);
		}
Exemplo n.º 11
0
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);
}
Exemplo n.º 12
0
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);
	}
Exemplo n.º 14
0
	void draw()
	{
		VK_CHECK_RESULT(Swapchain.acquire(presentCompleteSemaphore, &currentBuffer));
		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));
	}
Exemplo n.º 15
0
		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);
	}
Exemplo n.º 17
0
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);
}
Exemplo n.º 18
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);
}
Exemplo n.º 19
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;                    
}
Exemplo n.º 20
0
//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);
}
Exemplo n.º 21
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);
    }
}
Exemplo n.º 22
0
// 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);
	}
Exemplo n.º 24
0
    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();
    }
Exemplo n.º 25
0
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;
}
Exemplo n.º 26
0
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;
	}

}
Exemplo n.º 27
0
void Buffer::bindRange(GLenum target, GLuint index, GLintptr offset, GLsizeiptr size)
{
    glBindBufferRange(target, index, m_id, offset, size);
	CheckGLError();
}
Exemplo n.º 28
0
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);
}
Exemplo n.º 29
0
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);
	}
}