X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fcore%2Fpipelinestate.cpp;h=97f353dcee8b572c835e1ac5569ca9769489b246;hb=009918e76dda88b0cb68fdaa20c63d6e952af260;hp=673fa701e6cb6c5d5860648bab880cda117a2a87;hpb=8e063e6def7412f85a26f829b641f28d3476062f;p=libs%2Fgl.git diff --git a/source/core/pipelinestate.cpp b/source/core/pipelinestate.cpp index 673fa701..97f353dc 100644 --- a/source/core/pipelinestate.cpp +++ b/source/core/pipelinestate.cpp @@ -5,10 +5,18 @@ #include #include #include +#include +#include +#include "blend.h" #include "buffer.h" #include "deviceinfo.h" +#include "depthtest.h" +#include "framebuffer.h" #include "pipelinestate.h" #include "program.h" +#include "rect.h" +#include "sampler.h" +#include "stenciltest.h" #include "texture.h" #include "uniformblock.h" #include "vertexsetup.h" @@ -20,17 +28,27 @@ namespace GL { const PipelineState *PipelineState::last_applied = 0; vector PipelineState::bound_tex_targets; +vector PipelineState::bound_uniform_blocks; +unsigned PipelineState::restart_index = 0; PipelineState::PipelineState(): + framebuffer(0), + viewport(0), + scissor(0), shprog(0), vertex_setup(0), front_face(COUNTERCLOCKWISE), face_cull(NO_CULL), enabled_clip_planes(0), + depth_test(0), + stencil_test(0), + blend(0), changes(0) { - if(!ARB_direct_state_access && bound_tex_targets.empty()) - bound_tex_targets.resize(Limits::get_global().max_texture_bindings); + 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); } PipelineState::~PipelineState() @@ -49,6 +67,21 @@ void PipelineState::set(T &target, T value, unsigned flag) } } +void PipelineState::set_framebuffer(const Framebuffer *f) +{ + set(framebuffer, f, FRAMEBUFFER|VIEWPORT); +} + +void PipelineState::set_viewport(const Rect *v) +{ + set(viewport, v, VIEWPORT); +} + +void PipelineState::set_scissor(const Rect *s) +{ + set(scissor, s, SCISSOR); +} + void PipelineState::set_shader_program(const Program *p) { set(shprog, p, SHPROG); @@ -79,7 +112,7 @@ void PipelineState::set_texture(unsigned binding, const Texture *tex, const Samp if((tex!=0)!=(samp!=0)) throw invalid_argument("PipelineState::set_texture"); - vector::iterator i = lower_bound_member(textures, binding, &BoundTexture::binding); + auto i = lower_bound_member(textures, binding, &BoundTexture::binding); if(i==textures.end() || i->binding!=binding) i = textures.insert(i, BoundTexture(binding)); if(tex!=i->texture || samp!=i->sampler) @@ -91,19 +124,9 @@ void PipelineState::set_texture(unsigned binding, const Texture *tex, const Samp } } -void PipelineState::set_uniforms(const DefaultUniformBlock *block) -{ - set_uniform_block_(-1, block); -} - -void PipelineState::set_uniform_block(unsigned binding, const BufferBackedUniformBlock *block) +void PipelineState::set_uniform_block(int binding, const UniformBlock *block) { - set_uniform_block_(binding, block); -} - -void PipelineState::set_uniform_block_(int binding, const UniformBlock *block) -{ - vector::iterator i = lower_bound_member(uniform_blocks, binding, &BoundUniformBlock::binding); + auto i = lower_bound_member(uniform_blocks, binding, &BoundUniformBlock::binding); if(i==uniform_blocks.end() || i->binding!=binding) i = uniform_blocks.insert(i, BoundUniformBlock(binding)); if(block!=i->block || binding<0) @@ -114,21 +137,80 @@ void PipelineState::set_uniform_block_(int binding, const UniformBlock *block) } } +void PipelineState::set_depth_test(const DepthTest *dt) +{ + set(depth_test, dt, DEPTH_TEST); +} + +void PipelineState::set_stencil_test(const StencilTest *st) +{ + set(stencil_test, st, STENCIL_TEST); +} + +void PipelineState::set_blend(const Blend *b) +{ + set(blend, b, BLEND); +} + void PipelineState::apply() const { + if(!last_applied) + Texture::unbind_scratch(); + apply(this==last_applied ? changes : ~0U); } void PipelineState::apply(unsigned mask) const { + if(mask&FRAMEBUFFER) + { + glBindFramebuffer(GL_FRAMEBUFFER, framebuffer ? framebuffer->id : 0); + if(framebuffer) + { + framebuffer->refresh(); + framebuffer->require_complete(); + } + } + + if(mask&VIEWPORT) + { + if(viewport) + glViewport(viewport->left, viewport->bottom, viewport->width, viewport->height); + else if(framebuffer) + glViewport(0, 0, framebuffer->get_width(), framebuffer->get_height()); + } + + if(mask&SCISSOR) + { + if(scissor) + { + glEnable(GL_SCISSOR_TEST); + glScissor(scissor->left, scissor->bottom, scissor->width, scissor->height); + } + else + glDisable(GL_SCISSOR_TEST); + } + if(mask&SHPROG) - glUseProgram(shprog ? shprog->get_id() : 0); + glUseProgram(shprog ? shprog->id : 0); if(mask&VERTEX_SETUP) { - glBindVertexArray(vertex_setup ? vertex_setup->get_id() : 0); + 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&FACE_CULL) @@ -146,7 +228,7 @@ void PipelineState::apply(unsigned mask) const if(mask&CLIP_PLANES) { - unsigned max_clip_planes = Limits::get_global().max_clip_planes; + unsigned max_clip_planes = DeviceInfo::get_global().limits.max_clip_planes; for(unsigned i=0; i>i)&1) @@ -158,110 +240,91 @@ void PipelineState::apply(unsigned mask) const if(mask&TEXTURES) { - if(last_applied && this!=last_applied) - { - vector::const_iterator i = textures.begin(); - vector::const_iterator j = last_applied->textures.begin(); - while(j!=last_applied->textures.end()) + for(const BoundTexture &t: textures) + if(t.changed || mask==~0U) { - if(i==textures.end() || j->bindingbinding) + if(t.texture && t.sampler) { - if(bound_tex_targets[j->binding]) + if(ARB_direct_state_access) + glBindTextureUnit(t.binding, t.texture->id); + else { - if(ARB_direct_state_access) - glBindTextureUnit(j->binding, 0); - else - { - glActiveTexture(GL_TEXTURE0+j->binding); - glBindTexture(bound_tex_targets[j->binding], 0); - } + glActiveTexture(GL_TEXTURE0+t.binding); + if(bound_tex_targets[t.binding] && static_cast(t.texture->target)!=bound_tex_targets[t.binding]) + glBindTexture(bound_tex_targets[t.binding], 0); + glBindTexture(t.texture->target, t.texture->id); } - ++j; - } - else - { - if(i->binding==j->binding) - ++j; - ++i; + + bound_tex_targets[t.binding] = t.texture->target; + + glBindSampler(t.binding, t.sampler->id); + t.sampler->refresh(); } + + t.changed = false; } - } + } - for(vector::const_iterator i=textures.begin(); i!=textures.end(); ++i) - if(i->changed || mask==~0U) + if(mask&UNIFORMS) + { + for(const BoundUniformBlock &u: uniform_blocks) + if(u.changed || mask==~0U) { - if(i->texture && i->sampler) + if(u.block) { - if(ARB_direct_state_access) - glBindTextureUnit(i->binding, i->texture->get_id()); - else + if(u.binding>=0) { - glActiveTexture(GL_TEXTURE0+i->binding); - if(bound_tex_targets[i->binding] && static_cast(i->texture->get_target())!=bound_tex_targets[i->binding]) - glBindTexture(bound_tex_targets[i->binding], 0); - glBindTexture(i->texture->get_target(), i->texture->get_id()); - bound_tex_targets[i->binding] = i->texture->get_target(); + 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; } - - glBindSampler(i->binding, i->sampler->get_id()); - i->sampler->refresh(); - } - else if(bound_tex_targets[i->binding]) - { - if(ARB_direct_state_access) - glBindTextureUnit(i->binding, 0); - else + else if(shprog) { - glActiveTexture(GL_TEXTURE0+i->binding); - glBindTexture(bound_tex_targets[i->binding], 0); - bound_tex_targets[i->binding] = 0; + const char *data = static_cast(u.block->get_data_pointer()); + for(const Program::UniformCall &call: shprog->uniform_calls) + call.func(call.location, call.size, data+call.location*16); } } - i->changed = false; + u.changed = false; } } - if(mask&UNIFORMS) + if(mask&DEPTH_TEST) { - if(last_applied && this!=last_applied) + if(depth_test && depth_test->enabled) { - vector::const_iterator i = uniform_blocks.begin(); - vector::const_iterator j = last_applied->uniform_blocks.begin(); - while(j!=last_applied->uniform_blocks.end()) - { - if(i==uniform_blocks.end() || j->bindingbinding) - { - glBindBufferBase(GL_UNIFORM_BUFFER, j->binding, 0); - ++j; - } - else - { - if(i->binding==j->binding) - ++j; - ++i; - } - } + glEnable(GL_DEPTH_TEST); + glDepthFunc(get_gl_predicate(depth_test->compare)); } + else + glDisable(GL_DEPTH_TEST); - for(vector::const_iterator i=uniform_blocks.begin(); i!=uniform_blocks.end(); ++i) - if(i->changed || mask==~0U) - { - if(i->block) - { - if(i->binding>=0) - { - const BufferBackedUniformBlock *block = static_cast(i->block); - glBindBufferRange(GL_UNIFORM_BUFFER, i->binding, block->get_buffer()->get_id(), block->get_offset(), block->get_data_size()); - } - else - static_cast(i->block)->apply(); - } - else - glBindBufferBase(GL_UNIFORM_BUFFER, i->binding, 0); + glDepthMask(!depth_test || depth_test->write); + } - i->changed = false; - } + if(mask&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&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); + } + else + glDisable(GL_BLEND); } last_applied = this; @@ -275,27 +338,35 @@ void PipelineState::clear() glUseProgram(0); glBindVertexArray(0); - unsigned max_clip_planes = Limits::get_global().max_clip_planes; + unsigned max_clip_planes = DeviceInfo::get_global().limits.max_clip_planes; for(unsigned i=0; ienabled_clip_planes>>i)&1) glDisable(GL_CLIP_PLANE0+i); - for(vector::const_iterator i=last_applied->textures.begin(); i!=last_applied->textures.end(); ++i) - if(i->texture && i->sampler) + for(unsigned i=0; ibinding, 0); + glBindTextureUnit(i, 0); else { - glActiveTexture(GL_TEXTURE0+i->binding); - glBindTexture(bound_tex_targets[i->binding], 0); - bound_tex_targets[i->binding] = 0; + glActiveTexture(GL_TEXTURE0+i); + glBindTexture(bound_tex_targets[i], 0); } + bound_tex_targets[i] = 0; + } + + for(unsigned i=0; i::const_iterator i=last_applied->uniform_blocks.begin(); i!=last_applied->uniform_blocks.end(); ++i) - if(i->block) - glBindBufferBase(GL_UNIFORM_BUFFER, i->binding, 0); + glDisable(GL_DEPTH_TEST); + glDepthMask(true); + glDisable(GL_STENCIL_TEST); + glDisable(GL_BLEND); last_applied = 0; }