From c9e03603944107b44c1519a19e19e04f7af885f4 Mon Sep 17 00:00:00 2001 From: Sam Gateau Date: Thu, 26 Mar 2015 13:48:49 -0700 Subject: [PATCH] using gpu::Pipeline it s mostly working but still glUniforms to get rid of --- libraries/gpu/src/gpu/GLBackend.cpp | 3 +- libraries/gpu/src/gpu/GLBackend.h | 39 ++-- libraries/gpu/src/gpu/GLBackendState.cpp | 230 +++++++++-------------- libraries/gpu/src/gpu/State.h | 162 +++++++++------- libraries/model/src/model/Stage.cpp | 4 +- libraries/render-utils/src/Model.cpp | 4 +- 6 files changed, 203 insertions(+), 239 deletions(-) diff --git a/libraries/gpu/src/gpu/GLBackend.cpp b/libraries/gpu/src/gpu/GLBackend.cpp index 4831ecdd4c..d05ba74b57 100644 --- a/libraries/gpu/src/gpu/GLBackend.cpp +++ b/libraries/gpu/src/gpu/GLBackend.cpp @@ -370,8 +370,9 @@ void GLBackend::do_glUseProgram(Batch& batch, uint32 paramOffset) { } void Batch::_glUniform1f(GLint location, GLfloat v0) { + if (location < 0) + return; ADD_COMMAND_GL(glUniform1f); - _params.push_back(v0); _params.push_back(location); diff --git a/libraries/gpu/src/gpu/GLBackend.h b/libraries/gpu/src/gpu/GLBackend.h index 8a65263df0..0ef407df8a 100644 --- a/libraries/gpu/src/gpu/GLBackend.h +++ b/libraries/gpu/src/gpu/GLBackend.h @@ -79,9 +79,7 @@ public: public: class Command { public: - virtual void run(GLBackend* backend) = 0; - Command() {} virtual ~Command() {}; }; @@ -89,46 +87,32 @@ public: template class Command1 : public Command { public: typedef void (GLBackend::*GLFunction)(typename T); - void run(GLBackend* backend) { (backend->*(_func))(_param); } - Command1(GLFunction func, T param) : _func(func), _param(param) {}; - GLFunction _func; T _param; }; template class Command2 : public Command { public: - typedef void (*GLFunction)(typename T, typename U); - - void run(GLBackend* backend) { (_func)(_param0, _param1); } - + typedef void (GLBackend::*GLFunction)(typename T, typename U); + void run(GLBackend* backend) { (backend->*(_func))(_param0, _param1); } Command2(GLFunction func, T param0, U param1) : _func(func), _param0(param0), _param1(param1) {}; - GLFunction _func; T _param0; U _param1; }; - template class Command4 : public Command { + template class Command3 : public Command { public: - typedef void (*GLFunction)(typename T, typename U, typename V, typename W); - - void run(GLBackend* backend) { (_func)(_param0, _param1, _param2, _param3); } - - Command4(GLFunction func, T param0, U param1, V param2, W param3) : - _func(func), - _param0(param0), - _param1(param1), - _param2(param2), - _param3(param3) {}; - + typedef void (GLBackend::*GLFunction)(typename T, typename U, typename V); + void run(GLBackend* backend) { (backend->*(_func))(_param0, _param1, _param2); } + Command3(GLFunction func, T param0, U param1, V param2) : _func(func), _param0(param0), _param1(param1), _param2(param2) {}; GLFunction _func; T _param0; U _param1; V _param2; - W _param3; }; + typedef std::shared_ptr< Command > CommandPointer; typedef std::vector< CommandPointer > Commands; @@ -137,6 +121,8 @@ public: GLState(); ~GLState(); + + friend class GLBackend; }; static GLState* syncGPUObject(const State& state); @@ -156,7 +142,7 @@ public: uint32 getNumInputBuffers() const { return _input._buffersState.size(); } - + // The State setters called by the GLState::Commands when a new state is assigned void do_setStateFillMode(int32 mode); void do_setStateCullMode(int32 mode); void do_setStateFrontClockwise(int32 isFrontClockwise); @@ -167,11 +153,12 @@ public: void do_setStateDepthTest(State::DepthTest test); - void do_setStateStencilEnable(int32 enable); + void do_setStateStencil(State::StencilActivation activation, State::StencilTest frontTest, State::StencilTest backTest); void do_setStateAlphaToCoverageEnable(int32 enable); - void do_setStateBlendEnable(int32 enable); + void do_setStateBlend(State::BlendFunction blendFunction, Vec4 blendFactor); + void do_setStateColorWriteMask(int32 mask); protected: diff --git a/libraries/gpu/src/gpu/GLBackendState.cpp b/libraries/gpu/src/gpu/GLBackendState.cpp index 9fa515b2c4..94304080c5 100644 --- a/libraries/gpu/src/gpu/GLBackendState.cpp +++ b/libraries/gpu/src/gpu/GLBackendState.cpp @@ -24,23 +24,10 @@ GLBackend::GLState::~GLState() { typedef GLBackend::GLState::Command Command; typedef GLBackend::GLState::CommandPointer CommandPointer; typedef GLBackend::GLState::Command1 Command1I; -typedef GLBackend::GLState::Command1 Command1DT; -typedef GLBackend::GLState::Command1 Command1E; -typedef GLBackend::GLState::Command2 Command2E; -typedef GLBackend::GLState::Command2 Command2F; -typedef GLBackend::GLState::Command4 Command4E; -typedef GLBackend::GLState::Command4 Command4F; -typedef GLBackend::GLState::Command4 Command4B; - -static GLenum GL_COMPARISON_FUNCTIONS[] = { - GL_NEVER, - GL_LESS, - GL_EQUAL, - GL_LEQUAL, - GL_GREATER, - GL_NOTEQUAL, - GL_GEQUAL, - GL_ALWAYS }; +typedef GLBackend::GLState::Command1 CommandDepthTest; +typedef GLBackend::GLState::Command3 CommandStencil; +typedef GLBackend::GLState::Command2 CommandBlend; + void generateFillMode(GLBackend::GLState::Commands& commands, State::FillMode fillMode) { commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateFillMode, int32(fillMode)))); @@ -86,99 +73,23 @@ void generateAntialiasedLineEnable(GLBackend::GLState::Commands& commands, bool } void generateDepthTest(GLBackend::GLState::Commands& commands, State::DepthTest& test) { - commands.push_back(CommandPointer(new Command1DT(&GLBackend::do_setStateDepthTest, int32(test.getRaw())))); + commands.push_back(CommandPointer(new CommandDepthTest(&GLBackend::do_setStateDepthTest, int32(test.getRaw())))); } -void generateStencilEnable(GLBackend::GLState::Commands& commands, bool enable) { - commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateStencilEnable, int32(enable)))); -} - -void generateStencilWriteMask(GLBackend::GLState::Commands& commands, uint32 mask) { -// commands.push_back(CommandPointer(new Command1E((Command1E::GLFunction)glStencilMask, mask))); -} - -void generateStencilState(GLBackend::GLState::Commands& commands, const State& state) { - auto frontTest(state.getStencilTestFront()); - auto backTest(state.getStencilTestBack()); - - commands.push_back(CommandPointer(new Command4E((Command4E::GLFunction)glBlendEquationSeparate, - GL_FRONT, GL_COMPARISON_FUNCTIONS[frontTest._function], state.getStencilReference(), state.getStencilReadMask()))); - commands.push_back(CommandPointer(new Command4E((Command4E::GLFunction)glBlendEquationSeparate, - GL_BACK, GL_COMPARISON_FUNCTIONS[backTest._function], state.getStencilReference(), state.getStencilReadMask()))); - - static GLenum STENCIL_OPS[] = { - GL_KEEP, - GL_ZERO, - GL_REPLACE, - GL_INCR_WRAP, - GL_DECR_WRAP, - GL_INVERT, - GL_INCR, - GL_DECR }; - - commands.push_back(CommandPointer(new Command4E((Command4E::GLFunction)glStencilOpSeparate, - GL_FRONT, STENCIL_OPS[frontTest._failOp], STENCIL_OPS[frontTest._passOp], STENCIL_OPS[frontTest._depthFailOp]))); - commands.push_back(CommandPointer(new Command4E((Command4E::GLFunction)glStencilOpSeparate, - GL_BACK, STENCIL_OPS[backTest._failOp], STENCIL_OPS[backTest._passOp], STENCIL_OPS[backTest._depthFailOp]))); +void generateStencil(GLBackend::GLState::Commands& commands, const State& state) { + commands.push_back(CommandPointer(new CommandStencil(&GLBackend::do_setStateStencil, state.getStencilActivation(), state.getStencilTestFront(), state.getStencilTestBack()))); } void generateAlphaToCoverageEnable(GLBackend::GLState::Commands& commands, bool enable) { commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateAlphaToCoverageEnable, int32(enable)))); } -void generateBlendEnable(GLBackend::GLState::Commands& commands, bool enable) { - commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateBlendEnable, int32(enable)))); +void generateBlend(GLBackend::GLState::Commands& commands, const State& state) { + commands.push_back(CommandPointer(new CommandBlend(&GLBackend::do_setStateBlend, state.getBlendFunction(), state.getBlendFactor()))); } -void generateBlendFunction(GLBackend::GLState::Commands& commands, const State& state) { - static GLenum GL_BLEND_OPS[] = { - GL_FUNC_ADD, - GL_FUNC_SUBTRACT, - GL_FUNC_REVERSE_SUBTRACT, - GL_MIN, - GL_MAX }; - - auto colorFunction = state.getBlendFunctionColor(); - auto alphaFunction = state.getBlendFunctionColor(); - - commands.push_back(CommandPointer(new Command2E((Command2E::GLFunction)glBlendEquationSeparate, - GL_BLEND_OPS[colorFunction._operation], - GL_BLEND_OPS[alphaFunction._operation]))); - - static GLenum BLEND_ARGS[] = { - GL_ZERO, - GL_ONE, - GL_SRC_COLOR, - GL_ONE_MINUS_SRC_COLOR, - GL_SRC_ALPHA, - GL_ONE_MINUS_SRC_ALPHA, - GL_DST_ALPHA, - GL_ONE_MINUS_DST_ALPHA, - GL_DST_COLOR, - GL_ONE_MINUS_DST_COLOR, - GL_SRC_ALPHA_SATURATE, - GL_CONSTANT_COLOR, - GL_ONE_MINUS_CONSTANT_COLOR - }; - - commands.push_back(CommandPointer(new Command4E((Command4E::GLFunction)glBlendFuncSeparate, - BLEND_ARGS[colorFunction._source], - BLEND_ARGS[colorFunction._destination], - BLEND_ARGS[alphaFunction._source], - BLEND_ARGS[alphaFunction._destination]))); -} - -void generateBlendFactor(GLBackend::GLState::Commands& commands, const Vec4& factor) { - commands.push_back(CommandPointer(new Command4F((Command4F::GLFunction)glBlendColor, - factor.x, factor.y, factor.z, factor.w))); -} - -void generateColorWriteMask(GLBackend::GLState::Commands& commands, State::ColorMask mask) { - commands.push_back(CommandPointer(new Command4B((Command4B::GLFunction)glColorMask, - mask & State::ColorMask::WRITE_RED, - mask & State::ColorMask::WRITE_GREEN, - mask & State::ColorMask::WRITE_BLUE, - mask & State::ColorMask::WRITE_ALPHA ))); +void generateColorWriteMask(GLBackend::GLState::Commands& commands, int32 mask) { + commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateColorWriteMask, int32(mask)))); } GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { @@ -200,13 +111,8 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { object->_stamp = state.getStamp(); bool depthBias = false; - - bool stencilEnabled = false; bool stencilState = false; - - bool blendEnabled = false; - bool blendFunction = false; - bool blendFactor = false; + bool blendState = false; // go thorugh the list of state fields in the State and record the corresponding gl command for (auto field: state.getFields()) { @@ -224,7 +130,7 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { depthBias = true; break; } - case State::FRONT_CLOCKWISE: { + case State::FRONT_FACE: { generateFrontClockwise(object->_commands, bool(field.second._integer)); break; } @@ -249,14 +155,7 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { break; } - case State::STENCIL_ENABLE: { - stencilEnabled = bool(field.second._integer); - generateStencilEnable(object->_commands, stencilEnabled); - break; - } - case State::STENCIL_WRITE_MASK: - case State::STENCIL_READ_MASK: - case State::STENCIL_REFERENCE: + case State::STENCIL_ACTIVATION: case State::STENCIL_TEST_FRONT: case State::STENCIL_TEST_BACK: { stencilState = true; @@ -271,26 +170,17 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { break; } - case State::BLEND_ENABLE: { - blendEnabled = field.second._integer; - generateBlendEnable(object->_commands, blendEnabled); - break; - } - case State::BLEND_FUNCTION_COLOR: - case State::BLEND_FUNCTION_ALPHA: { - blendFunction = true; - break; - } + case State::BLEND_FUNCTION: case State::BLEND_FACTOR_X: case State::BLEND_FACTOR_Y: case State::BLEND_FACTOR_Z: case State::BLEND_FACTOR_W: { - blendFactor = true; + blendState = true; break; } case State::COLOR_WRITE_MASK: { - generateColorWriteMask(object->_commands, State::ColorMask(field.second._integer)); + generateColorWriteMask(object->_commands, field.second._integer); break; } @@ -301,19 +191,27 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { generateDepthBias(object->_commands, state); } - if (stencilEnabled) { - generateStencilState(object->_commands, state); - generateStencilWriteMask(object->_commands, state.getStencilWriteMask()); + if (stencilState) { + generateStencil(object->_commands, state); } - if (blendEnabled) { - generateBlendFunction(object->_commands, state); - generateBlendFactor(object->_commands, state.getBlendFactor()); + if (blendState) { + generateBlend(object->_commands, state); } return object; } + +static GLenum GL_COMPARISON_FUNCTIONS[] = { + GL_NEVER, + GL_LESS, + GL_EQUAL, + GL_LEQUAL, + GL_GREATER, + GL_NOTEQUAL, + GL_GEQUAL, + GL_ALWAYS }; void GLBackend::do_setStateFillMode(int32 mode) { static GLenum GL_FILL_MODES[] = { GL_POINT, GL_LINE, GL_FILL }; @@ -386,9 +284,27 @@ void GLBackend::do_setStateDepthTest(State::DepthTest test) { CHECK_GL_ERROR(); } -void GLBackend::do_setStateStencilEnable(int32 enable) { - if (enable) { +void GLBackend::do_setStateStencil(State::StencilActivation activation, State::StencilTest frontTest, State::StencilTest backTest) { + if (activation._enabled) { glEnable(GL_STENCIL_TEST); + glStencilMaskSeparate(GL_FRONT, activation._frontWriteMask); + glStencilMaskSeparate(GL_BACK, activation._backWriteMask); + + static GLenum STENCIL_OPS[] = { + GL_KEEP, + GL_ZERO, + GL_REPLACE, + GL_INCR_WRAP, + GL_DECR_WRAP, + GL_INVERT, + GL_INCR, + GL_DECR }; + + glStencilFuncSeparate(GL_FRONT, STENCIL_OPS[frontTest._failOp], STENCIL_OPS[frontTest._passOp], STENCIL_OPS[frontTest._depthFailOp]); + glStencilFuncSeparate(GL_FRONT, GL_COMPARISON_FUNCTIONS[frontTest._function], frontTest._reference, frontTest._readMask); + + glStencilFuncSeparate(GL_BACK, STENCIL_OPS[backTest._failOp], STENCIL_OPS[backTest._passOp], STENCIL_OPS[backTest._depthFailOp]); + glStencilFuncSeparate(GL_BACK, GL_COMPARISON_FUNCTIONS[backTest._function], backTest._reference, backTest._readMask); } else { glDisable(GL_STENCIL_TEST); } @@ -404,12 +320,50 @@ void GLBackend::do_setStateAlphaToCoverageEnable(int32 enable) { CHECK_GL_ERROR(); } - -void GLBackend::do_setStateBlendEnable(int32 enable) { - if (enable) { +void GLBackend::do_setStateBlend(State::BlendFunction function, Vec4 factor ) { + if (function._enabled) { glEnable(GL_BLEND); + + static GLenum GL_BLEND_OPS[] = { + GL_FUNC_ADD, + GL_FUNC_SUBTRACT, + GL_FUNC_REVERSE_SUBTRACT, + GL_MIN, + GL_MAX }; + + glBlendEquationSeparate(GL_BLEND_OPS[function._operationColor], GL_BLEND_OPS[function._operationAlpha]); + + static GLenum BLEND_ARGS[] = { + GL_ZERO, + GL_ONE, + GL_SRC_COLOR, + GL_ONE_MINUS_SRC_COLOR, + GL_SRC_ALPHA, + GL_ONE_MINUS_SRC_ALPHA, + GL_DST_ALPHA, + GL_ONE_MINUS_DST_ALPHA, + GL_DST_COLOR, + GL_ONE_MINUS_DST_COLOR, + GL_SRC_ALPHA_SATURATE, + GL_CONSTANT_COLOR, + GL_ONE_MINUS_CONSTANT_COLOR, + GL_CONSTANT_ALPHA, + GL_ONE_MINUS_CONSTANT_ALPHA, + }; + + glBlendFuncSeparate(BLEND_ARGS[function._sourceColor], BLEND_ARGS[function._destinationColor], + BLEND_ARGS[function._sourceAlpha], BLEND_ARGS[function._destinationAlpha]); + + glBlendColor(factor.x, factor.y, factor.z, factor.w); } else { glDisable(GL_BLEND); } CHECK_GL_ERROR(); } + +void GLBackend::do_setStateColorWriteMask(int32 mask) { + glColorMask(mask & State::ColorMask::WRITE_RED, + mask & State::ColorMask::WRITE_GREEN, + mask & State::ColorMask::WRITE_BLUE, + mask & State::ColorMask::WRITE_ALPHA ); +} \ No newline at end of file diff --git a/libraries/gpu/src/gpu/State.h b/libraries/gpu/src/gpu/State.h index deaf8c8271..97990ccfb5 100755 --- a/libraries/gpu/src/gpu/State.h +++ b/libraries/gpu/src/gpu/State.h @@ -32,31 +32,25 @@ public: enum Field { FILL_MODE, CULL_MODE, - - DEPTH_BIAS, - DEPTH_BIAS_SLOPE_SCALE, - - FRONT_CLOCKWISE, + FRONT_FACE, DEPTH_CLIP_ENABLE, SCISSOR_ENABLE, MULTISAMPLE_ENABLE, ANTIALISED_LINE_ENABLE, + DEPTH_BIAS, + DEPTH_BIAS_SLOPE_SCALE, + DEPTH_TEST, - STENCIL_ENABLE, - STENCIL_READ_MASK, - STENCIL_WRITE_MASK, + STENCIL_ACTIVATION, STENCIL_TEST_FRONT, STENCIL_TEST_BACK, - STENCIL_REFERENCE, SAMPLE_MASK, ALPHA_TO_COVERAGE_ENABLE, - BLEND_ENABLE, - BLEND_FUNCTION_COLOR, - BLEND_FUNCTION_ALPHA, + BLEND_FUNCTION, BLEND_FACTOR_X, BLEND_FACTOR_Y, BLEND_FACTOR_Z, @@ -121,9 +115,11 @@ public: DEST_COLOR, INV_DEST_COLOR, SRC_ALPHA_SAT, - BLEND_FACTOR, - INV_BLEND_FACTOR, - + FACTOR_COLOR, + INV_FACTOR_COLOR, + FACTOR_ALPHA, + INV_FACTOR_ALPHA, + NUM_BLEND_ARGS, }; @@ -153,37 +149,65 @@ public: bool _writeMask = true; bool _enabled = false; - DepthTest(bool enable, bool writeMask, ComparisonFunction func) : - _function(func), _writeMask(writeMask), _enabled(enable) {} + DepthTest(bool enabled, bool writeMask, ComparisonFunction func) : + _function(func), _writeMask(writeMask), _enabled(enabled) {} int32 getRaw() const { return *(reinterpret_cast(this)); } DepthTest(int32 raw) { *(reinterpret_cast(this)) = raw; } }; - class StencilTest { - public: - int8 _failOp = STENCIL_OP_KEEP; - int8 _depthFailOp = STENCIL_OP_KEEP; - int8 _passOp = STENCIL_OP_KEEP; - int8 _function = ALWAYS; - - StencilTest(StencilOp failOp, StencilOp depthFailOp, StencilOp passOp, ComparisonFunction func) : - _failOp(failOp), _depthFailOp(depthFailOp), _passOp(passOp), _function(func) {} - - int32 raw() const { return *(reinterpret_cast(this)); } + class StencilTest { + public: + uint8 _reference; + uint8 _readMask; + int8 _function : 4; + int8 _failOp : 4; + int8 _depthFailOp : 4; + int8 _passOp : 4; + + StencilTest(uint8 reference = 0, uint8 readMask =0xFF, ComparisonFunction func = ALWAYS, StencilOp failOp = STENCIL_OP_KEEP, StencilOp depthFailOp = STENCIL_OP_KEEP, StencilOp passOp = STENCIL_OP_KEEP) : + _reference(reference), _readMask(readMask), _function(func), _failOp(failOp), _depthFailOp(depthFailOp), _passOp(passOp) {} + + int32 getRaw() const { return *(reinterpret_cast(this)); } StencilTest(int32 raw) { *(reinterpret_cast(this)) = raw; } + }; + + class StencilActivation { + public: + uint8 _frontWriteMask; + uint8 _backWriteMask; + int16 _enabled; + + StencilActivation(bool enabled, uint8 frontWriteMask = 0xFF, uint8 backWriteMask = 0xFF) : + _frontWriteMask(frontWriteMask), _backWriteMask(backWriteMask), _enabled(enabled) {} + + int32 getRaw() const { return *(reinterpret_cast(this)); } + StencilActivation(int32 raw) { *(reinterpret_cast(this)) = raw; } }; + class BlendFunction { public: - int8 _source = ONE; - int8 _operation = BLEND_OP_ADD; - int8 _destination = ZERO; - int8 _spare = 0; + int8 _enabled; + int8 _sourceColor : 4; + int8 _sourceAlpha : 4; + int8 _destinationColor : 4; + int8 _destinationAlpha : 4; + int8 _operationColor : 4; + int8 _operationAlpha : 4; - BlendFunction(BlendArg source, BlendOp operation, BlendArg destination) : - _source(source), _operation(operation), _destination(destination) {} + BlendFunction(bool enabled, + BlendArg sourceColor, BlendOp operationColor, BlendArg destinationColor, + BlendArg sourceAlpha, BlendOp operationAlpha, BlendArg destinationAlpha) : + _enabled(enabled), + _sourceColor(sourceColor), _operationColor(operationColor), _destinationColor(destinationColor), + _sourceAlpha(sourceAlpha), _operationAlpha(operationAlpha), _destinationAlpha(destinationAlpha) {} + + BlendFunction(bool enabled, BlendArg source, BlendOp operation, BlendArg destination) : + _enabled(enabled), + _sourceColor(source), _operationColor(operation), _destinationColor(destination), + _sourceAlpha(source), _operationAlpha(operation), _destinationAlpha(destination) {} int32 raw() const { return *(reinterpret_cast(this)); } BlendFunction(int32 raw) { *(reinterpret_cast(this)) = raw; } @@ -214,65 +238,61 @@ public: void setCullMode(CullMode cull) { set(CULL_MODE, uint32(cull)); } CullMode getCullMode() const { return CullMode(get(CULL_MODE)._integer); } - void setFrontClockwise(bool enable) { set(FRONT_CLOCKWISE, enable); } + void setFrontFace(bool isClockwise) { set(FRONT_FACE, isClockwise); } void setDepthClipEnable(bool enable) { set(DEPTH_CLIP_ENABLE, enable); } - + void setScissorEnable(bool enable) { set(SCISSOR_ENABLE, enable); } + void setMultisampleEnable(bool enable) { set(MULTISAMPLE_ENABLE, enable); } + void setAntialiasedLineEnable(bool enable) { set(ANTIALISED_LINE_ENABLE, enable); } + + bool isFrontFaceClockwise() const { return get(FRONT_FACE)._integer; } + bool isDepthClipEnable() const { return get(DEPTH_CLIP_ENABLE)._integer; } + bool isScissorEnable() const { return get(SCISSOR_ENABLE)._integer; } + bool isMultisampleEnable() const { return get(MULTISAMPLE_ENABLE)._integer; } + bool isAntialiasedLineEnable() const { return get(ANTIALISED_LINE_ENABLE)._integer; } + void setDepthBias(float bias) { set(DEPTH_BIAS, bias); } void setDepthBiasSlopeScale(float scale) { set(DEPTH_BIAS_SLOPE_SCALE, scale); } float getDepthBias() const { return get(DEPTH_BIAS)._integer; } float getDepthBiasSlopeScale() const { return get(DEPTH_BIAS_SLOPE_SCALE)._float; } - - - void setScissorEnable(bool enable) { set(SCISSOR_ENABLE, enable); } - void setMultisampleEnable(bool enable) { set(MULTISAMPLE_ENABLE, enable); } - void setAntialiasedLineEnable(bool enable) { set(ANTIALISED_LINE_ENABLE, enable); } - bool getFrontClockwise() const { return get(FRONT_CLOCKWISE)._integer; } - bool getDepthClipEnable() const { return get(DEPTH_CLIP_ENABLE)._integer; } - bool getScissorEnable() const { return get(SCISSOR_ENABLE)._integer; } - bool getMultisampleEnable() const { return get(MULTISAMPLE_ENABLE)._integer; } - bool getAntialiasedLineEnable() const { return get(ANTIALISED_LINE_ENABLE)._integer; } void setDepthTest(bool enable, bool writeMask, ComparisonFunction func) { set(DEPTH_TEST, DepthTest(enable, writeMask, func).getRaw()); } DepthTest getDepthTest() const { return DepthTest(get(DEPTH_TEST)._integer); } - bool getDepthTestEnabled() const { return getDepthTest()._enabled; } + bool isDepthTestEnabled() const { return getDepthTest()._enabled; } bool getDepthTestWriteMask() const { return getDepthTest()._writeMask; } ComparisonFunction getDepthTestFunc() const { return ComparisonFunction(getDepthTest()._function); } - void setStencilEnable(bool enable) { set(STENCIL_ENABLE, enable); } - void setStencilReadMask(uint8 mask) { set(STENCIL_READ_MASK, mask); } - void setStencilWriteMask(uint8 mask) { set(STENCIL_WRITE_MASK, mask); } - bool getStencilEnable() const { return get(STENCIL_ENABLE)._integer; } - uint8 getStencilReadMask() const { return get(STENCIL_READ_MASK)._unsigned_integer; } - uint8 getStencilWriteMask() const { return get(STENCIL_WRITE_MASK)._unsigned_integer; } + void setStencilTest(bool enabled, uint8 frontWriteMask, StencilTest frontTest, uint8 backWriteMask, StencilTest backTest) { + set(STENCIL_ACTIVATION, StencilActivation(enabled, frontWriteMask, backWriteMask).getRaw()); + set(STENCIL_TEST_FRONT, frontTest.getRaw()); set(STENCIL_TEST_BACK, backTest.getRaw()); + } + void setStencilTest(bool enabled, uint8 frontWriteMask, StencilTest frontTest) { setStencilTest(enabled, frontWriteMask, frontTest, frontWriteMask, frontTest); } - void setStencilTestFront(StencilTest test) { set(STENCIL_TEST_FRONT, test.raw()); } - void setStencilTestBack(StencilTest test) { set(STENCIL_TEST_BACK, test.raw()); } + StencilActivation getStencilActivation() const { return StencilActivation(get(STENCIL_ACTIVATION)._integer); } + bool isStencilEnabled() const { return getStencilActivation()._enabled != 0; } + uint8 getStencilWriteMaskFront() const { return getStencilActivation()._frontWriteMask; } + uint8 getStencilWriteMaskBack() const { return getStencilActivation()._backWriteMask; } StencilTest getStencilTestFront() const { return StencilTest(get(STENCIL_TEST_FRONT)._integer); } StencilTest getStencilTestBack() const { return StencilTest(get(STENCIL_TEST_BACK)._integer); } - void setStencilReference(uint32 ref) { set(STENCIL_REFERENCE, ref); } - uint32 getStencilReference() const { return get(STENCIL_REFERENCE)._unsigned_integer; } - void setAlphaToCoverageEnable(bool enable) { set(ALPHA_TO_COVERAGE_ENABLE, enable); } - bool getAlphaToCoverageEnable() const { return get(ALPHA_TO_COVERAGE_ENABLE)._integer; } + bool isAlphaToCoverageEnabled() const { return get(ALPHA_TO_COVERAGE_ENABLE)._integer; } void setSampleMask(uint32 mask) { set(SAMPLE_MASK, mask); } uint32 getSampleMask() const { return get(SAMPLE_MASK)._unsigned_integer; } - void setBlendEnable(bool enable) { set(BLEND_ENABLE, enable); } - bool getBlendEnable() const { return get(BLEND_ENABLE)._integer; } - - void setBlendFunctionColor(BlendFunction function) { set(BLEND_FUNCTION_COLOR, function.raw()); } - BlendFunction getBlendFunctionColor() const { return BlendFunction(get(BLEND_FUNCTION_COLOR)._integer); } - void setBlendFunctionAlpha(BlendFunction function) { set(BLEND_FUNCTION_ALPHA, function.raw()); } - BlendFunction getBlendFunctionAlpha() const { return BlendFunction(get(BLEND_FUNCTION_ALPHA)._integer); } - + void setBlendFunction(BlendFunction function) { set(BLEND_FUNCTION, function.raw()); } + void setBlendFunction(bool enabled, BlendArg sourceColor, BlendOp operationColor, BlendArg destinationColor, + BlendArg sourceAlpha, BlendOp operationAlpha, BlendArg destinationAlpha) { + setBlendFunction(BlendFunction(enabled, sourceColor, operationColor, destinationColor, sourceAlpha, operationAlpha, destinationAlpha)); } + void setBlendFunction(bool enabled, BlendArg source, BlendOp operation, BlendArg destination) { + setBlendFunction(BlendFunction(enabled, source, operation, destination)); } + bool isBlendEnabled() const { return BlendFunction(get(BLEND_FUNCTION)._integer)._enabled; } + BlendFunction getBlendFunction() const { return BlendFunction(get(BLEND_FUNCTION)._integer); } void setBlendFactor(const Vec4& factor) { set(BLEND_FACTOR_X, factor.x); set(BLEND_FACTOR_Y, factor.y); set(BLEND_FACTOR_Z, factor.z); set(BLEND_FACTOR_W, factor.w); } Vec4 getBlendFactor() const { return Vec4(get(BLEND_FACTOR_X)._float, get(BLEND_FACTOR_Y)._float, get(BLEND_FACTOR_Z)._float, get(BLEND_FACTOR_W)._float); } - - void setColorWriteMask(ColorMask mask) { set(COLOR_WRITE_MASK, mask); } - ColorMask getColorWriteMask() const { return ColorMask(get(COLOR_WRITE_MASK)._integer); } + void setColorWriteMask(int32 mask) { set(COLOR_WRITE_MASK, mask); } + int32 getColorWriteMask() const { return ColorMask(get(COLOR_WRITE_MASK)._integer); } protected: State(const State& state); @@ -280,7 +300,7 @@ protected: FieldMap _fields; - Stamp _stamp; + Stamp _stamp = 0; // This shouldn't be used by anything else than the Backend class with the proper casting. mutable GPUObject* _gpuObject = nullptr; diff --git a/libraries/model/src/model/Stage.cpp b/libraries/model/src/model/Stage.cpp index a1a673a80b..b274973ee7 100644 --- a/libraries/model/src/model/Stage.cpp +++ b/libraries/model/src/model/Stage.cpp @@ -217,8 +217,8 @@ SunSkyStage::SunSkyStage() : auto skyShader = gpu::ShaderPointer(gpu::Shader::createProgram(skyFromAtmosphereVertex, skyFromAtmosphereFragment)); auto skyState = gpu::StatePointer(new gpu::State()); - skyState->setStencilEnable(false); - skyState->setBlendEnable(false); + // skyState->setStencilEnable(false); + // skyState->setBlendEnable(false); _skyPipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState)); diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index 711c850c5e..22202801d3 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/libraries/render-utils/src/Model.cpp @@ -128,7 +128,9 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey& key, state->setDepthTest(true, !key.isTranslucent(), gpu::State::LESS_EQUAL); // Blend on transparent - state->setBlendEnable(key.isTranslucent()); + state->setBlendFunction(key.isTranslucent(), + gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA, + gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE); auto it = insert(value_type(key.getRaw(), RenderPipeline(