// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
|
#include "Context.hpp"
|
|
#include "Primitive.hpp"
|
#include "Surface.hpp"
|
#include "Shader/PixelShader.hpp"
|
#include "Shader/VertexShader.hpp"
|
#include "Common/Memory.hpp"
|
#include "Common/Debug.hpp"
|
|
#include <string.h>
|
|
namespace sw
|
{
|
extern bool perspectiveCorrection;
|
|
bool halfIntegerCoordinates = false; // Pixel centers are not at integer coordinates
|
bool symmetricNormalizedDepth = false; // [-1, 1] instead of [0, 1]
|
bool booleanFaceRegister = false;
|
bool fullPixelPositionRegister = false;
|
bool leadingVertexFirst = false; // Flat shading uses first vertex, else last
|
bool secondaryColor = false; // Specular lighting is applied after texturing
|
bool colorsDefaultToZero = false;
|
|
bool forceWindowed = false;
|
bool quadLayoutEnabled = false;
|
bool veryEarlyDepthTest = true;
|
bool complementaryDepthBuffer = false;
|
bool postBlendSRGB = false;
|
bool exactColorRounding = false;
|
TransparencyAntialiasing transparencyAntialiasing = TRANSPARENCY_NONE;
|
bool forceClearRegisters = false;
|
|
Context::Context()
|
{
|
init();
|
}
|
|
Context::~Context()
|
{
|
}
|
|
void *Context::operator new(size_t bytes)
|
{
|
return allocate((unsigned int)bytes);
|
}
|
|
void Context::operator delete(void *pointer, size_t bytes)
|
{
|
deallocate(pointer);
|
}
|
|
bool Context::isDrawPoint(bool fillModeAware) const
|
{
|
switch(drawType)
|
{
|
case DRAW_POINTLIST:
|
case DRAW_INDEXEDPOINTLIST8:
|
case DRAW_INDEXEDPOINTLIST16:
|
case DRAW_INDEXEDPOINTLIST32:
|
return true;
|
case DRAW_LINELIST:
|
case DRAW_LINESTRIP:
|
case DRAW_LINELOOP:
|
case DRAW_INDEXEDLINELIST8:
|
case DRAW_INDEXEDLINESTRIP8:
|
case DRAW_INDEXEDLINELOOP8:
|
case DRAW_INDEXEDLINELIST16:
|
case DRAW_INDEXEDLINESTRIP16:
|
case DRAW_INDEXEDLINELOOP16:
|
case DRAW_INDEXEDLINELIST32:
|
case DRAW_INDEXEDLINESTRIP32:
|
case DRAW_INDEXEDLINELOOP32:
|
return false;
|
case DRAW_TRIANGLELIST:
|
case DRAW_TRIANGLESTRIP:
|
case DRAW_TRIANGLEFAN:
|
case DRAW_INDEXEDTRIANGLELIST8:
|
case DRAW_INDEXEDTRIANGLESTRIP8:
|
case DRAW_INDEXEDTRIANGLEFAN8:
|
case DRAW_INDEXEDTRIANGLELIST16:
|
case DRAW_INDEXEDTRIANGLESTRIP16:
|
case DRAW_INDEXEDTRIANGLEFAN16:
|
case DRAW_INDEXEDTRIANGLELIST32:
|
case DRAW_INDEXEDTRIANGLESTRIP32:
|
case DRAW_INDEXEDTRIANGLEFAN32:
|
return fillModeAware ? fillMode == FILL_VERTEX : false;
|
case DRAW_QUADLIST:
|
return false;
|
default:
|
ASSERT(false);
|
}
|
|
return false;
|
}
|
|
bool Context::isDrawLine(bool fillModeAware) const
|
{
|
switch(drawType)
|
{
|
case DRAW_POINTLIST:
|
case DRAW_INDEXEDPOINTLIST8:
|
case DRAW_INDEXEDPOINTLIST16:
|
case DRAW_INDEXEDPOINTLIST32:
|
return false;
|
case DRAW_LINELIST:
|
case DRAW_LINESTRIP:
|
case DRAW_LINELOOP:
|
case DRAW_INDEXEDLINELIST8:
|
case DRAW_INDEXEDLINESTRIP8:
|
case DRAW_INDEXEDLINELOOP8:
|
case DRAW_INDEXEDLINELIST16:
|
case DRAW_INDEXEDLINESTRIP16:
|
case DRAW_INDEXEDLINELOOP16:
|
case DRAW_INDEXEDLINELIST32:
|
case DRAW_INDEXEDLINESTRIP32:
|
case DRAW_INDEXEDLINELOOP32:
|
return true;
|
case DRAW_TRIANGLELIST:
|
case DRAW_TRIANGLESTRIP:
|
case DRAW_TRIANGLEFAN:
|
case DRAW_INDEXEDTRIANGLELIST8:
|
case DRAW_INDEXEDTRIANGLESTRIP8:
|
case DRAW_INDEXEDTRIANGLEFAN8:
|
case DRAW_INDEXEDTRIANGLELIST16:
|
case DRAW_INDEXEDTRIANGLESTRIP16:
|
case DRAW_INDEXEDTRIANGLEFAN16:
|
case DRAW_INDEXEDTRIANGLELIST32:
|
case DRAW_INDEXEDTRIANGLESTRIP32:
|
case DRAW_INDEXEDTRIANGLEFAN32:
|
return fillModeAware ? fillMode == FILL_WIREFRAME : false;
|
case DRAW_QUADLIST:
|
return false;
|
default:
|
ASSERT(false);
|
}
|
|
return false;
|
}
|
|
bool Context::isDrawTriangle(bool fillModeAware) const
|
{
|
switch(drawType)
|
{
|
case DRAW_POINTLIST:
|
case DRAW_INDEXEDPOINTLIST8:
|
case DRAW_INDEXEDPOINTLIST16:
|
case DRAW_INDEXEDPOINTLIST32:
|
return false;
|
case DRAW_LINELIST:
|
case DRAW_LINESTRIP:
|
case DRAW_LINELOOP:
|
case DRAW_INDEXEDLINELIST8:
|
case DRAW_INDEXEDLINESTRIP8:
|
case DRAW_INDEXEDLINELOOP8:
|
case DRAW_INDEXEDLINELIST16:
|
case DRAW_INDEXEDLINESTRIP16:
|
case DRAW_INDEXEDLINELOOP16:
|
case DRAW_INDEXEDLINELIST32:
|
case DRAW_INDEXEDLINESTRIP32:
|
case DRAW_INDEXEDLINELOOP32:
|
return false;
|
case DRAW_TRIANGLELIST:
|
case DRAW_TRIANGLESTRIP:
|
case DRAW_TRIANGLEFAN:
|
case DRAW_INDEXEDTRIANGLELIST8:
|
case DRAW_INDEXEDTRIANGLESTRIP8:
|
case DRAW_INDEXEDTRIANGLEFAN8:
|
case DRAW_INDEXEDTRIANGLELIST16:
|
case DRAW_INDEXEDTRIANGLESTRIP16:
|
case DRAW_INDEXEDTRIANGLEFAN16:
|
case DRAW_INDEXEDTRIANGLELIST32:
|
case DRAW_INDEXEDTRIANGLESTRIP32:
|
case DRAW_INDEXEDTRIANGLEFAN32:
|
return fillModeAware ? fillMode == FILL_SOLID : true;
|
case DRAW_QUADLIST:
|
// Quads are broken up into triangles
|
return fillModeAware ? fillMode == FILL_SOLID : true;
|
default:
|
ASSERT(false);
|
}
|
|
return true;
|
}
|
|
void Context::init()
|
{
|
for(int i = 0; i < 8; i++)
|
{
|
textureStage[i].init(i, &sampler[i], (i >= 1) ? &textureStage[i - 1] : 0);
|
}
|
|
// Set vertex streams to null stream
|
for(int i = 0; i < MAX_VERTEX_INPUTS; i++)
|
{
|
input[i].defaults();
|
}
|
|
fogStart = 0.0f;
|
fogEnd = 1.0f;
|
|
for(int i = 0; i < TEXTURE_IMAGE_UNITS; i++) textureWrap[i] = 0;
|
for(int i = 0; i < 8; i++) texGen[i] = TEXGEN_PASSTHRU;
|
for(int i = 0; i < 8; i++) textureTransformCount[i] = 0;
|
for(int i = 0; i < 8; i++) textureTransformProject[i] = false;
|
textureWrapActive = false;
|
localViewer = true;
|
normalizeNormals = false;
|
|
for(int i = 0; i < RENDERTARGETS; ++i)
|
{
|
renderTarget[i] = nullptr;
|
}
|
depthBuffer = nullptr;
|
stencilBuffer = nullptr;
|
|
stencilEnable = false;
|
stencilCompareMode = STENCIL_ALWAYS;
|
stencilReference = 0;
|
stencilMask = 0xFFFFFFFF;
|
stencilFailOperation = OPERATION_KEEP;
|
stencilPassOperation = OPERATION_KEEP;
|
stencilZFailOperation = OPERATION_KEEP;
|
stencilWriteMask = 0xFFFFFFFF;
|
|
twoSidedStencil = false;
|
stencilCompareModeCCW = STENCIL_ALWAYS;
|
stencilReferenceCCW = 0;
|
stencilMaskCCW = 0xFFFFFFFF;
|
stencilFailOperationCCW = OPERATION_KEEP;
|
stencilPassOperationCCW = OPERATION_KEEP;
|
stencilZFailOperationCCW = OPERATION_KEEP;
|
stencilWriteMaskCCW = 0xFFFFFFFF;
|
|
setGlobalMipmapBias(0);
|
|
lightingEnable = true;
|
specularEnable = false;
|
for(int i = 0; i < 8; i++) lightEnable[i] = false;
|
for(int i = 0; i < 8; i++) worldLightPosition[i] = 0;
|
|
alphaCompareMode = ALPHA_ALWAYS;
|
alphaTestEnable = false;
|
fillMode = FILL_SOLID;
|
shadingMode = SHADING_GOURAUD;
|
|
rasterizerDiscard = false;
|
|
depthCompareMode = DEPTH_LESS;
|
depthBufferEnable = true;
|
depthWriteEnable = true;
|
|
alphaBlendEnable = false;
|
sourceBlendFactorState = BLEND_ONE;
|
destBlendFactorState = BLEND_ZERO;
|
blendOperationState = BLENDOP_ADD;
|
|
separateAlphaBlendEnable = false;
|
sourceBlendFactorStateAlpha = BLEND_ONE;
|
destBlendFactorStateAlpha = BLEND_ZERO;
|
blendOperationStateAlpha = BLENDOP_ADD;
|
|
cullMode = CULL_CLOCKWISE;
|
frontFacingCCW = true;
|
alphaReference = 0.0f;
|
|
depthBias = 0.0f;
|
slopeDepthBias = 0.0f;
|
|
for(int i = 0; i < RENDERTARGETS; i++)
|
{
|
colorWriteMask[i] = 0x0000000F;
|
}
|
|
ambientMaterialSource = MATERIAL_MATERIAL;
|
diffuseMaterialSource = MATERIAL_COLOR1;
|
specularMaterialSource = MATERIAL_COLOR2;
|
emissiveMaterialSource = MATERIAL_MATERIAL;
|
colorVertexEnable = true;
|
|
fogEnable = false;
|
pixelFogMode = FOG_NONE;
|
vertexFogMode = FOG_NONE;
|
wBasedFog = false;
|
rangeFogEnable = false;
|
|
indexedVertexBlendEnable = false;
|
vertexBlendMatrixCount = 0;
|
|
pixelShader = 0;
|
vertexShader = 0;
|
|
instanceID = 0;
|
|
occlusionEnabled = false;
|
transformFeedbackQueryEnabled = false;
|
transformFeedbackEnabled = 0;
|
|
pointSpriteEnable = false;
|
pointScaleEnable = false;
|
lineWidth = 1.0f;
|
|
writeSRGB = false;
|
sampleMask = 0xFFFFFFFF;
|
|
colorLogicOpEnabled = false;
|
logicalOperation = LOGICALOP_COPY;
|
}
|
|
const float &Context::exp2Bias()
|
{
|
return bias;
|
}
|
|
const Point &Context::getLightPosition(int light)
|
{
|
return worldLightPosition[light];
|
}
|
|
void Context::setGlobalMipmapBias(float bias)
|
{
|
this->bias = exp2(bias + 0.5f);
|
}
|
|
void Context::setLightingEnable(bool lightingEnable)
|
{
|
this->lightingEnable = lightingEnable;
|
}
|
|
void Context::setSpecularEnable(bool specularEnable)
|
{
|
Context::specularEnable = specularEnable;
|
}
|
|
void Context::setLightEnable(int light, bool lightEnable)
|
{
|
Context::lightEnable[light] = lightEnable;
|
}
|
|
void Context::setLightPosition(int light, Point worldLightPosition)
|
{
|
Context::worldLightPosition[light] = worldLightPosition;
|
}
|
|
void Context::setAmbientMaterialSource(MaterialSource ambientMaterialSource)
|
{
|
Context::ambientMaterialSource = ambientMaterialSource;
|
}
|
|
void Context::setDiffuseMaterialSource(MaterialSource diffuseMaterialSource)
|
{
|
Context::diffuseMaterialSource = diffuseMaterialSource;
|
}
|
|
void Context::setSpecularMaterialSource(MaterialSource specularMaterialSource)
|
{
|
Context::specularMaterialSource = specularMaterialSource;
|
}
|
|
void Context::setEmissiveMaterialSource(MaterialSource emissiveMaterialSource)
|
{
|
Context::emissiveMaterialSource = emissiveMaterialSource;
|
}
|
|
void Context::setPointSpriteEnable(bool pointSpriteEnable)
|
{
|
Context::pointSpriteEnable = pointSpriteEnable;
|
}
|
|
void Context::setPointScaleEnable(bool pointScaleEnable)
|
{
|
Context::pointScaleEnable = pointScaleEnable;
|
}
|
|
bool Context::setDepthBufferEnable(bool depthBufferEnable)
|
{
|
bool modified = (Context::depthBufferEnable != depthBufferEnable);
|
Context::depthBufferEnable = depthBufferEnable;
|
return modified;
|
}
|
|
bool Context::setAlphaBlendEnable(bool alphaBlendEnable)
|
{
|
bool modified = (Context::alphaBlendEnable != alphaBlendEnable);
|
Context::alphaBlendEnable = alphaBlendEnable;
|
return modified;
|
}
|
|
bool Context::setSourceBlendFactor(BlendFactor sourceBlendFactor)
|
{
|
bool modified = (Context::sourceBlendFactorState != sourceBlendFactor);
|
Context::sourceBlendFactorState = sourceBlendFactor;
|
return modified;
|
}
|
|
bool Context::setDestBlendFactor(BlendFactor destBlendFactor)
|
{
|
bool modified = (Context::destBlendFactorState != destBlendFactor);
|
Context::destBlendFactorState = destBlendFactor;
|
return modified;
|
}
|
|
bool Context::setBlendOperation(BlendOperation blendOperation)
|
{
|
bool modified = (Context::blendOperationState != blendOperation);
|
Context::blendOperationState = blendOperation;
|
return modified;
|
}
|
|
bool Context::setSeparateAlphaBlendEnable(bool separateAlphaBlendEnable)
|
{
|
bool modified = (Context::separateAlphaBlendEnable != separateAlphaBlendEnable);
|
Context::separateAlphaBlendEnable = separateAlphaBlendEnable;
|
return modified;
|
}
|
|
bool Context::setSourceBlendFactorAlpha(BlendFactor sourceBlendFactorAlpha)
|
{
|
bool modified = (Context::sourceBlendFactorStateAlpha != sourceBlendFactorAlpha);
|
Context::sourceBlendFactorStateAlpha = sourceBlendFactorAlpha;
|
return modified;
|
}
|
|
bool Context::setDestBlendFactorAlpha(BlendFactor destBlendFactorAlpha)
|
{
|
bool modified = (Context::destBlendFactorStateAlpha != destBlendFactorAlpha);
|
Context::destBlendFactorStateAlpha = destBlendFactorAlpha;
|
return modified;
|
}
|
|
bool Context::setBlendOperationAlpha(BlendOperation blendOperationAlpha)
|
{
|
bool modified = (Context::blendOperationStateAlpha != blendOperationAlpha);
|
Context::blendOperationStateAlpha = blendOperationAlpha;
|
return modified;
|
}
|
|
bool Context::setColorWriteMask(int index, int colorWriteMask)
|
{
|
bool modified = (Context::colorWriteMask[index] != colorWriteMask);
|
Context::colorWriteMask[index] = colorWriteMask;
|
return modified;
|
}
|
|
bool Context::setWriteSRGB(bool sRGB)
|
{
|
bool modified = (Context::writeSRGB != sRGB);
|
Context::writeSRGB = sRGB;
|
return modified;
|
}
|
|
bool Context::setColorLogicOpEnabled(bool enabled)
|
{
|
bool modified = (Context::colorLogicOpEnabled != enabled);
|
Context::colorLogicOpEnabled = enabled;
|
return modified;
|
}
|
|
bool Context::setLogicalOperation(LogicalOperation logicalOperation)
|
{
|
bool modified = (Context::logicalOperation != logicalOperation);
|
Context::logicalOperation = logicalOperation;
|
return modified;
|
}
|
|
void Context::setColorVertexEnable(bool colorVertexEnable)
|
{
|
Context::colorVertexEnable = colorVertexEnable;
|
}
|
|
bool Context::fogActive()
|
{
|
if(!colorUsed()) return false;
|
|
if(pixelShaderModel() >= 0x0300) return false;
|
|
return fogEnable;
|
}
|
|
bool Context::pointSizeActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return isDrawPoint(true) && (input[PointSize] || (!preTransformed && pointScaleActive()));
|
}
|
|
FogMode Context::pixelFogActive()
|
{
|
if(fogActive())
|
{
|
return pixelFogMode;
|
}
|
|
return FOG_NONE;
|
}
|
|
bool Context::depthWriteActive()
|
{
|
if(!depthBufferActive()) return false;
|
|
return depthWriteEnable;
|
}
|
|
bool Context::alphaTestActive()
|
{
|
if(transparencyAntialiasing != TRANSPARENCY_NONE) return true;
|
if(!alphaTestEnable) return false;
|
if(alphaCompareMode == ALPHA_ALWAYS) return false;
|
if(alphaReference == 0.0f && alphaCompareMode == ALPHA_GREATEREQUAL) return false;
|
|
return true;
|
}
|
|
bool Context::depthBufferActive()
|
{
|
return depthBuffer && depthBufferEnable;
|
}
|
|
bool Context::stencilActive()
|
{
|
return stencilBuffer && stencilEnable;
|
}
|
|
bool Context::vertexLightingActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return lightingEnable && !preTransformed;
|
}
|
|
bool Context::texCoordActive(int coordinate, int component)
|
{
|
bool hasTexture = pointSpriteActive();
|
|
if(vertexShader)
|
{
|
if(!preTransformed)
|
{
|
if(vertexShader->getOutput(T0 + coordinate, component).usage == Shader::USAGE_TEXCOORD)
|
{
|
hasTexture = true;
|
}
|
}
|
else
|
{
|
hasTexture = true; // FIXME: Check vertex buffer streams
|
}
|
}
|
else
|
{
|
switch(texGen[coordinate])
|
{
|
case TEXGEN_NONE:
|
hasTexture = true;
|
break;
|
case TEXGEN_PASSTHRU:
|
hasTexture = hasTexture || (component < input[TexCoord0 + textureStage[coordinate].texCoordIndex].count);
|
break;
|
case TEXGEN_NORMAL:
|
hasTexture = hasTexture || (component <= 2);
|
break;
|
case TEXGEN_POSITION:
|
hasTexture = hasTexture || (component <= 2);
|
break;
|
case TEXGEN_REFLECTION:
|
hasTexture = hasTexture || (component <= 2);
|
break;
|
case TEXGEN_SPHEREMAP:
|
hasTexture = hasTexture || (component <= 1);
|
break;
|
default:
|
ASSERT(false);
|
}
|
}
|
|
bool project = isProjectionComponent(coordinate, component);
|
bool usesTexture = false;
|
|
if(pixelShader)
|
{
|
usesTexture = pixelShader->usesTexture(coordinate, component) || project;
|
}
|
else
|
{
|
usesTexture = textureStage[coordinate].usesTexture() || project;
|
}
|
|
return hasTexture && usesTexture;
|
}
|
|
bool Context::texCoordActive(int coordinate)
|
{
|
return texCoordActive(coordinate, 0) ||
|
texCoordActive(coordinate, 1) ||
|
texCoordActive(coordinate, 2) ||
|
texCoordActive(coordinate, 3);
|
}
|
|
bool Context::isProjectionComponent(unsigned int coordinate, int component)
|
{
|
if(pixelShaderModel() <= 0x0103 && coordinate < 8 && textureTransformProject[coordinate])
|
{
|
if(textureTransformCount[coordinate] == 2)
|
{
|
if(component == 1) return true;
|
}
|
else if(textureTransformCount[coordinate] == 3)
|
{
|
if(component == 2) return true;
|
}
|
else if(textureTransformCount[coordinate] == 4 || textureTransformCount[coordinate] == 0)
|
{
|
if(component == 3) return true;
|
}
|
}
|
|
return false;
|
}
|
|
bool Context::vertexSpecularActive()
|
{
|
return vertexLightingActive() && specularEnable && vertexNormalActive();
|
}
|
|
bool Context::vertexNormalActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return input[Normal];
|
}
|
|
bool Context::vertexLightActive(int i)
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return lightingEnable && lightEnable[i];
|
}
|
|
MaterialSource Context::vertexDiffuseMaterialSourceActive()
|
{
|
if(vertexShader)
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
if(diffuseMaterialSource == MATERIAL_MATERIAL || !colorVertexEnable ||
|
(diffuseMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
|
(diffuseMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
return diffuseMaterialSource;
|
}
|
|
MaterialSource Context::vertexSpecularMaterialSourceActive()
|
{
|
if(vertexShader)
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
if(!colorVertexEnable ||
|
(specularMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
|
(specularMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
return specularMaterialSource;
|
}
|
|
MaterialSource Context::vertexAmbientMaterialSourceActive()
|
{
|
if(vertexShader)
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
if(!colorVertexEnable ||
|
(ambientMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
|
(ambientMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
return ambientMaterialSource;
|
}
|
|
MaterialSource Context::vertexEmissiveMaterialSourceActive()
|
{
|
if(vertexShader)
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
if(!colorVertexEnable ||
|
(emissiveMaterialSource == MATERIAL_COLOR1 && !input[Color0]) ||
|
(emissiveMaterialSource == MATERIAL_COLOR2 && !input[Color1]))
|
{
|
return MATERIAL_MATERIAL;
|
}
|
|
return emissiveMaterialSource;
|
}
|
|
bool Context::pointSpriteActive()
|
{
|
return isDrawPoint(true) && pointSpriteEnable;
|
}
|
|
bool Context::pointScaleActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return isDrawPoint(true) && pointScaleEnable;
|
}
|
|
bool Context::alphaBlendActive()
|
{
|
if(!alphaBlendEnable)
|
{
|
return false;
|
}
|
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
bool colorBlend = !(blendOperation() == BLENDOP_SOURCE && sourceBlendFactor() == BLEND_ONE);
|
bool alphaBlend = separateAlphaBlendEnable ? !(blendOperationAlpha() == BLENDOP_SOURCE && sourceBlendFactorAlpha() == BLEND_ONE) : colorBlend;
|
|
return colorBlend || alphaBlend;
|
}
|
|
LogicalOperation Context::colorLogicOp()
|
{
|
return colorLogicOpEnabled ? logicalOperation : LOGICALOP_COPY;
|
}
|
|
BlendFactor Context::sourceBlendFactor()
|
{
|
if(!alphaBlendEnable) return BLEND_ONE;
|
|
switch(blendOperationState)
|
{
|
case BLENDOP_ADD:
|
case BLENDOP_SUB:
|
case BLENDOP_INVSUB:
|
return sourceBlendFactorState;
|
case BLENDOP_MIN:
|
return BLEND_ONE;
|
case BLENDOP_MAX:
|
return BLEND_ONE;
|
default:
|
ASSERT(false);
|
}
|
|
return sourceBlendFactorState;
|
}
|
|
BlendFactor Context::destBlendFactor()
|
{
|
if(!alphaBlendEnable) return BLEND_ZERO;
|
|
switch(blendOperationState)
|
{
|
case BLENDOP_ADD:
|
case BLENDOP_SUB:
|
case BLENDOP_INVSUB:
|
return destBlendFactorState;
|
case BLENDOP_MIN:
|
return BLEND_ONE;
|
case BLENDOP_MAX:
|
return BLEND_ONE;
|
default:
|
ASSERT(false);
|
}
|
|
return destBlendFactorState;
|
}
|
|
BlendOperation Context::blendOperation()
|
{
|
if(!alphaBlendEnable) return BLENDOP_SOURCE;
|
|
switch(blendOperationState)
|
{
|
case BLENDOP_ADD:
|
if(sourceBlendFactor() == BLEND_ZERO)
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL;
|
}
|
else
|
{
|
return BLENDOP_DEST;
|
}
|
}
|
else if(sourceBlendFactor() == BLEND_ONE)
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_ADD;
|
}
|
}
|
else
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_ADD;
|
}
|
}
|
case BLENDOP_SUB:
|
if(sourceBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else if(sourceBlendFactor() == BLEND_ONE)
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_SUB;
|
}
|
}
|
else
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_SUB;
|
}
|
}
|
case BLENDOP_INVSUB:
|
if(sourceBlendFactor() == BLEND_ZERO)
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL;
|
}
|
else
|
{
|
return BLENDOP_DEST;
|
}
|
}
|
else if(sourceBlendFactor() == BLEND_ONE)
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else
|
{
|
return BLENDOP_INVSUB;
|
}
|
}
|
else
|
{
|
if(destBlendFactor() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else
|
{
|
return BLENDOP_INVSUB;
|
}
|
}
|
case BLENDOP_MIN:
|
return BLENDOP_MIN;
|
case BLENDOP_MAX:
|
return BLENDOP_MAX;
|
default:
|
ASSERT(false);
|
}
|
|
return blendOperationState;
|
}
|
|
BlendFactor Context::sourceBlendFactorAlpha()
|
{
|
if(!separateAlphaBlendEnable)
|
{
|
return sourceBlendFactor();
|
}
|
else
|
{
|
switch(blendOperationStateAlpha)
|
{
|
case BLENDOP_ADD:
|
case BLENDOP_SUB:
|
case BLENDOP_INVSUB:
|
return sourceBlendFactorStateAlpha;
|
case BLENDOP_MIN:
|
return BLEND_ONE;
|
case BLENDOP_MAX:
|
return BLEND_ONE;
|
default:
|
ASSERT(false);
|
}
|
|
return sourceBlendFactorStateAlpha;
|
}
|
}
|
|
BlendFactor Context::destBlendFactorAlpha()
|
{
|
if(!separateAlphaBlendEnable)
|
{
|
return destBlendFactor();
|
}
|
else
|
{
|
switch(blendOperationStateAlpha)
|
{
|
case BLENDOP_ADD:
|
case BLENDOP_SUB:
|
case BLENDOP_INVSUB:
|
return destBlendFactorStateAlpha;
|
case BLENDOP_MIN:
|
return BLEND_ONE;
|
case BLENDOP_MAX:
|
return BLEND_ONE;
|
default:
|
ASSERT(false);
|
}
|
|
return destBlendFactorStateAlpha;
|
}
|
}
|
|
BlendOperation Context::blendOperationAlpha()
|
{
|
if(!separateAlphaBlendEnable)
|
{
|
return blendOperation();
|
}
|
else
|
{
|
switch(blendOperationStateAlpha)
|
{
|
case BLENDOP_ADD:
|
if(sourceBlendFactorAlpha() == BLEND_ZERO)
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL;
|
}
|
else
|
{
|
return BLENDOP_DEST;
|
}
|
}
|
else if(sourceBlendFactorAlpha() == BLEND_ONE)
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_ADD;
|
}
|
}
|
else
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_ADD;
|
}
|
}
|
case BLENDOP_SUB:
|
if(sourceBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else if(sourceBlendFactorAlpha() == BLEND_ONE)
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_SUB;
|
}
|
}
|
else
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_SOURCE;
|
}
|
else
|
{
|
return BLENDOP_SUB;
|
}
|
}
|
case BLENDOP_INVSUB:
|
if(sourceBlendFactorAlpha() == BLEND_ZERO)
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL;
|
}
|
else
|
{
|
return BLENDOP_DEST;
|
}
|
}
|
else if(sourceBlendFactorAlpha() == BLEND_ONE)
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else
|
{
|
return BLENDOP_INVSUB;
|
}
|
}
|
else
|
{
|
if(destBlendFactorAlpha() == BLEND_ZERO)
|
{
|
return BLENDOP_NULL; // Negative, clamped to zero
|
}
|
else
|
{
|
return BLENDOP_INVSUB;
|
}
|
}
|
case BLENDOP_MIN:
|
return BLENDOP_MIN;
|
case BLENDOP_MAX:
|
return BLENDOP_MAX;
|
default:
|
ASSERT(false);
|
}
|
|
return blendOperationStateAlpha;
|
}
|
}
|
|
bool Context::indexedVertexBlendActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return indexedVertexBlendEnable;
|
}
|
|
int Context::vertexBlendMatrixCountActive()
|
{
|
if(vertexShader)
|
{
|
return 0;
|
}
|
|
return vertexBlendMatrixCount;
|
}
|
|
bool Context::localViewerActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return localViewer;
|
}
|
|
bool Context::normalizeNormalsActive()
|
{
|
if(vertexShader)
|
{
|
return false;
|
}
|
|
return normalizeNormals;
|
}
|
|
FogMode Context::vertexFogModeActive()
|
{
|
if(vertexShader || !fogActive())
|
{
|
return FOG_NONE;
|
}
|
|
return vertexFogMode;
|
}
|
|
bool Context::rangeFogActive()
|
{
|
if(vertexShader || !fogActive())
|
{
|
return false;
|
}
|
|
return rangeFogEnable;
|
}
|
|
TexGen Context::texGenActive(int stage)
|
{
|
if(vertexShader || !texCoordActive(stage))
|
{
|
return TEXGEN_PASSTHRU;
|
}
|
|
return texGen[stage];
|
}
|
|
int Context::textureTransformCountActive(int stage)
|
{
|
if(vertexShader || !texCoordActive(stage))
|
{
|
return 0;
|
}
|
|
return textureTransformCount[stage];
|
}
|
|
int Context::texCoordIndexActive(int stage)
|
{
|
if(vertexShader || !texCoordActive(stage))
|
{
|
return stage;
|
}
|
|
return textureStage[stage].texCoordIndex;
|
}
|
|
bool Context::perspectiveActive()
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
if(!perspectiveCorrection)
|
{
|
return false;
|
}
|
|
if(isDrawPoint(true))
|
{
|
return false;
|
}
|
|
return true;
|
}
|
|
bool Context::diffuseUsed()
|
{
|
return diffuseUsed(0) || diffuseUsed(1) || diffuseUsed(2) || diffuseUsed(3);
|
}
|
|
bool Context::diffuseUsed(int component)
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
if(pixelShader)
|
{
|
return pixelShader->usesDiffuse(component);
|
}
|
|
// Directly using the diffuse input color
|
for(int i = 0; i < 8; i++)
|
{
|
if(textureStage[i].isStageDisabled())
|
{
|
break;
|
}
|
|
if(textureStage[i].usesDiffuse())
|
{
|
return true;
|
}
|
}
|
|
// Using the current color (initialized to diffuse) before it's overwritten
|
for(int i = 0; i < 8; i++)
|
{
|
if(textureStage[i].usesCurrent() || textureStage[i].isStageDisabled()) // Current color contains diffuse before being overwritten
|
{
|
return true;
|
}
|
|
if(textureStage[i].writesCurrent())
|
{
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
bool Context::diffuseActive()
|
{
|
return diffuseActive(0) || diffuseActive(1) || diffuseActive(2) || diffuseActive(3);
|
}
|
|
bool Context::diffuseActive(int component)
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
// Vertex processor provides diffuse component
|
bool vertexDiffuse;
|
|
if(vertexShader)
|
{
|
vertexDiffuse = vertexShader->getOutput(C0, component).active();
|
}
|
else if(!preTransformed)
|
{
|
vertexDiffuse = input[Color0] || lightingEnable;
|
}
|
else
|
{
|
vertexDiffuse = input[Color0];
|
}
|
|
// Pixel processor requires diffuse component
|
bool pixelDiffuse = diffuseUsed(component);
|
|
return vertexDiffuse && pixelDiffuse;
|
}
|
|
bool Context::specularUsed()
|
{
|
return Context::specularUsed(0) || Context::specularUsed(1) || Context::specularUsed(2) || Context::specularUsed(3);
|
}
|
|
bool Context::specularUsed(int component)
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
if(pixelShader)
|
{
|
return pixelShader->usesSpecular(component);
|
}
|
|
bool pixelSpecular = specularEnable;
|
|
for(int i = 0; i < 8; i++)
|
{
|
if(textureStage[i].isStageDisabled()) break;
|
|
pixelSpecular = pixelSpecular || textureStage[i].usesSpecular();
|
}
|
|
return pixelSpecular;
|
}
|
|
bool Context::specularActive()
|
{
|
return specularActive(0) || specularActive(1) || specularActive(2) || specularActive(3);
|
}
|
|
bool Context::specularActive(int component)
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
// Vertex processor provides specular component
|
bool vertexSpecular;
|
|
if(!vertexShader)
|
{
|
vertexSpecular = input[Color1] || (lightingEnable && specularEnable);
|
}
|
else
|
{
|
vertexSpecular = vertexShader->getOutput(C1, component).active();
|
}
|
|
// Pixel processor requires specular component
|
bool pixelSpecular = specularUsed(component);
|
|
return vertexSpecular && pixelSpecular;
|
}
|
|
bool Context::colorActive(int color, int component)
|
{
|
if(color == 0)
|
{
|
return diffuseActive(component);
|
}
|
else
|
{
|
return specularActive(component);
|
}
|
}
|
|
bool Context::textureActive()
|
{
|
for(int i = 0; i < 8; i++)
|
{
|
if(textureActive(i))
|
{
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
bool Context::textureActive(int coordinate)
|
{
|
return textureActive(coordinate, 0) || textureActive(coordinate, 1) || textureActive(coordinate, 2) || textureActive(coordinate, 3);
|
}
|
|
bool Context::textureActive(int coordinate, int component)
|
{
|
if(!colorUsed())
|
{
|
return false;
|
}
|
|
if(!texCoordActive(coordinate, component))
|
{
|
return false;
|
}
|
|
if(textureTransformProject[coordinate] && pixelShaderModel() <= 0x0103)
|
{
|
if(textureTransformCount[coordinate] == 2)
|
{
|
if(component == 1) return true;
|
}
|
else if(textureTransformCount[coordinate] == 3)
|
{
|
if(component == 2) return true;
|
}
|
else if(textureTransformCount[coordinate] == 4 || textureTransformCount[coordinate] == 0)
|
{
|
if(component == 3) return true;
|
}
|
}
|
|
if(!pixelShader)
|
{
|
bool texture = textureStage[coordinate].usesTexture();
|
bool cube = sampler[coordinate].hasCubeTexture();
|
bool volume = sampler[coordinate].hasVolumeTexture();
|
|
if(texture)
|
{
|
for(int i = coordinate; i >= 0; i--)
|
{
|
if(textureStage[i].stageOperation == TextureStage::STAGE_DISABLE)
|
{
|
return false;
|
}
|
}
|
}
|
|
switch(component)
|
{
|
case 0:
|
return texture;
|
case 1:
|
return texture;
|
case 2:
|
return (texture && (cube || volume));
|
case 3:
|
return false;
|
}
|
}
|
else
|
{
|
return pixelShader->usesTexture(coordinate, component);
|
}
|
|
return false;
|
}
|
|
unsigned short Context::pixelShaderModel() const
|
{
|
return pixelShader ? pixelShader->getShaderModel() : 0x0000;
|
}
|
|
unsigned short Context::vertexShaderModel() const
|
{
|
return vertexShader ? vertexShader->getShaderModel() : 0x0000;
|
}
|
|
int Context::getMultiSampleCount() const
|
{
|
return renderTarget[0] ? renderTarget[0]->getMultiSampleCount() : 1;
|
}
|
|
int Context::getSuperSampleCount() const
|
{
|
return renderTarget[0] ? renderTarget[0]->getSuperSampleCount() : 1;
|
}
|
|
Format Context::renderTargetInternalFormat(int index)
|
{
|
if(renderTarget[index])
|
{
|
return renderTarget[index]->getInternalFormat();
|
}
|
else
|
{
|
return FORMAT_NULL;
|
}
|
}
|
|
bool Context::colorWriteActive()
|
{
|
for (int i = 0; i < RENDERTARGETS; i++)
|
{
|
if (colorWriteActive(i))
|
{
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
int Context::colorWriteActive(int index)
|
{
|
if(!renderTarget[index] || renderTarget[index]->getInternalFormat() == FORMAT_NULL)
|
{
|
return 0;
|
}
|
|
if(blendOperation() == BLENDOP_DEST && destBlendFactor() == BLEND_ONE &&
|
(!separateAlphaBlendEnable || (blendOperationAlpha() == BLENDOP_DEST && destBlendFactorAlpha() == BLEND_ONE)))
|
{
|
return 0;
|
}
|
|
return colorWriteMask[index];
|
}
|
|
bool Context::colorUsed()
|
{
|
return colorWriteActive() || alphaTestActive() || (pixelShader && pixelShader->containsKill());
|
}
|
}
|
