예제 #1
0
	void OGLGraphicsBuffer::Unmap()
	{
		if (glloader_GL_EXT_direct_state_access())
		{
			glUnmapNamedBufferEXT(vb_);
		}
		else
		{
			OGLRenderEngine& re = *checked_cast<OGLRenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
			re.BindBuffer(target_, vb_);
			glUnmapBuffer(target_);
		}
	}
void resolveMultisampling()
{
	{
		glm::mat4* Pointer = (glm::mat4*)glMapNamedBufferRangeEXT(
			BufferName[buffer::BLIT], 0, sizeof(glm::mat4),
			GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT);

		glm::mat4 Perspective = glm::perspective(45.0f, float(Window.Size.x) / Window.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;

		*Pointer = MVP;
		glUnmapNamedBufferEXT(BufferName[buffer::BLIT]);
		//glNamedBufferSubDataEXT(BufferName[buffer::BLIT], 0, sizeof(glm::mat4), &MVP[0][0]);
	}

	glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y));
	glEnable(GL_SCISSOR_TEST);
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

	glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::BLIT]);
	glBindMultiTextureEXT(GL_TEXTURE0, GL_TEXTURE_2D_MULTISAMPLE, TextureName[texture::MULTISAMPLE]);
	glBindSampler(0, SamplerName);
	glBindVertexArray(VertexArrayName);

	// Box
	{
		glScissorIndexed(0, 1, 1, Window.Size.x  / 2 - 2, Window.Size.y - 2);
		glBindProgramPipeline(PipelineName[program::RESOLVE_BOX]);
		glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 5, 0);
	}

	// Near
	{
		glScissorIndexed(0, Window.Size.x / 2 + 1, 1, Window.Size.x / 2 - 2, Window.Size.y - 2);
		glBindProgramPipeline(PipelineName[program::RESOLVE_NEAR]);
		glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 5, 0);
	}

	glDisable(GL_SCISSOR_TEST);
}
예제 #3
0
파일: Buffer.cpp 프로젝트: voxelinc/glow
bool Buffer::unmap()
{
    if (m_directStateAccess)
    {
        GLboolean success = glUnmapNamedBufferEXT(m_id);
        CheckGLError();

        return success == GL_TRUE;
    }
    else
    {
        bind();

        GLboolean success = glUnmapBuffer(m_target);
        CheckGLError();

        return success == GL_TRUE;
    }
}
void renderFBO()
{
	{
		glm::mat4* Pointer = (glm::mat4*)glMapNamedBufferRangeEXT(
			BufferName[buffer::TRANSFORM], 0, sizeof(glm::mat4),
			GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);

		glm::mat4 Perspective = glm::perspective(45.0f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f);
		glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y * 2.0 - 4.0));
		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 = Perspective * View * Model;

		*Pointer = MVP;
		glUnmapNamedBufferEXT(BufferName[buffer::TRANSFORM]);
		//glNamedBufferSubDataEXT(BufferName[buffer::TRANSFORM], 0, sizeof(glm::mat4), &MVP[0][0]);
	}

	glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y));
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_MULTISAMPLE);

	glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
	float Depth(1.0f);
	glClearBufferfv(GL_DEPTH, 0, &Depth);
	glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);

	glBindProgramPipeline(PipelineName[program::THROUGH]);
	glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
	glBindMultiTextureEXT(GL_TEXTURE0, GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
	glBindSampler(0, SamplerName);
	glBindVertexArray(VertexArrayName);

	glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 5, 0);

	glDisable(GL_MULTISAMPLE);
	glDisable(GL_DEPTH_TEST);
}
	bool render()
	{
		{
			glm::uint8* Pointer = reinterpret_cast<glm::uint8*>(glMapNamedBufferRangeEXT(BufferName[buffer::TRANSFORM],
				0, this->UniformBlockSize, GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));

			glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f);
			*reinterpret_cast<glm::mat4*>(Pointer + 0) = Projection * this->view() * glm::mat4(1);

			// Make sure the uniform buffer is uploaded
			glUnmapNamedBufferEXT(BufferName[buffer::TRANSFORM]);
		}

		glBindProgramPipeline(PipelineName);

		// Step 1: render the scene in a multisampled framebuffer
		renderFBO();

		// Step 2: resolve MSAA
		glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferName[framebuffer::RENDER]);
		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, FramebufferName[framebuffer::RESOLVE]);
		glBlitFramebuffer(
			0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
			0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);

		// Step 3: Blit resolved colorbuffer. Resolve and blit can't be done in a single step
		glm::ivec2 const WindowSize(this->getWindowSize());

		glBindFramebuffer(GL_READ_FRAMEBUFFER, FramebufferName[framebuffer::RESOLVE]);
		glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
		glBlitFramebuffer(
			0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
			0, 0, WindowSize.x, WindowSize.y, GL_COLOR_BUFFER_BIT, GL_NEAREST);

		return true;
	}
bool BufferImplementation_DirectStateAccessEXT::unmap(const Buffer * buffer) const
{
    return GL_TRUE == glUnmapNamedBufferEXT(buffer->id());
}
예제 #7
0
void map_ptr::unmap() const
{
    glUnmapNamedBufferEXT(this->Name);
}
예제 #8
0
파일: r_mesh.c 프로젝트: raynorpat/cake
/*
=============
GL_DrawAliasFrameLerp

interpolates between two frames and origins
FIXME: batch lerp all vertexes
=============
*/
void GL_DrawAliasFrameLerp (entity_t *e, dmdl_t *hdr, float backlerp)
{
	int		i;
	float	frontlerp;
	float	alpha;
	vec3_t	delta, vectors[3];

	daliasframe_t *currframe = (daliasframe_t *) ((byte *) hdr + hdr->ofs_frames + e->currframe * hdr->framesize);
	daliasframe_t *lastframe = (daliasframe_t *) ((byte *) hdr + hdr->ofs_frames + e->lastframe * hdr->framesize);

	meshubo_t *meshubo = NULL;
	GLbitfield access;

	if (e->flags & RF_TRANSLUCENT)
		alpha = e->alpha;
	else alpha = 1.0;

	frontlerp = 1.0 - backlerp;

	// move should be the delta back to the previous frame * backlerp
	VectorSubtract (e->lastorigin, e->currorigin, delta);
	AngleVectors (e->angles, vectors[0], vectors[1], vectors[2]);

	gl_meshuboupdate.move[0] = lastframe->translate[0] + DotProduct (delta, vectors[0]);	// forward
	gl_meshuboupdate.move[1] = lastframe->translate[1] - DotProduct (delta, vectors[1]);	// left
	gl_meshuboupdate.move[2] = lastframe->translate[2] + DotProduct (delta, vectors[2]);	// up

	for (i = 0; i < 3; i++)
	{
		gl_meshuboupdate.move[i] = backlerp * gl_meshuboupdate.move[i] + frontlerp * currframe->translate[i];
		gl_meshuboupdate.frontv[i] = frontlerp * currframe->scale[i];
		gl_meshuboupdate.backv[i] = backlerp * lastframe->scale[i];
	}

	if (!(e->flags & (RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE)))
	{
		if (gl_monolightmap->value)
		{
			float ntsc[] = {0.3f, 0.59f, 0.11f};
			float gs = DotProduct (gl_meshuboupdate.shadelight, ntsc);

			gl_meshuboupdate.shadelight[0] = gl_meshuboupdate.shadelight[1] = gl_meshuboupdate.shadelight[2] = gs;
		}

		gl_meshuboupdate.shadelight[0] *= r_lightscale->value * 2.0f;
		gl_meshuboupdate.shadelight[1] *= r_lightscale->value * 2.0f;
		gl_meshuboupdate.shadelight[2] *= r_lightscale->value * 2.0f;

		gl_meshuboupdate.powersuitscale = 0.0f;
		gl_meshuboupdate.shellmix = 0.0f;
	}
	else
	{
		float scale = (e->flags & RF_WEAPONMODEL) ? WEAPONSHELL_SCALE : POWERSUIT_SCALE;

		gl_meshuboupdate.powersuitscale = scale;
		gl_meshuboupdate.shellmix = 1.0f;
	}

	gl_meshuboupdate.shadelight[3] = alpha;
	gl_meshuboupdate.lerpfrac = backlerp;

	if (e->model->lastcurrframe != e->currframe)
	{
		glVertexArrayVertexAttribOffsetEXT (e->model->meshvao, e->model->meshvbo, 0, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (posevert_t), VERTOFFSET (e->currframe));
		e->model->lastcurrframe = e->currframe;
	}

	if (e->model->lastlastframe != e->lastframe)
	{
		glVertexArrayVertexAttribOffsetEXT (e->model->meshvao, e->model->meshvbo, 1, 4, GL_UNSIGNED_BYTE, GL_FALSE, sizeof (posevert_t), VERTOFFSET (e->lastframe));
		e->model->lastlastframe = e->lastframe;
	}

	GL_BindVertexArray (e->model->meshvao);
	GL_Enable (DEPTHTEST_BIT | ((e->flags & RF_TRANSLUCENT) ? BLEND_BIT : DEPTHWRITE_BIT) | (gl_cull->value ? CULLFACE_BIT : 0));
	GL_UseProgram (gl_meshprog);

	if (gl_meshubonumblocks + 1 >= MESH_UBO_MAX_BLOCKS)
	{
		access = BUFFER_DISCARD;
		gl_meshubonumblocks = 0;
	}
	else access = BUFFER_NO_OVERWRITE;

	if ((meshubo = glMapNamedBufferRangeEXT (gl_meshubo, gl_meshubonumblocks * gl_meshuboblocksize, sizeof (meshubo_t), access)) != NULL)
	{
		memcpy (meshubo, &gl_meshuboupdate, sizeof (meshubo_t));

		glUnmapNamedBufferEXT (gl_meshubo);
		glBindBufferRange (GL_UNIFORM_BUFFER, gl_meshubobinding, gl_meshubo, gl_meshubonumblocks * gl_meshuboblocksize, sizeof (meshubo_t));

		glDrawElements (GL_TRIANGLES, e->model->numindexes, GL_UNSIGNED_SHORT, NULL);
		gl_meshubonumblocks++;
	}
}