X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fbackends%2Fopengl%2Fpipelinestate_backend.cpp;fp=source%2Fbackends%2Fopengl%2Fpipelinestate_backend.cpp;h=738de3ac5fea34250f29659a09752e2208d497e7;hb=160e9eea29bd10034733d59507fa1bcca36be401;hp=0000000000000000000000000000000000000000;hpb=93448d16e72e38afbaecbccf6fdedd46d6a82a73;p=libs%2Fgl.git

diff --git a/source/backends/opengl/pipelinestate_backend.cpp b/source/backends/opengl/pipelinestate_backend.cpp
new file mode 100644
index 00000000..738de3ac
--- /dev/null
+++ b/source/backends/opengl/pipelinestate_backend.cpp
@@ -0,0 +1,282 @@
+#include <msp/gl/extensions/arb_direct_state_access.h>
+#include <msp/gl/extensions/arb_sampler_objects.h>
+#include <msp/gl/extensions/arb_shader_objects.h>
+#include <msp/gl/extensions/arb_uniform_buffer_object.h>
+#include <msp/gl/extensions/arb_vertex_array_object.h>
+#include <msp/gl/extensions/ext_framebuffer_object.h>
+#include <msp/gl/extensions/msp_primitive_restart.h>
+#include "blend.h"
+#include "buffer.h"
+#include "depthtest.h"
+#include "deviceinfo.h"
+#include "framebuffer.h"
+#include "gl.h"
+#include "pipelinestate.h"
+#include "pipelinestate_backend.h"
+#include "program.h"
+#include "rect.h"
+#include "sampler.h"
+#include "stenciltest.h"
+#include "texture.h"
+#include "uniformblock.h"
+#include "vertexsetup.h"
+
+using namespace std;
+
+namespace Msp {
+namespace GL {
+
+const OpenGLPipelineState *OpenGLPipelineState::last_applied = 0;
+vector<int> OpenGLPipelineState::bound_tex_targets;
+vector<char> OpenGLPipelineState::bound_uniform_blocks;
+unsigned OpenGLPipelineState::restart_index = 0;
+
+OpenGLPipelineState::OpenGLPipelineState()
+{
+	if(bound_tex_targets.empty())
+		bound_tex_targets.resize(DeviceInfo::get_global().limits.max_texture_bindings);
+	if(bound_uniform_blocks.empty())
+		bound_uniform_blocks.resize(DeviceInfo::get_global().limits.max_uniform_bindings);
+}
+
+OpenGLPipelineState::~OpenGLPipelineState()
+{
+	if(this==last_applied)
+		last_applied = 0;
+}
+
+void OpenGLPipelineState::apply() const
+{
+	if(!last_applied)
+		OpenGLTexture::unbind_scratch();
+
+	apply(this==last_applied ? static_cast<const PipelineState *>(this)->changes : ~0U);
+}
+
+void OpenGLPipelineState::apply(unsigned mask) const
+{
+	const PipelineState *self = static_cast<const PipelineState *>(this);
+
+	if(mask&PipelineState::FRAMEBUFFER)
+	{
+		const Framebuffer *framebuffer = self->framebuffer;
+		glBindFramebuffer(GL_FRAMEBUFFER, framebuffer ? framebuffer->id : 0);
+		if(framebuffer)
+		{
+			framebuffer->refresh();
+			framebuffer->require_complete();
+		}
+	}
+
+	if(mask&(PipelineState::VIEWPORT|PipelineState::FRAMEBUFFER))
+	{
+		if(const Rect *viewport = self->viewport)
+			glViewport(viewport->left, viewport->bottom, viewport->width, viewport->height);
+		else if(const Framebuffer *framebuffer = self->framebuffer)
+			glViewport(0, 0, framebuffer->get_width(), framebuffer->get_height());
+	}
+
+	if(mask&PipelineState::SCISSOR)
+	{
+		if(const Rect *scissor = self->scissor)
+		{
+			glEnable(GL_SCISSOR_TEST);
+			glScissor(scissor->left, scissor->bottom, scissor->width, scissor->height);
+		}
+		else
+			glDisable(GL_SCISSOR_TEST);
+	}
+
+	if(mask&PipelineState::SHPROG)
+		glUseProgram(self->shprog ? self->shprog->id : 0);
+
+	if(mask&PipelineState::VERTEX_SETUP)
+	{
+		const VertexSetup *vertex_setup = self->vertex_setup;
+		glBindVertexArray(vertex_setup ? vertex_setup->id : 0);
+		if(vertex_setup)
+		{
+			static Require _req(MSP_primitive_restart);
+
+			vertex_setup->refresh();
+			unsigned ri = (vertex_setup->get_index_type()==UNSIGNED_INT ? 0xFFFFFFFF : 0xFFFF);
+			if(ri!=restart_index)
+			{
+				if(!restart_index)
+					glEnable(GL_PRIMITIVE_RESTART);
+				glPrimitiveRestartIndex(ri);
+				restart_index = ri;
+			}
+		}
+	}
+
+	if(mask&PipelineState::FACE_CULL)
+	{
+		glFrontFace(self->front_face==CLOCKWISE ? GL_CW : GL_CCW);
+
+		if(self->face_cull!=NO_CULL && self->front_face!=NON_MANIFOLD)
+		{
+			glEnable(GL_CULL_FACE);
+			glCullFace(self->face_cull==CULL_FRONT ? GL_FRONT : GL_BACK);
+		}
+		else
+			glDisable(GL_CULL_FACE);
+	}
+
+	if(mask&PipelineState::CLIP_PLANES)
+	{
+		unsigned max_clip_planes = DeviceInfo::get_global().limits.max_clip_planes;
+		for(unsigned i=0; i<max_clip_planes; ++i)
+		{
+			if((self->enabled_clip_planes>>i)&1)
+				glEnable(GL_CLIP_PLANE0+i);
+			else
+				glDisable(GL_CLIP_PLANE0+i);
+		}
+	}
+
+	if(mask&PipelineState::TEXTURES)
+	{
+		for(const PipelineState::BoundTexture &t: self->textures)
+			if(t.changed || mask==~0U)
+			{
+				if(t.texture && t.sampler)
+				{
+					if(ARB_direct_state_access)
+						glBindTextureUnit(t.binding, t.texture->id);
+					else
+					{
+						glActiveTexture(GL_TEXTURE0+t.binding);
+						if(bound_tex_targets[t.binding] && static_cast<int>(t.texture->target)!=bound_tex_targets[t.binding])
+							glBindTexture(bound_tex_targets[t.binding], 0);
+						glBindTexture(t.texture->target, t.texture->id);
+					}
+
+					bound_tex_targets[t.binding] = t.texture->target;
+
+					glBindSampler(t.binding, t.sampler->id);
+					t.sampler->refresh();
+				}
+
+				t.changed = false;
+			}
+	}
+
+	if(mask&PipelineState::UNIFORMS)
+	{
+		for(const PipelineState::BoundUniformBlock &u: self->uniform_blocks)
+			if(u.changed || mask==~0U)
+			{
+				if(u.block)
+				{
+					if(u.binding>=0)
+					{
+						glBindBufferRange(GL_UNIFORM_BUFFER, u.binding, u.block->get_buffer()->id, u.block->get_offset(), u.block->get_data_size());
+						bound_uniform_blocks[u.binding] = 1;
+					}
+					else if(self->shprog)
+					{
+						const char *data = static_cast<const char *>(u.block->get_data_pointer());
+						for(const Program::UniformCall &call: self->shprog->uniform_calls)
+							call.func(call.location, call.size, data+call.location*16);
+					}
+				}
+
+				u.changed = false;
+			}
+	}
+
+	if(mask&PipelineState::DEPTH_TEST)
+	{
+		const DepthTest *depth_test = self->depth_test;
+		if(depth_test && depth_test->enabled)
+		{
+			glEnable(GL_DEPTH_TEST);
+			glDepthFunc(get_gl_predicate(depth_test->compare));
+		}
+		else
+			glDisable(GL_DEPTH_TEST);
+
+		glDepthMask(!depth_test || depth_test->write);
+	}
+
+	if(mask&PipelineState::STENCIL_TEST)
+	{
+		const StencilTest *stencil_test = self->stencil_test;
+		if(stencil_test && stencil_test->enabled)
+		{
+			glEnable(GL_STENCIL_TEST);
+			glStencilFunc(get_gl_predicate(stencil_test->compare), stencil_test->reference, 0xFFFFFFFF);
+			glStencilOp(get_gl_stencil_op(stencil_test->stencil_fail_op), get_gl_stencil_op(stencil_test->depth_fail_op), get_gl_stencil_op(stencil_test->depth_pass_op));
+		}
+		else
+			glDisable(GL_STENCIL_TEST);
+	}
+
+	if(mask&PipelineState::BLEND)
+	{
+		const Blend *blend = self->blend;
+		if(blend && blend->enabled)
+		{
+			glEnable(GL_BLEND);
+			glBlendEquation(get_gl_blend_equation(blend->equation));
+			glBlendFunc(get_gl_blend_factor(blend->src_factor), get_gl_blend_factor(blend->dst_factor));
+			glBlendColor(blend->constant.r, blend->constant.g, blend->constant.b, blend->constant.a);
+			ColorWriteMask cw = blend->write_mask;
+			glColorMask((cw&WRITE_RED)!=0, (cw&WRITE_GREEN)!=0, (cw&WRITE_BLUE)!=0, (cw&WRITE_ALPHA)!=0);
+		}
+		else
+		{
+			glDisable(GL_BLEND);
+			glColorMask(true, true, true, true);
+		}
+	}
+
+	last_applied = this;
+	self->changes &= ~mask;
+}
+
+void OpenGLPipelineState::clear()
+{
+	if(last_applied)
+	{
+		glUseProgram(0);
+		glBindVertexArray(0);
+
+		unsigned max_clip_planes = DeviceInfo::get_global().limits.max_clip_planes;
+		unsigned enabled_clip_planes = static_cast<const PipelineState *>(last_applied)->enabled_clip_planes;
+		for(unsigned i=0; i<max_clip_planes; ++i)
+			if((enabled_clip_planes>>i)&1)
+				glDisable(GL_CLIP_PLANE0+i);
+
+		for(unsigned i=0; i<bound_tex_targets.size(); ++i)
+			if(bound_tex_targets[i])
+			{
+				if(ARB_direct_state_access)
+					glBindTextureUnit(i, 0);
+				else
+				{
+					glActiveTexture(GL_TEXTURE0+i);
+					glBindTexture(bound_tex_targets[i], 0);
+				}
+				bound_tex_targets[i] = 0;
+			}
+
+		for(unsigned i=0; i<bound_uniform_blocks.size(); ++i)
+			if(bound_uniform_blocks[i])
+			{
+				glBindBufferBase(GL_UNIFORM_BUFFER, i, 0);
+				bound_uniform_blocks[i] = 0;
+			}
+
+		glDisable(GL_DEPTH_TEST);
+		glDepthMask(true);
+		glDisable(GL_STENCIL_TEST);
+		glDisable(GL_BLEND);
+
+		last_applied = 0;
+	}
+}
+
+} // namespace GL
+} // namespace Msp