11 #ifndef hifi_gpu_State_h
12 #define hifi_gpu_State_h
19 #include <unordered_map>
26 #define SET_FIELD(FIELD, PATH, value) \
28 _values.PATH = value; \
29 if (value == DEFAULT.PATH) { \
30 _signature.reset(FIELD); \
32 _signature.set(FIELD); \
44 State(
const State& state) : _values(state._values), _signature(state._signature), _stamp(state._stamp) {}
47 Stamp getStamp()
const {
return _stamp; }
49 typedef ::gpu::ComparisonFunction ComparisonFunction;
108 BLEND_OP_REV_SUBTRACT,
122 WRITE_ALL = (WRITE_RED | WRITE_GREEN | WRITE_BLUE | WRITE_ALPHA),
127 uint8 writeMask{
true };
128 uint8 enabled{
false };
129 ComparisonFunction
function{ LESS };
132 DepthTest(
bool enabled =
false,
bool writeMask =
true, ComparisonFunction func = LESS) :
133 writeMask(writeMask), enabled(enabled), function(func) {}
135 bool isEnabled()
const {
return enabled != 0; }
136 ComparisonFunction getFunction()
const {
return function; }
137 uint8 getWriteMask()
const {
return writeMask; }
139 bool operator==(
const DepthTest& right)
const {
141 writeMask == right.writeMask &&
142 enabled == right.enabled &&
143 function == right.function;
146 bool operator!=(
const DepthTest& right)
const {
147 return !(*
this == right);
150 operator QString()
const {
151 return QString(
"{ writeMask = %1, enabled = %2, function = %3 }").arg(writeMask).arg(enabled).arg(
function);
156 ComparisonFunction
function;
158 StencilOp depthFailOp;
161 uint8 readMask{ 0xff };
164 StencilTest(int8 reference = 0,
165 uint8 readMask = 0xFF,
166 ComparisonFunction func = ALWAYS,
167 StencilOp failOp = STENCIL_OP_KEEP,
168 StencilOp depthFailOp = STENCIL_OP_KEEP,
169 StencilOp passOp = STENCIL_OP_KEEP) :
171 failOp(failOp), depthFailOp(depthFailOp), passOp(passOp), reference(reference), readMask(readMask) {}
173 ComparisonFunction getFunction()
const {
return function; }
174 StencilOp getFailOp()
const {
return failOp; }
175 StencilOp getDepthFailOp()
const {
return depthFailOp; }
176 StencilOp getPassOp()
const {
return passOp; }
178 int8 getReference()
const {
return reference; }
179 uint8 getReadMask()
const {
return readMask; }
181 bool operator==(
const StencilTest& right)
const {
183 function == right.function &&
184 failOp == right.failOp &&
185 depthFailOp == right.depthFailOp &&
186 passOp == right.passOp &&
187 reference == right.reference &&
188 readMask == right.readMask;
192 bool operator!=(
const StencilTest &right)
const {
return !(right==*
this); }
195 StencilTest stencilTestFront;
197 struct StencilActivation {
198 uint8 frontWriteMask = 0xFF;
199 uint8 backWriteMask = 0xFF;
203 StencilActivation(
bool enabled =
false, uint8 frontWriteMask = 0xFF, uint8 backWriteMask = 0xFF) :
204 frontWriteMask(frontWriteMask), backWriteMask(backWriteMask), enabled(enabled) {}
206 bool isEnabled()
const {
return enabled; }
207 uint8 getWriteMaskFront()
const {
return frontWriteMask; }
208 uint8 getWriteMaskBack()
const {
return backWriteMask; }
210 bool operator==(
const StencilActivation& right)
const {
212 frontWriteMask == right.frontWriteMask &&
213 backWriteMask == right.backWriteMask &&
214 enabled == right.enabled;
217 bool operator!=(
const StencilActivation& right)
const {
218 return !(*
this == right);
222 struct BlendFunction {
225 BlendArg sourceColor;
226 BlendArg sourceAlpha;
233 BlendFunction(
bool enabled,
234 BlendArg sourceColor,
235 BlendOp operationColor,
236 BlendArg destinationColor,
237 BlendArg sourceAlpha,
238 BlendOp operationAlpha,
239 BlendArg destinationAlpha) :
241 sourceColor(sourceColor), sourceAlpha(sourceAlpha),
242 destColor(destinationColor), destAlpha(destinationAlpha),
243 opColor(operationColor), opAlpha(operationAlpha) {}
245 BlendFunction(
bool enabled =
false, BlendArg source = ONE, BlendOp operation = BLEND_OP_ADD, BlendArg destination = ZERO) :
246 BlendFunction(enabled, source, operation, destination, source, operation, destination) {}
248 bool isEnabled()
const {
return (enabled != 0); }
250 BlendArg getSourceColor()
const {
return sourceColor; }
251 BlendArg getDestinationColor()
const {
return destColor; }
252 BlendOp getOperationColor()
const {
return opColor; }
254 BlendArg getSourceAlpha()
const {
return sourceAlpha; }
255 BlendArg getDestinationAlpha()
const {
return destAlpha; }
256 BlendOp getOperationAlpha()
const {
return opAlpha; }
258 bool operator==(
const BlendFunction& right)
const {
260 enabled == right.enabled &&
261 sourceColor == right.sourceColor &&
262 sourceAlpha == right.sourceAlpha &&
263 destColor == right.destColor &&
264 destAlpha == right.destAlpha &&
265 opColor == right.opColor &&
266 opAlpha == right.opAlpha;
270 bool operator!=(
const BlendFunction& right)
const {
271 return !(*
this == right);
277 frontFaceClockwise(false), depthClampEnable(false), scissorEnable(false), multisampleEnable(true),
278 antialisedLineEnable(true), alphaToCoverageEnable(false) {}
279 bool frontFaceClockwise;
280 bool depthClampEnable;
282 bool multisampleEnable;
283 bool antialisedLineEnable;
284 bool alphaToCoverageEnable;
287 bool operator==(
const Flags& right)
const {
289 frontFaceClockwise == right.frontFaceClockwise &&
290 depthClampEnable == right.depthClampEnable &&
291 scissorEnable == right.scissorEnable &&
292 multisampleEnable == right.multisampleEnable &&
293 antialisedLineEnable == right.antialisedLineEnable &&
294 alphaToCoverageEnable == right.alphaToCoverageEnable;
298 bool operator!=(
const Flags& right)
const {
299 return !(*
this == right);
307 float depthBias = 0.0f;
308 float depthBiasSlopeScale = 0.0f;
311 StencilActivation stencilActivation;
312 StencilTest stencilTestFront;
313 StencilTest stencilTestBack;
314 uint32 sampleMask = 0xFFFFFFFF;
315 BlendFunction blendFunction;
316 FillMode fillMode{ FILL_FACE };
317 CullMode cullMode{ CULL_NONE };
318 ColorMask colorWriteMask{ WRITE_ALL };
324 static const Data DEFAULT;
325 void setFillMode(FillMode fill) { SET_FIELD(FILL_MODE, fillMode, fill); }
326 FillMode getFillMode()
const {
return _values.fillMode; }
328 void setCullMode(CullMode cull) { SET_FIELD(CULL_MODE, cullMode, cull); }
329 CullMode getCullMode()
const {
return _values.cullMode; }
331 const Flags& getFlags()
const {
return _values.flags; }
333 void setFrontFaceClockwise(
bool isClockwise) { SET_FIELD(FRONT_FACE_CLOCKWISE, flags.frontFaceClockwise, isClockwise); }
334 bool isFrontFaceClockwise()
const {
return _values.flags.frontFaceClockwise; }
336 void setDepthClampEnable(
bool enable) { SET_FIELD(DEPTH_CLAMP_ENABLE, flags.depthClampEnable, enable); }
337 bool isDepthClampEnable()
const {
return _values.flags.depthClampEnable; }
339 void setScissorEnable(
bool enable) { SET_FIELD(SCISSOR_ENABLE, flags.scissorEnable, enable); }
340 bool isScissorEnable()
const {
return _values.flags.scissorEnable; }
342 void setMultisampleEnable(
bool enable) { SET_FIELD(MULTISAMPLE_ENABLE, flags.multisampleEnable, enable); }
343 bool isMultisampleEnable()
const {
return _values.flags.multisampleEnable; }
345 void setAntialiasedLineEnable(
bool enable) { SET_FIELD(ANTIALISED_LINE_ENABLE, flags.antialisedLineEnable, enable); }
346 bool isAntialiasedLineEnable()
const {
return _values.flags.antialisedLineEnable; }
349 void setDepthBias(
float bias) { SET_FIELD(DEPTH_BIAS, depthBias, bias); }
350 float getDepthBias()
const {
return _values.depthBias; }
352 void setDepthBiasSlopeScale(
float scale) { SET_FIELD(DEPTH_BIAS_SLOPE_SCALE, depthBiasSlopeScale, scale); }
353 float getDepthBiasSlopeScale()
const {
return _values.depthBiasSlopeScale; }
356 void setDepthTest(DepthTest newDepthTest) { SET_FIELD(DEPTH_TEST, depthTest, newDepthTest); }
357 void setDepthTest(
bool enable,
bool writeMask, ComparisonFunction func) {
358 setDepthTest(DepthTest(enable, writeMask, func));
360 DepthTest getDepthTest()
const {
return _values.depthTest; }
362 bool isDepthTestEnabled()
const {
return getDepthTest().isEnabled(); }
363 uint8 getDepthTestWriteMask()
const {
return getDepthTest().getWriteMask(); }
364 ComparisonFunction getDepthTestFunc()
const {
return getDepthTest().getFunction(); }
367 void setStencilTest(
bool enabled, uint8 frontWriteMask, StencilTest frontTest, uint8 backWriteMask, StencilTest backTest) {
368 SET_FIELD(STENCIL_ACTIVATION, stencilActivation, StencilActivation(enabled, frontWriteMask, backWriteMask));
369 SET_FIELD(STENCIL_TEST_FRONT, stencilTestFront, frontTest);
370 SET_FIELD(STENCIL_TEST_BACK, stencilTestBack, backTest);
373 void setStencilTest(
bool enabled, uint8 frontWriteMask, StencilTest frontTest) {
374 setStencilTest(enabled, frontWriteMask, frontTest, frontWriteMask, frontTest);
377 StencilActivation getStencilActivation()
const {
return _values.stencilActivation; }
378 StencilTest getStencilTestFront()
const {
return _values.stencilTestFront; }
379 StencilTest getStencilTestBack()
const {
return _values.stencilTestBack; }
381 bool isStencilEnabled()
const {
return getStencilActivation().isEnabled(); }
382 uint8 getStencilWriteMaskFront()
const {
return getStencilActivation().getWriteMaskFront(); }
383 uint8 getStencilWriteMaskBack()
const {
return getStencilActivation().getWriteMaskBack(); }
386 void setAlphaToCoverageEnable(
bool enable) { SET_FIELD(ALPHA_TO_COVERAGE_ENABLE, flags.alphaToCoverageEnable, enable); }
387 bool isAlphaToCoverageEnabled()
const {
return _values.flags.alphaToCoverageEnable; }
390 void setSampleMask(uint32 mask) { SET_FIELD(SAMPLE_MASK, sampleMask, mask); }
391 uint32 getSampleMask()
const {
return _values.sampleMask; }
394 void setBlendFunction(BlendFunction
function) { SET_FIELD(BLEND_FUNCTION, blendFunction,
function); }
395 const BlendFunction& getBlendFunction()
const {
return _values.blendFunction; }
397 void setBlendFunction(
bool enabled,
398 BlendArg sourceColor,
399 BlendOp operationColor,
400 BlendArg destinationColor,
401 BlendArg sourceAlpha,
402 BlendOp operationAlpha,
403 BlendArg destinationAlpha) {
404 setBlendFunction(BlendFunction(enabled, sourceColor, operationColor, destinationColor, sourceAlpha, operationAlpha,
407 void setBlendFunction(
bool enabled, BlendArg source, BlendOp operation, BlendArg destination) {
408 setBlendFunction(BlendFunction(enabled, source, operation, destination));
411 bool isBlendEnabled()
const {
return getBlendFunction().isEnabled(); }
414 void setColorWriteMask(ColorMask mask) { SET_FIELD(COLOR_WRITE_MASK, colorWriteMask, mask); }
415 void setColorWriteMask(
bool red,
bool green,
bool blue,
bool alpha) {
416 ColorMask value = (ColorMask)((WRITE_RED * red) | (WRITE_GREEN * green) | (WRITE_BLUE * blue) | (WRITE_ALPHA * alpha));
417 SET_FIELD(COLOR_WRITE_MASK, colorWriteMask, value);
419 ColorMask getColorWriteMask()
const {
return _values.colorWriteMask; }
427 FRONT_FACE_CLOCKWISE,
431 ANTIALISED_LINE_ENABLE,
434 DEPTH_BIAS_SLOPE_SCALE,
444 ALPHA_TO_COVERAGE_ENABLE,
455 typedef std::bitset<NUM_FIELDS> Signature;
457 Signature getSignature()
const {
return _signature; }
459 static Signature evalSignature(
const Data& state);
462 State(
const Data& values);
463 const Data& getValues()
const {
return _values; }
465 const GPUObjectPointer gpuObject{};
468 State& operator=(
const State& state);
471 Signature _signature{ 0 };
475 typedef std::shared_ptr<State> StatePointer;
476 typedef std::vector<StatePointer> States;