mSampleStateDirty = true;\r
mDitherStateDirty = true;\r
mFrontFaceDirty = true;\r
+ mColorLogicOperatorDirty = true;\r
}\r
\r
void Context::setClearColor(float red, float green, float blue, float alpha)\r
\r
void Context::setLogicalOperation(GLenum logicalOperation)\r
{\r
- mState.logicalOperation = logicalOperation;\r
+ if(mState.logicalOperation != logicalOperation)\r
+ {\r
+ mState.logicalOperation = logicalOperation;\r
+ mColorLogicOperatorDirty = true;\r
+ }\r
}\r
\r
void Context::setColorMaterialEnabled(bool enable)\r
{\r
switch(logicalOperation)\r
{\r
- case GL_CLEAR: return sw::LOGICALOP_CLEAR;\r
- case GL_SET: return sw::LOGICALOP_SET;\r
- case GL_COPY: return sw::LOGICALOP_COPY;\r
- case GL_COPY_INVERTED: return sw::LOGICALOP_COPY_INVERTED;\r
- case GL_NOOP: return sw::LOGICALOP_NOOP;\r
- case GL_INVERT: return sw::LOGICALOP_INVERT;\r
- case GL_AND: return sw::LOGICALOP_AND;\r
- case GL_NAND: return sw::LOGICALOP_NAND;\r
- case GL_OR: return sw::LOGICALOP_OR;\r
- case GL_NOR: return sw::LOGICALOP_NOR;\r
- case GL_XOR: return sw::LOGICALOP_XOR;\r
- case GL_EQUIV: return sw::LOGICALOP_EQUIV;\r
- case GL_AND_REVERSE: return sw::LOGICALOP_AND_REVERSE;\r
- case GL_AND_INVERTED: return sw::LOGICALOP_AND_INVERTED;\r
- case GL_OR_REVERSE: return sw::LOGICALOP_OR_REVERSE;\r
- case GL_OR_INVERTED: return sw::LOGICALOP_OR_INVERTED;\r
+ case GL_CLEAR: return sw::LOGICALOP_CLEAR;\r
+ case GL_SET: return sw::LOGICALOP_SET;\r
+ case GL_COPY: return sw::LOGICALOP_COPY;\r
+ case GL_COPY_INVERTED: return sw::LOGICALOP_COPY_INVERTED;\r
+ case GL_NOOP: return sw::LOGICALOP_NOOP;\r
+ case GL_INVERT: return sw::LOGICALOP_INVERT;\r
+ case GL_AND: return sw::LOGICALOP_AND;\r
+ case GL_NAND: return sw::LOGICALOP_NAND;\r
+ case GL_OR: return sw::LOGICALOP_OR;\r
+ case GL_NOR: return sw::LOGICALOP_NOR;\r
+ case GL_XOR: return sw::LOGICALOP_XOR;\r
+ case GL_EQUIV: return sw::LOGICALOP_EQUIV;\r
+ case GL_AND_REVERSE: return sw::LOGICALOP_AND_REVERSE;\r
+ case GL_AND_INVERTED: return sw::LOGICALOP_AND_INVERTED;\r
+ case GL_OR_REVERSE: return sw::LOGICALOP_OR_REVERSE;\r
+ case GL_OR_INVERTED: return sw::LOGICALOP_OR_INVERTED;\r
default: UNREACHABLE(logicalOperation);\r
}\r
\r
mState.shadeModel = GL_SMOOTH;\r
mState.generateMipmapHint = GL_DONT_CARE;\r
mState.perspectiveCorrectionHint = GL_DONT_CARE;\r
- mState.colorLogicOpEnabled = false;\r
- mState.logicalOperation = GL_COPY;\r
+ mState.fogHint = GL_DONT_CARE;\r
\r
mState.lineWidth = 1.0f;\r
\r
light[i].position = {0.0f, 0.0f, 1.0f, 0.0f};\r
light[i].direction = {0.0f, 0.0f, -1.0f};\r
light[i].attenuation = {1.0f, 0.0f, 0.0f};\r
+ light[i].spotExponent = 0.0f;\r
+ light[i].spotCutoffAngle = 180.0f;\r
}\r
\r
light[0].diffuse = {1.0f, 1.0f, 1.0f, 1.0f};\r
materialSpecular = {0.0f, 0.0f, 0.0f, 1.0f};\r
materialEmission = {0.0f, 0.0f, 0.0f, 1.0f};\r
materialShininess = 0.0f;\r
+ lightModelTwoSide = false;\r
\r
matrixMode = GL_MODELVIEW;\r
\r
alphaTestFunc = GL_ALWAYS;\r
alphaTestRef = 0;\r
\r
+ fogEnabled = false;\r
+ fogMode = GL_EXP;\r
+ fogDensity = 1.0f;\r
+ fogStart = 0.0f;\r
+ fogEnd = 1.0f;\r
+ fogColor = {0, 0, 0, 0};\r
+\r
+ lineSmoothEnabled = false;\r
+ colorMaterialEnabled = false;\r
+ normalizeEnabled = false;\r
+ rescaleNormalEnabled = false;\r
+ multisampleEnabled = true;\r
+ sampleAlphaToOneEnabled = false;\r
+\r
+ colorLogicOpEnabled = false;\r
+ logicalOperation = GL_COPY;\r
+\r
+ pointSpriteEnabled = false;\r
+ pointSmoothEnabled = false;\r
+ pointSizeMin = 0.0f;\r
+ pointSizeMax = 1.0f;\r
+ pointDistanceAttenuation = {1.0f, 0.0f, 0.0f};\r
+ pointFadeThresholdSize = 1.0f;\r
+\r
mHasBeenCurrent = false;\r
\r
markAllStateDirty();\r
void Context::setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask)\r
{\r
if(mState.stencilFunc != stencilFunc ||\r
- mState.stencilRef != stencilRef ||\r
- mState.stencilMask != stencilMask)\r
+ mState.stencilRef != stencilRef ||\r
+ mState.stencilMask != stencilMask)\r
{\r
mState.stencilFunc = stencilFunc;\r
mState.stencilRef = (stencilRef > 0) ? stencilRef : 0;\r
void Context::setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass)\r
{\r
if(mState.stencilFail != stencilFail ||\r
- mState.stencilPassDepthFail != stencilPassDepthFail ||\r
- mState.stencilPassDepthPass != stencilPassDepthPass)\r
+ mState.stencilPassDepthFail != stencilPassDepthFail ||\r
+ mState.stencilPassDepthPass != stencilPassDepthPass)\r
{\r
mState.stencilFail = stencilFail;\r
mState.stencilPassDepthFail = stencilPassDepthFail;\r
void Context::setPolygonOffsetParams(GLfloat factor, GLfloat units)\r
{\r
if(mState.polygonOffsetFactor != factor ||\r
- mState.polygonOffsetUnits != units)\r
+ mState.polygonOffsetUnits != units)\r
{\r
mState.polygonOffsetFactor = factor;\r
mState.polygonOffsetUnits = units;\r
lightingEnabled = enable;\r
}\r
\r
+bool Context::isLightingEnabled() const\r
+{\r
+ return lightingEnabled;\r
+}\r
+\r
void Context::setLightEnabled(int index, bool enable)\r
{\r
light[index].enabled = enable;\r
}\r
\r
+bool Context::isLightEnabled(int index) const\r
+{\r
+ return light[index].enabled;\r
+}\r
+\r
void Context::setLightAmbient(int index, float r, float g, float b, float a)\r
{\r
light[index].ambient = {r, g, b, a};\r
light[index].attenuation.quadratic = quadratic;\r
}\r
\r
+void Context::setSpotLightExponent(int index, float exponent)\r
+{\r
+ light[index].spotExponent = exponent;\r
+}\r
+\r
+void Context::setSpotLightCutoff(int index, float cutoff)\r
+{\r
+ light[index].spotCutoffAngle = cutoff;\r
+}\r
+\r
void Context::setGlobalAmbient(float red, float green, float blue, float alpha)\r
{\r
globalAmbient.red = red;\r
materialShininess = shininess;\r
}\r
\r
+void Context::setLightModelTwoSide(bool enable)\r
+{\r
+ lightModelTwoSide = enable;\r
+}\r
+\r
void Context::setFogEnabled(bool enable)\r
{\r
- device->setFogEnable(enable);\r
+ fogEnabled = enable;\r
+}\r
+\r
+bool Context::isFogEnabled() const\r
+{\r
+ return fogEnabled;\r
}\r
\r
void Context::setFogMode(GLenum mode)\r
{\r
- switch(mode)\r
- {\r
- case GL_LINEAR:\r
- device->setPixelFogMode(sw::FOG_LINEAR);\r
- break;\r
- case GL_EXP:\r
- device->setPixelFogMode(sw::FOG_EXP);\r
- break;\r
- case GL_EXP2:\r
- device->setPixelFogMode(sw::FOG_EXP2);\r
- break;\r
- default:\r
- UNREACHABLE(mode);\r
- }\r
+ fogMode = mode;\r
}\r
\r
void Context::setFogDensity(float fogDensity)\r
{\r
- device->setFogDensity(fogDensity);\r
+ this->fogDensity = fogDensity;\r
}\r
\r
void Context::setFogStart(float fogStart)\r
{\r
- device->setFogStart(fogStart);\r
+ this->fogStart = fogStart;\r
}\r
\r
void Context::setFogEnd(float fogEnd)\r
{\r
- device->setFogEnd(fogEnd);\r
+ this->fogEnd = fogEnd;\r
}\r
\r
void Context::setFogColor(float r, float g, float b, float a)\r
{\r
- device->setFogColor(sw::Color<float>(r, g, b, a));\r
+ this->fogColor = {r, g, b, a};\r
}\r
\r
void Context::setTexture2Denabled(bool enable)\r
texture2Denabled[mState.activeSampler] = enable;\r
}\r
\r
+bool Context::isTexture2Denabled() const\r
+{\r
+ return texture2Denabled[mState.activeSampler];\r
+}\r
+\r
void Context::setTextureExternalEnabled(bool enable)\r
{\r
textureExternalEnabled[mState.activeSampler] = enable;\r
}\r
\r
+bool Context::isTextureExternalEnabled() const\r
+{\r
+ return textureExternalEnabled[mState.activeSampler];\r
+}\r
+\r
void Context::setLineWidth(GLfloat width)\r
{\r
mState.lineWidth = width;\r
mState.perspectiveCorrectionHint = hint;\r
}\r
\r
+void Context::setFogHint(GLenum hint)\r
+{\r
+ mState.fogHint = hint;\r
+}\r
+\r
void Context::setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height)\r
{\r
mState.viewportX = x;\r
\r
if(texid == 0) // Special case: 0 refers to different initial textures based on the target\r
{\r
- switch (type)\r
+ switch(type)\r
{\r
case TEXTURE_2D: return mTexture2DZero;\r
case TEXTURE_EXTERNAL: return mTextureExternalZero;\r
case GL_DEPTH_TEST: *params = mState.depthTestEnabled; break;\r
case GL_BLEND: *params = mState.blendEnabled; break;\r
case GL_DITHER: *params = mState.ditherEnabled; break;\r
+ case GL_LIGHT_MODEL_TWO_SIDE: *params = lightModelTwoSide; break;\r
default:\r
return false;\r
}\r
params[0] = ALIASED_POINT_SIZE_RANGE_MIN;\r
params[1] = ALIASED_POINT_SIZE_RANGE_MAX;\r
break;\r
+ case GL_SMOOTH_LINE_WIDTH_RANGE:\r
+ params[0] = SMOOTH_LINE_WIDTH_RANGE_MIN;\r
+ params[1] = SMOOTH_LINE_WIDTH_RANGE_MAX;\r
+ break;\r
+ case GL_SMOOTH_POINT_SIZE_RANGE:\r
+ params[0] = SMOOTH_POINT_SIZE_RANGE_MIN;\r
+ params[1] = SMOOTH_POINT_SIZE_RANGE_MAX;\r
+ break;\r
case GL_DEPTH_RANGE:\r
params[0] = mState.zNear;\r
params[1] = mState.zFar;\r
// GetIntegerv as its native query function. As it would require conversion in any\r
// case, this should make no difference to the calling application. You may find it in\r
// Context::getFloatv.\r
- switch (pname)\r
+ switch(pname)\r
{\r
case GL_ARRAY_BUFFER_BINDING: *params = mState.arrayBuffer.name(); break;\r
case GL_ELEMENT_ARRAY_BUFFER_BINDING: *params = mState.elementArrayBuffer.name(); break;\r
\r
if(colorbuffer)\r
{\r
- switch (pname)\r
+ switch(pname)\r
{\r
- case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;\r
- case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;\r
- case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;\r
- case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;\r
+ case GL_RED_BITS: *params = colorbuffer->getRedSize(); break;\r
+ case GL_GREEN_BITS: *params = colorbuffer->getGreenSize(); break;\r
+ case GL_BLUE_BITS: *params = colorbuffer->getBlueSize(); break;\r
+ case GL_ALPHA_BITS: *params = colorbuffer->getAlphaSize(); break;\r
}\r
}\r
else\r
}\r
}\r
break;\r
- case GL_TEXTURE_BINDING_2D:\r
- {\r
- if(mState.activeSampler < 0 || mState.activeSampler > MAX_TEXTURE_UNITS - 1)\r
- {\r
- error(GL_INVALID_OPERATION);\r
- return false;\r
- }\r
-\r
- *params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].name();\r
- }\r
- break;\r
- case GL_TEXTURE_BINDING_CUBE_MAP_OES:\r
- {\r
- if(mState.activeSampler < 0 || mState.activeSampler > MAX_TEXTURE_UNITS - 1)\r
- {\r
- error(GL_INVALID_OPERATION);\r
- return false;\r
- }\r
-\r
- *params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].name();\r
- }\r
- break;\r
- case GL_TEXTURE_BINDING_EXTERNAL_OES:\r
- {\r
- if(mState.activeSampler < 0 || mState.activeSampler > MAX_TEXTURE_UNITS - 1)\r
- {\r
- error(GL_INVALID_OPERATION);\r
- return false;\r
- }\r
-\r
- *params = mState.samplerTexture[TEXTURE_EXTERNAL][mState.activeSampler].name();\r
- }\r
- break;\r
- case GL_MAX_LIGHTS: *params = MAX_LIGHTS; break;\r
- case GL_MAX_MODELVIEW_STACK_DEPTH: *params = MAX_MODELVIEW_STACK_DEPTH; break;\r
- case GL_MAX_PROJECTION_STACK_DEPTH: *params = MAX_PROJECTION_STACK_DEPTH; break;\r
- case GL_MAX_TEXTURE_STACK_DEPTH: *params = MAX_TEXTURE_STACK_DEPTH; break;\r
- case GL_MAX_TEXTURE_UNITS: *params = MAX_TEXTURE_UNITS; break;\r
- case GL_MAX_CLIP_PLANES: *params = MAX_CLIP_PLANES; break;\r
+ case GL_TEXTURE_BINDING_2D: *params = mState.samplerTexture[TEXTURE_2D][mState.activeSampler].name(); break;\r
+ case GL_TEXTURE_BINDING_CUBE_MAP_OES: *params = mState.samplerTexture[TEXTURE_CUBE][mState.activeSampler].name(); break;\r
+ case GL_TEXTURE_BINDING_EXTERNAL_OES: *params = mState.samplerTexture[TEXTURE_EXTERNAL][mState.activeSampler].name(); break;\r
+ case GL_MAX_LIGHTS: *params = MAX_LIGHTS; break;\r
+ case GL_MAX_MODELVIEW_STACK_DEPTH: *params = MAX_MODELVIEW_STACK_DEPTH; break;\r
+ case GL_MAX_PROJECTION_STACK_DEPTH: *params = MAX_PROJECTION_STACK_DEPTH; break;\r
+ case GL_MAX_TEXTURE_STACK_DEPTH: *params = MAX_TEXTURE_STACK_DEPTH; break;\r
+ case GL_MAX_TEXTURE_UNITS: *params = MAX_TEXTURE_UNITS; break;\r
+ case GL_MAX_CLIP_PLANES: *params = MAX_CLIP_PLANES; break;\r
+ case GL_POINT_SIZE_ARRAY_TYPE_OES: *params = mState.vertexAttribute[sw::PointSize].mType; break;\r
+ case GL_POINT_SIZE_ARRAY_STRIDE_OES: *params = mState.vertexAttribute[sw::PointSize].mStride; break;\r
+ case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: *params = mState.vertexAttribute[sw::PointSize].mBoundBuffer.name(); break;\r
+ case GL_VERTEX_ARRAY_TYPE: *params = mState.vertexAttribute[sw::Position].mType; break;\r
+ case GL_VERTEX_ARRAY_STRIDE: *params = mState.vertexAttribute[sw::Position].mStride; break;\r
+ case GL_VERTEX_ARRAY_BUFFER_BINDING: *params = mState.vertexAttribute[sw::Position].mBoundBuffer.name(); break;\r
+ case GL_NORMAL_ARRAY_TYPE: *params = mState.vertexAttribute[sw::Normal].mType; break;\r
+ case GL_NORMAL_ARRAY_STRIDE: *params = mState.vertexAttribute[sw::Normal].mStride; break;\r
+ case GL_NORMAL_ARRAY_BUFFER_BINDING: *params = mState.vertexAttribute[sw::Normal].mBoundBuffer.name(); break;\r
+ case GL_COLOR_ARRAY_TYPE: *params = mState.vertexAttribute[sw::Color0].mType; break;\r
+ case GL_COLOR_ARRAY_STRIDE: *params = mState.vertexAttribute[sw::Color0].mStride; break;\r
+ case GL_COLOR_ARRAY_BUFFER_BINDING: *params = mState.vertexAttribute[sw::Color0].mBoundBuffer.name(); break;\r
+ case GL_TEXTURE_COORD_ARRAY_TYPE: *params = mState.vertexAttribute[sw::TexCoord0 + mState.activeSampler].mType; break;\r
+ case GL_TEXTURE_COORD_ARRAY_STRIDE: *params = mState.vertexAttribute[sw::TexCoord0 + mState.activeSampler].mStride; break;\r
+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: *params = mState.vertexAttribute[sw::TexCoord0 + mState.activeSampler].mBoundBuffer.name(); break;\r
default:\r
return false;\r
}\r
// in the case that one calls glGetIntegerv to retrieve a float-typed state variable, we\r
// place DEPTH_CLEAR_VALUE with the floats. This should make no difference to the calling\r
// application.\r
- switch (pname)\r
+ switch(pname)\r
{\r
case GL_COMPRESSED_TEXTURE_FORMATS:\r
return NUM_COMPRESSED_TEXTURE_FORMATS;\r
case GL_MAX_TEXTURE_STACK_DEPTH:\r
case GL_MAX_TEXTURE_UNITS:\r
case GL_MAX_CLIP_PLANES:\r
+ case GL_POINT_SIZE_ARRAY_TYPE_OES:\r
+ case GL_POINT_SIZE_ARRAY_STRIDE_OES:\r
+ case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:\r
return 1;\r
+ case GL_CURRENT_COLOR:\r
+ return 4;\r
+ case GL_CURRENT_NORMAL:\r
+ return 3;\r
+ case GL_CURRENT_TEXTURE_COORDS:\r
+ return 4;\r
+ case GL_POINT_SIZE:\r
+ case GL_POINT_SIZE_MIN:\r
+ case GL_POINT_SIZE_MAX:\r
+ case GL_POINT_FADE_THRESHOLD_SIZE:\r
+ return 1;\r
+ case GL_POINT_DISTANCE_ATTENUATION:\r
+ return 3;\r
+ case GL_SMOOTH_POINT_SIZE_RANGE:\r
+ case GL_SMOOTH_LINE_WIDTH_RANGE:\r
+ return 2;\r
+ case GL_SHADE_MODEL:\r
+ case GL_MATRIX_MODE:\r
+ case GL_MODELVIEW_STACK_DEPTH:\r
+ case GL_PROJECTION_STACK_DEPTH:\r
+ case GL_TEXTURE_STACK_DEPTH:\r
+ return 1;\r
+ case GL_MODELVIEW_MATRIX:\r
+ case GL_PROJECTION_MATRIX:\r
+ case GL_TEXTURE_MATRIX:\r
+ return 16;\r
+ case GL_ALPHA_TEST_FUNC:\r
+ case GL_ALPHA_TEST_REF:\r
+ case GL_BLEND_DST:\r
+ case GL_BLEND_SRC:\r
+ case GL_LOGIC_OP_MODE:\r
+ case GL_VERTEX_ARRAY_SIZE:\r
+ case GL_VERTEX_ARRAY_TYPE:\r
+ case GL_VERTEX_ARRAY_STRIDE:\r
+ case GL_NORMAL_ARRAY_TYPE:\r
+ case GL_NORMAL_ARRAY_STRIDE:\r
+ case GL_COLOR_ARRAY_SIZE:\r
+ case GL_COLOR_ARRAY_TYPE:\r
+ case GL_COLOR_ARRAY_STRIDE:\r
+ case GL_TEXTURE_COORD_ARRAY_SIZE:\r
+ case GL_TEXTURE_COORD_ARRAY_TYPE:\r
+ case GL_TEXTURE_COORD_ARRAY_STRIDE:\r
+ case GL_VERTEX_ARRAY_POINTER:\r
+ case GL_NORMAL_ARRAY_POINTER:\r
+ case GL_COLOR_ARRAY_POINTER:\r
+ case GL_TEXTURE_COORD_ARRAY_POINTER:\r
+ case GL_LIGHT_MODEL_TWO_SIDE:\r
+ return 1;\r
default:\r
UNREACHABLE(pname);\r
}\r
case GL_MAX_PROJECTION_STACK_DEPTH:\r
case GL_MAX_TEXTURE_STACK_DEPTH:\r
case GL_MAX_TEXTURE_UNITS:\r
+ case GL_MAX_CLIP_PLANES:\r
+ case GL_POINT_SIZE_ARRAY_TYPE_OES:\r
+ case GL_POINT_SIZE_ARRAY_STRIDE_OES:\r
+ case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:\r
return true;\r
- default:\r
- ASSERT(isQueryParameterFloat(pname) || isQueryParameterBool(pname));\r
}\r
\r
return false;\r
case GL_LINE_WIDTH:\r
case GL_ALIASED_LINE_WIDTH_RANGE:\r
case GL_ALIASED_POINT_SIZE_RANGE:\r
+ case GL_SMOOTH_LINE_WIDTH_RANGE:\r
+ case GL_SMOOTH_POINT_SIZE_RANGE:\r
case GL_DEPTH_RANGE:\r
case GL_COLOR_CLEAR_VALUE:\r
case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:\r
+ case GL_LIGHT_MODEL_AMBIENT:\r
+ case GL_POINT_SIZE_MIN:\r
+ case GL_POINT_SIZE_MAX:\r
+ case GL_POINT_DISTANCE_ATTENUATION:\r
+ case GL_POINT_FADE_THRESHOLD_SIZE:\r
return true;\r
- default:\r
- ASSERT(isQueryParameterInt(pname) || isQueryParameterBool(pname));\r
}\r
\r
return false;\r
case GL_BLEND:\r
case GL_DITHER:\r
case GL_COLOR_WRITEMASK:\r
+ case GL_LIGHT_MODEL_TWO_SIDE:\r
+ return true;\r
+ }\r
+\r
+ return false;\r
+}\r
+\r
+bool Context::isQueryParameterPointer(GLenum pname)\r
+{\r
+ switch(pname)\r
+ {\r
+ case GL_VERTEX_ARRAY_POINTER:\r
+ case GL_NORMAL_ARRAY_POINTER:\r
+ case GL_COLOR_ARRAY_POINTER:\r
+ case GL_TEXTURE_COORD_ARRAY_POINTER:\r
+ case GL_POINT_SIZE_ARRAY_POINTER_OES:\r
return true;\r
- default:\r
- ASSERT(isQueryParameterInt(pname) || isQueryParameterFloat(pname));\r
}\r
\r
return false;\r
device->setAlphaTestEnable(alphaTestEnabled);\r
device->setAlphaCompare(es2sw::ConvertAlphaComparison(alphaTestFunc));\r
device->setAlphaReference(alphaTestRef * 0xFF);\r
+\r
+ device->setFogEnable(fogEnabled);\r
+ device->setFogColor(sw::Color<float>(fogColor.red, fogColor.green, fogColor.blue, fogColor.alpha));\r
+ device->setFogDensity(fogDensity);\r
+ device->setFogStart(fogStart);\r
+ device->setFogEnd(fogEnd);\r
+\r
+ switch(fogMode)\r
+ {\r
+ case GL_LINEAR: device->setVertexFogMode(sw::FOG_LINEAR); break;\r
+ case GL_EXP: device->setVertexFogMode(sw::FOG_EXP); break;\r
+ case GL_EXP2: device->setVertexFogMode(sw::FOG_EXP2); break;\r
+ default: UNREACHABLE(fogMode);\r
+ }\r
+\r
+ device->setColorLogicOpEnabled(colorLogicOpEnabled);\r
+ device->setLogicalOperation(es2sw::ConvertLogicalOperation(logicalOperation));\r
+\r
+ device->setNormalizeNormals(normalizeEnabled || rescaleNormalEnabled);\r
}\r
\r
GLenum Context::applyVertexBuffer(GLint base, GLint first, GLsizei count)\r
{\r
es1::Framebuffer *framebuffer = getFramebuffer();\r
es1::Renderbuffer *renderbuffer = framebuffer->getColorbuffer();\r
- float targetWidth = renderbuffer->getWidth();\r
- float targetHeight = renderbuffer->getHeight();\r
+ float targetWidth = (float)renderbuffer->getWidth();\r
+ float targetHeight = (float)renderbuffer->getHeight();\r
float x0 = 2.0f * x / targetWidth - 1.0f;\r
float y0 = 2.0f * y / targetHeight - 1.0f;\r
float x1 = 2.0f * (x + width) / targetWidth - 1.0f;\r
\r
ASSERT(mState.samplerTexture[TEXTURE_2D][1].name() == 0); // Multi-texturing unimplemented\r
es1::Texture *texture = getSamplerTexture(0, TEXTURE_2D);\r
- float textureWidth = texture->getWidth(GL_TEXTURE_2D, 0);\r
- float textureHeight = texture->getHeight(GL_TEXTURE_2D, 0);\r
+ float textureWidth = (float)texture->getWidth(GL_TEXTURE_2D, 0);\r
+ float textureHeight = (float)texture->getHeight(GL_TEXTURE_2D, 0);\r
int Ucr = texture->getCropRectU();\r
int Vcr = texture->getCropRectV();\r
int Wcr = texture->getCropRectW();\r
\r
bool Context::isTriangleMode(GLenum drawMode)\r
{\r
- switch (drawMode)\r
+ switch(drawMode)\r
{\r
- case GL_TRIANGLES:\r
- case GL_TRIANGLE_FAN:\r
- case GL_TRIANGLE_STRIP:\r
+ case GL_TRIANGLES:\r
+ case GL_TRIANGLE_FAN:\r
+ case GL_TRIANGLE_STRIP:\r
return true;\r
- case GL_POINTS:\r
- case GL_LINES:\r
- case GL_LINE_LOOP:\r
- case GL_LINE_STRIP:\r
+ case GL_POINTS:\r
+ case GL_LINES:\r
+ case GL_LINE_LOOP:\r
+ case GL_LINE_STRIP:\r
return false;\r
- default: UNREACHABLE(drawMode);\r
+ default: UNREACHABLE(drawMode);\r
}\r
\r
return false;\r
return (clipFlags & (1 << index)) != 0;\r
}\r
\r
+void Context::setColorLogicOpEnabled(bool enable)\r
+{\r
+ colorLogicOpEnabled = enable;\r
+}\r
+\r
+bool Context::isColorLogicOpEnabled() const\r
+{\r
+ return colorLogicOpEnabled;\r
+}\r
+\r
+void Context::setLogicalOperation(GLenum logicOp)\r
+{\r
+ logicalOperation = logicOp;\r
+}\r
+\r
+void Context::setLineSmoothEnabled(bool enable)\r
+{\r
+ lineSmoothEnabled = enable;\r
+}\r
+\r
+bool Context::isLineSmoothEnabled() const\r
+{\r
+ return lineSmoothEnabled;\r
+}\r
+\r
+void Context::setColorMaterialEnabled(bool enable)\r
+{\r
+ colorMaterialEnabled = enable;\r
+}\r
+\r
+bool Context::isColorMaterialEnabled() const\r
+{\r
+ return colorMaterialEnabled;\r
+}\r
+\r
+void Context::setNormalizeEnabled(bool enable)\r
+{\r
+ normalizeEnabled = enable;\r
+}\r
+\r
+bool Context::isNormalizeEnabled() const\r
+{\r
+ return normalizeEnabled;\r
+}\r
+\r
+void Context::setRescaleNormalEnabled(bool enable)\r
+{\r
+ rescaleNormalEnabled = enable;\r
+}\r
+\r
+bool Context::isRescaleNormalEnabled() const\r
+{\r
+ return rescaleNormalEnabled;\r
+}\r
+\r
+void Context::setVertexArrayEnabled(bool enable)\r
+{\r
+ mState.vertexAttribute[sw::Position].mArrayEnabled = enable;\r
+}\r
+\r
+bool Context::isVertexArrayEnabled() const\r
+{\r
+ return mState.vertexAttribute[sw::Position].mArrayEnabled;\r
+}\r
+\r
+void Context::setNormalArrayEnabled(bool enable)\r
+{\r
+ mState.vertexAttribute[sw::Normal].mArrayEnabled = enable;\r
+}\r
+\r
+bool Context::isNormalArrayEnabled() const\r
+{\r
+ return mState.vertexAttribute[sw::Normal].mArrayEnabled;\r
+}\r
+\r
+void Context::setColorArrayEnabled(bool enable)\r
+{\r
+ mState.vertexAttribute[sw::Color0].mArrayEnabled = enable;\r
+}\r
+\r
+bool Context::isColorArrayEnabled() const\r
+{\r
+ return mState.vertexAttribute[sw::Color0].mArrayEnabled;\r
+}\r
+\r
+void Context::setPointSizeArrayEnabled(bool enable)\r
+{\r
+ mState.vertexAttribute[sw::PointSize].mArrayEnabled = enable;\r
+}\r
+\r
+bool Context::isPointSizeArrayEnabled() const\r
+{\r
+ return mState.vertexAttribute[sw::PointSize].mArrayEnabled;\r
+}\r
+\r
+void Context::setTextureCoordArrayEnabled(bool enable)\r
+{\r
+ mState.vertexAttribute[sw::TexCoord0 + clientTexture].mArrayEnabled = enable;\r
+}\r
+\r
+bool Context::isTextureCoordArrayEnabled() const\r
+{\r
+ return mState.vertexAttribute[sw::TexCoord0 + clientTexture].mArrayEnabled;\r
+}\r
+\r
+void Context::setMultisampleEnabled(bool enable)\r
+{\r
+ multisampleEnabled = enable;\r
+}\r
+\r
+bool Context::isMultisampleEnabled() const\r
+{\r
+ return multisampleEnabled;\r
+}\r
+\r
+void Context::setSampleAlphaToOneEnabled(bool enable)\r
+{\r
+ sampleAlphaToOneEnabled = enable;\r
+}\r
+\r
+bool Context::isSampleAlphaToOneEnabled() const\r
+{\r
+ return sampleAlphaToOneEnabled;\r
+}\r
+\r
+void Context::setPointSpriteEnabled(bool enable)\r
+{\r
+ pointSpriteEnabled = enable;\r
+}\r
+\r
+bool Context::isPointSpriteEnabled() const\r
+{\r
+ return pointSpriteEnabled;\r
+}\r
+\r
+void Context::setPointSmoothEnabled(bool enable)\r
+{\r
+ pointSmoothEnabled = enable;\r
+}\r
+\r
+bool Context::isPointSmoothEnabled() const\r
+{\r
+ return pointSmoothEnabled;\r
+}\r
+\r
+\r
+void Context::setPointSizeMin(float min)\r
+{\r
+ pointSizeMin = min;\r
+}\r
+\r
+void Context::setPointSizeMax(float max)\r
+{\r
+ pointSizeMax = max;\r
+}\r
+\r
+void Context::setPointDistanceAttenuation(float a, float b, float c)\r
+{\r
+ pointDistanceAttenuation = {a, b, c};\r
+}\r
+\r
+void Context::setPointFadeThresholdSize(float threshold)\r
+{\r
+ pointFadeThresholdSize = threshold;\r
+}\r
+\r
void Context::clientActiveTexture(GLenum texture)\r
{\r
clientTexture = texture;\r
const float ALIASED_LINE_WIDTH_RANGE_MAX = 1.0f;\r
const float ALIASED_POINT_SIZE_RANGE_MIN = 0.125f;\r
const float ALIASED_POINT_SIZE_RANGE_MAX = 8192.0f;\r
+const float SMOOTH_LINE_WIDTH_RANGE_MIN = 1.0f;\r
+const float SMOOTH_LINE_WIDTH_RANGE_MAX = 1.0f;\r
+const float SMOOTH_POINT_SIZE_RANGE_MIN = 0.125f;\r
+const float SMOOTH_POINT_SIZE_RANGE_MAX = 8192.0f;\r
const float MAX_TEXTURE_MAX_ANISOTROPY = 16.0f;\r
\r
struct Color\r
Point position;\r
Vector direction;\r
Attenuation attenuation;\r
+ float spotExponent;\r
+ float spotCutoffAngle;\r
};\r
\r
// Helper structure describing a single vertex attribute\r
class VertexAttribute\r
{\r
- public:\r
+public:\r
VertexAttribute() : mType(GL_FLOAT), mSize(0), mNormalized(false), mStride(0), mPointer(NULL), mArrayEnabled(false)\r
{\r
mCurrentValue[0] = 0.0f;\r
bool scissorTestEnabled;\r
bool ditherEnabled;\r
GLenum shadeModel;\r
- bool colorLogicOpEnabled;\r
- GLenum logicalOperation;\r
\r
GLfloat lineWidth;\r
\r
GLenum generateMipmapHint;\r
GLenum perspectiveCorrectionHint;\r
+ GLenum fogHint;\r
\r
GLint viewportX;\r
GLint viewportY;\r
void setDitherEnabled(bool enabled);\r
bool isDitherEnabled() const;\r
void setLightingEnabled(bool enabled);\r
+ bool isLightingEnabled() const;\r
void setLightEnabled(int index, bool enable);\r
+ bool isLightEnabled(int index) const;\r
void setLightAmbient(int index, float r, float g, float b, float a);\r
void setLightDiffuse(int index, float r, float g, float b, float a);\r
void setLightSpecular(int index, float r, float g, float b, float a);\r
void setLightAttenuationConstant(int index, float constant);\r
void setLightAttenuationLinear(int index, float linear);\r
void setLightAttenuationQuadratic(int index, float quadratic);\r
+ void setSpotLightExponent(int index, float exponent);\r
+ void setSpotLightCutoff(int index, float cutoff);\r
\r
void setGlobalAmbient(float red, float green, float blue, float alpha);\r
void setMaterialAmbient(float red, float green, float blue, float alpha);\r
void setMaterialSpecular(float red, float green, float blue, float alpha);\r
void setMaterialEmission(float red, float green, float blue, float alpha);\r
void setMaterialShininess(float shininess);\r
+ void setLightModelTwoSide(bool enable);\r
\r
void setFogEnabled(bool enabled);\r
+ bool isFogEnabled() const;\r
void setFogMode(GLenum mode);\r
void setFogDensity(float fogDensity);\r
void setFogStart(float fogStart);\r
void setFogColor(float r, float g, float b, float a);\r
\r
void setTexture2Denabled(bool enabled);\r
+ bool isTexture2Denabled() const;\r
void setTextureExternalEnabled(bool enabled);\r
+ bool isTextureExternalEnabled() const;\r
void clientActiveTexture(GLenum texture);\r
GLenum getClientActiveTexture() const;\r
unsigned int getActiveTexture() const;\r
\r
void setGenerateMipmapHint(GLenum hint);\r
void setPerspectiveCorrectionHint(GLenum hint);\r
+ void setFogHint(GLenum hint);\r
\r
void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);\r
\r
void setPackAlignment(GLint alignment);\r
GLint getPackAlignment() const;\r
\r
- // These create and destroy methods are merely pass-throughs to\r
+ // These create and destroy methods are merely pass-throughs to\r
// ResourceManager, which owns these object types\r
GLuint createBuffer();\r
GLuint createTexture();\r
bool isQueryParameterInt(GLenum pname);\r
bool isQueryParameterFloat(GLenum pname);\r
bool isQueryParameterBool(GLenum pname);\r
+ bool isQueryParameterPointer(GLenum pname);\r
\r
void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);\r
void clear(GLbitfield mask);\r
void setClipPlaneEnabled(int index, bool enable);\r
bool isClipPlaneEnabled(int index) const;\r
\r
+ void setColorLogicOpEnabled(bool enable);\r
+ bool isColorLogicOpEnabled() const;\r
+ void setLogicalOperation(GLenum logicOp);\r
+\r
+ void setPointSmoothEnabled(bool enable);\r
+ bool isPointSmoothEnabled() const;\r
+\r
+ void setLineSmoothEnabled(bool enable);\r
+ bool isLineSmoothEnabled() const;\r
+\r
+ void setColorMaterialEnabled(bool enable);\r
+ bool isColorMaterialEnabled() const;\r
+\r
+ void setNormalizeEnabled(bool enable);\r
+ bool isNormalizeEnabled() const;\r
+\r
+ void setRescaleNormalEnabled(bool enable);\r
+ bool isRescaleNormalEnabled() const;\r
+\r
+ void setVertexArrayEnabled(bool enable);\r
+ bool isVertexArrayEnabled() const;\r
+\r
+ void setNormalArrayEnabled(bool enable);\r
+ bool isNormalArrayEnabled() const;\r
+\r
+ void setColorArrayEnabled(bool enable);\r
+ bool isColorArrayEnabled() const;\r
+\r
+ void setPointSizeArrayEnabled(bool enable);\r
+ bool isPointSizeArrayEnabled() const;\r
+\r
+ void setTextureCoordArrayEnabled(bool enable);\r
+ bool isTextureCoordArrayEnabled() const;\r
+\r
+ void setMultisampleEnabled(bool enable);\r
+ bool isMultisampleEnabled() const;\r
+\r
+ void setSampleAlphaToOneEnabled(bool enable);\r
+ bool isSampleAlphaToOneEnabled() const;\r
+\r
+ void setPointSpriteEnabled(bool enable);\r
+ bool isPointSpriteEnabled() const;\r
+ void setPointSizeMin(float min);\r
+ void setPointSizeMax(float max);\r
+ void setPointDistanceAttenuation(float a, float b, float c);\r
+ void setPointFadeThresholdSize(float threshold);\r
+\r
private:\r
virtual ~Context();\r
\r
Color materialSpecular;\r
Color materialEmission;\r
GLfloat materialShininess;\r
+ bool lightModelTwoSide;\r
\r
// Recorded errors\r
bool mInvalidEnum;\r
GLenum alphaTestFunc;\r
float alphaTestRef;\r
\r
+ bool fogEnabled;\r
+ GLenum fogMode;\r
+ float fogDensity;\r
+ float fogStart;\r
+ float fogEnd;\r
+ Color fogColor;\r
+\r
+ bool lineSmoothEnabled;\r
+ bool colorMaterialEnabled;\r
+ bool normalizeEnabled;\r
+ bool rescaleNormalEnabled;\r
+ bool multisampleEnabled;\r
+ bool sampleAlphaToOneEnabled;\r
+\r
+ bool pointSpriteEnabled;\r
+ bool pointSmoothEnabled;\r
+ float pointSizeMin;\r
+ float pointSizeMax;\r
+ Attenuation pointDistanceAttenuation;\r
+ float pointFadeThresholdSize;\r
+\r
+ bool colorLogicOpEnabled;\r
+ GLenum logicalOperation;\r
+\r
Device *device;\r
ResourceManager *mResourceManager;\r
};\r
setDestBlendFactorAlpha(BLEND_ZERO);\r
setBlendOperationAlpha(BLENDOP_ADD);\r
setPointSpriteEnable(true);\r
- setColorLogicOpEnabled(false);\r
- setLogicalOperation(LOGICALOP_COPY);\r
\r
for(int i = 0; i < 16; i++)\r
{\r
case GL_TEXTURE_2D: context->setTexture2Denabled(false); break;\r
case GL_TEXTURE_EXTERNAL_OES: context->setTextureExternalEnabled(false); break;\r
case GL_ALPHA_TEST: context->setAlphaTestEnabled(false); break;\r
- case GL_COLOR_LOGIC_OP: UNIMPLEMENTED(); break;\r
- case GL_POINT_SMOOTH: UNIMPLEMENTED(); break;\r
- case GL_LINE_SMOOTH: UNIMPLEMENTED(); break;\r
- case GL_COLOR_MATERIAL: UNIMPLEMENTED(); break;\r
- case GL_NORMALIZE: UNIMPLEMENTED(); break;\r
- case GL_RESCALE_NORMAL: UNIMPLEMENTED(); break;\r
- case GL_VERTEX_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_NORMAL_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_COLOR_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_TEXTURE_COORD_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_MULTISAMPLE: UNIMPLEMENTED(); break;\r
- case GL_SAMPLE_ALPHA_TO_ONE: UNIMPLEMENTED(); break;\r
- case GL_CLIP_PLANE0: context->setClipPlaneEnabled(0, false); break;\r
- case GL_CLIP_PLANE1: context->setClipPlaneEnabled(1, false); break;\r
- case GL_CLIP_PLANE2: context->setClipPlaneEnabled(2, false); break;\r
- case GL_CLIP_PLANE3: context->setClipPlaneEnabled(3, false); break;\r
- case GL_CLIP_PLANE4: context->setClipPlaneEnabled(4, false); break;\r
- case GL_CLIP_PLANE5: context->setClipPlaneEnabled(5, false); break;\r
+ case GL_COLOR_LOGIC_OP: context->setColorLogicOpEnabled(false); break;\r
+ case GL_POINT_SMOOTH: context->setPointSmoothEnabled(false); break;\r
+ case GL_LINE_SMOOTH: context->setLineSmoothEnabled(false); break;\r
+ case GL_COLOR_MATERIAL: context->setColorMaterialEnabled(false); break;\r
+ case GL_NORMALIZE: context->setNormalizeEnabled(false); break;\r
+ case GL_RESCALE_NORMAL: context->setRescaleNormalEnabled(false); break;\r
+ case GL_VERTEX_ARRAY: context->setVertexArrayEnabled(false); break;\r
+ case GL_NORMAL_ARRAY: context->setNormalArrayEnabled(false); break;\r
+ case GL_COLOR_ARRAY: context->setColorArrayEnabled(false); break;\r
+ case GL_POINT_SIZE_ARRAY_OES: context->setPointSizeArrayEnabled(false); break;\r
+ case GL_TEXTURE_COORD_ARRAY: context->setTextureCoordArrayEnabled(false); break;\r
+ case GL_MULTISAMPLE: context->setMultisampleEnabled(false); break;\r
+ case GL_SAMPLE_ALPHA_TO_ONE: context->setSampleAlphaToOneEnabled(false); break;\r
+ case GL_CLIP_PLANE0: context->setClipPlaneEnabled(0, false); break;\r
+ case GL_CLIP_PLANE1: context->setClipPlaneEnabled(1, false); break;\r
+ case GL_CLIP_PLANE2: context->setClipPlaneEnabled(2, false); break;\r
+ case GL_CLIP_PLANE3: context->setClipPlaneEnabled(3, false); break;\r
+ case GL_CLIP_PLANE4: context->setClipPlaneEnabled(4, false); break;\r
+ case GL_CLIP_PLANE5: context->setClipPlaneEnabled(5, false); break;\r
+ case GL_POINT_SPRITE_OES: context->setPointSpriteEnabled(false); break;\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
{\r
TRACE("(GLenum array = 0x%X)", array);\r
\r
+ switch(array)\r
+ {\r
+ case GL_VERTEX_ARRAY:\r
+ case GL_NORMAL_ARRAY:\r
+ case GL_COLOR_ARRAY:\r
+ case GL_POINT_SIZE_ARRAY_OES:\r
+ case GL_TEXTURE_COORD_ARRAY:\r
+ break;\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+\r
es1::Context *context = es1::getContext();\r
\r
- if (context)\r
+ if(context)\r
{\r
GLenum texture = context->getClientActiveTexture();\r
\r
- switch (array)\r
+ switch(array)\r
{\r
- case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, false); break;\r
- case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, false); break;\r
- case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), false); break;\r
- case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, false); break;\r
- default: UNIMPLEMENTED();\r
+ case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, false); break;\r
+ case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, false); break;\r
+ case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, false); break;\r
+ case GL_POINT_SIZE_ARRAY_OES: context->setVertexAttribArrayEnabled(sw::PointSize, false); break;\r
+ case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), false); break;\r
+ default: UNREACHABLE(array);\r
}\r
}\r
}\r
case GL_LIGHT5: context->setLightEnabled(5, true); break;\r
case GL_LIGHT6: context->setLightEnabled(6, true); break;\r
case GL_LIGHT7: context->setLightEnabled(7, true); break;\r
- case GL_FOG: context->setFogEnabled(true); break;\r
+ case GL_FOG: context->setFogEnabled(true); break;\r
case GL_TEXTURE_2D: context->setTexture2Denabled(true); break;\r
case GL_TEXTURE_EXTERNAL_OES: context->setTextureExternalEnabled(true); break;\r
case GL_ALPHA_TEST: context->setAlphaTestEnabled(true); break;\r
- case GL_COLOR_LOGIC_OP: UNIMPLEMENTED(); break;\r
- case GL_POINT_SMOOTH: UNIMPLEMENTED(); break;\r
- case GL_LINE_SMOOTH: UNIMPLEMENTED(); break;\r
- case GL_COLOR_MATERIAL: UNIMPLEMENTED(); break;\r
- case GL_NORMALIZE: UNIMPLEMENTED(); break;\r
- case GL_RESCALE_NORMAL: UNIMPLEMENTED(); break;\r
- case GL_VERTEX_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_NORMAL_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_COLOR_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_TEXTURE_COORD_ARRAY: UNIMPLEMENTED(); break;\r
- case GL_MULTISAMPLE: UNIMPLEMENTED(); break;\r
- case GL_SAMPLE_ALPHA_TO_ONE: UNIMPLEMENTED(); break;\r
- case GL_CLIP_PLANE0: context->setClipPlaneEnabled(0, true); break;\r
- case GL_CLIP_PLANE1: context->setClipPlaneEnabled(1, true); break;\r
- case GL_CLIP_PLANE2: context->setClipPlaneEnabled(2, true); break;\r
- case GL_CLIP_PLANE3: context->setClipPlaneEnabled(3, true); break;\r
- case GL_CLIP_PLANE4: context->setClipPlaneEnabled(4, true); break;\r
- case GL_CLIP_PLANE5: context->setClipPlaneEnabled(5, true); break;\r
+ case GL_COLOR_LOGIC_OP: context->setColorLogicOpEnabled(true); break;\r
+ case GL_POINT_SMOOTH: context->setPointSmoothEnabled(true); break;\r
+ case GL_LINE_SMOOTH: context->setLineSmoothEnabled(true); break;\r
+ case GL_COLOR_MATERIAL: context->setColorMaterialEnabled(true); break;\r
+ case GL_NORMALIZE: context->setNormalizeEnabled(true); break;\r
+ case GL_RESCALE_NORMAL: context->setRescaleNormalEnabled(true); break;\r
+ case GL_VERTEX_ARRAY: context->setVertexArrayEnabled(true); break;\r
+ case GL_NORMAL_ARRAY: context->setNormalArrayEnabled(true); break;\r
+ case GL_COLOR_ARRAY: context->setColorArrayEnabled(true); break;\r
+ case GL_POINT_SIZE_ARRAY_OES: context->setPointSizeArrayEnabled(true); break;\r
+ case GL_TEXTURE_COORD_ARRAY: context->setTextureCoordArrayEnabled(true); break;\r
+ case GL_MULTISAMPLE: context->setMultisampleEnabled(true); break;\r
+ case GL_SAMPLE_ALPHA_TO_ONE: context->setSampleAlphaToOneEnabled(true); break;\r
+ case GL_CLIP_PLANE0: context->setClipPlaneEnabled(0, true); break;\r
+ case GL_CLIP_PLANE1: context->setClipPlaneEnabled(1, true); break;\r
+ case GL_CLIP_PLANE2: context->setClipPlaneEnabled(2, true); break;\r
+ case GL_CLIP_PLANE3: context->setClipPlaneEnabled(3, true); break;\r
+ case GL_CLIP_PLANE4: context->setClipPlaneEnabled(4, true); break;\r
+ case GL_CLIP_PLANE5: context->setClipPlaneEnabled(5, true); break;\r
+ case GL_POINT_SPRITE_OES: context->setPointSpriteEnabled(true); break;\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
{\r
TRACE("(GLenum array = 0x%X)", array);\r
\r
+ switch(array)\r
+ {\r
+ case GL_VERTEX_ARRAY:\r
+ case GL_NORMAL_ARRAY:\r
+ case GL_COLOR_ARRAY:\r
+ case GL_POINT_SIZE_ARRAY_OES:\r
+ case GL_TEXTURE_COORD_ARRAY:\r
+ break;\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+\r
es1::Context *context = es1::getContext();\r
\r
if(context)\r
\r
switch(array)\r
{\r
- case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, true); break;\r
- case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, true); break;\r
- case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), true); break;\r
- case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, true); break;\r
- default: UNIMPLEMENTED();\r
+ case GL_VERTEX_ARRAY: context->setVertexAttribArrayEnabled(sw::Position, true); break;\r
+ case GL_NORMAL_ARRAY: context->setVertexAttribArrayEnabled(sw::Normal, true); break;\r
+ case GL_COLOR_ARRAY: context->setVertexAttribArrayEnabled(sw::Color0, true); break;\r
+ case GL_POINT_SIZE_ARRAY_OES: context->setVertexAttribArrayEnabled(sw::PointSize, true); break;\r
+ case GL_TEXTURE_COORD_ARRAY: context->setVertexAttribArrayEnabled(sw::TexCoord0 + (texture - GL_TEXTURE0), true); break;\r
+ default: UNREACHABLE(array);\r
}\r
}\r
}\r
TRACE("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);\r
\r
es1::Context *context = es1::getContext();\r
+\r
if(context)\r
{\r
switch(pname)\r
return error(GL_INVALID_ENUM);\r
}\r
break;\r
-\r
case GL_FOG_DENSITY:\r
if(param < 0)\r
{\r
return error(GL_INVALID_VALUE);\r
}\r
-\r
context->setFogDensity(param);\r
break;\r
-\r
case GL_FOG_START:\r
context->setFogStart(param);\r
break;\r
-\r
case GL_FOG_END:\r
context->setFogEnd(param);\r
break;\r
-\r
case GL_FOG_COLOR:\r
+ return error(GL_INVALID_ENUM); // Need four values, should call glFogfv() instead\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
return error(GL_INVALID_ENUM);\r
}\r
break;\r
-\r
case GL_FOG_DENSITY:\r
if(params[0] < 0)\r
{\r
return error(GL_INVALID_VALUE);\r
}\r
-\r
context->setFogDensity(params[0]);\r
break;\r
-\r
case GL_FOG_START:\r
context->setFogStart(params[0]);\r
break;\r
-\r
case GL_FOG_END:\r
context->setFogEnd(params[0]);\r
break;\r
-\r
case GL_FOG_COLOR:\r
context->setFogColor(params[0], params[1], params[2], params[3]);\r
break;\r
-\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
\r
delete [] intParams;\r
}\r
+ else UNREACHABLE(pname);\r
}\r
}\r
}\r
\r
delete [] intParams;\r
}\r
+ else UNREACHABLE(pname);\r
}\r
}\r
}\r
\r
delete [] floatParams;\r
}\r
+ else UNREACHABLE(pname);\r
}\r
}\r
}\r
case GL_PERSPECTIVE_CORRECTION_HINT:\r
context->setPerspectiveCorrectionHint(mode);\r
break;\r
+ case GL_FOG_HINT:\r
+ context->setFogHint(mode);\r
+ break;\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
{\r
switch(cap)\r
{\r
- case GL_CULL_FACE: return context->isCullFaceEnabled();\r
- case GL_POLYGON_OFFSET_FILL: return context->isPolygonOffsetFillEnabled();\r
- case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled();\r
- case GL_SAMPLE_COVERAGE: return context->isSampleCoverageEnabled();\r
- case GL_SCISSOR_TEST: return context->isScissorTestEnabled();\r
- case GL_STENCIL_TEST: return context->isStencilTestEnabled();\r
- case GL_DEPTH_TEST: return context->isDepthTestEnabled();\r
- case GL_BLEND: return context->isBlendEnabled();\r
- case GL_DITHER: return context->isDitherEnabled();\r
- case GL_ALPHA_TEST: return context->isAlphaTestEnabled();\r
- case GL_CLIP_PLANE0: return context->isClipPlaneEnabled(0);\r
- case GL_CLIP_PLANE1: return context->isClipPlaneEnabled(1);\r
- case GL_CLIP_PLANE2: return context->isClipPlaneEnabled(2);\r
- case GL_CLIP_PLANE3: return context->isClipPlaneEnabled(3);\r
- case GL_CLIP_PLANE4: return context->isClipPlaneEnabled(4);\r
- case GL_CLIP_PLANE5: return context->isClipPlaneEnabled(5);\r
+ case GL_CULL_FACE: return context->isCullFaceEnabled(); break;\r
+ case GL_POLYGON_OFFSET_FILL: return context->isPolygonOffsetFillEnabled(); break;\r
+ case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled(); break;\r
+ case GL_SAMPLE_COVERAGE: return context->isSampleCoverageEnabled(); break;\r
+ case GL_SCISSOR_TEST: return context->isScissorTestEnabled(); break;\r
+ case GL_STENCIL_TEST: return context->isStencilTestEnabled(); break;\r
+ case GL_DEPTH_TEST: return context->isDepthTestEnabled(); break;\r
+ case GL_BLEND: return context->isBlendEnabled(); break;\r
+ case GL_DITHER: return context->isDitherEnabled(); break;\r
+ case GL_LIGHTING: return context->isLightingEnabled(); break;\r
+ case GL_LIGHT0: return context->isLightEnabled(0); break;\r
+ case GL_LIGHT1: return context->isLightEnabled(1); break;\r
+ case GL_LIGHT2: return context->isLightEnabled(2); break;\r
+ case GL_LIGHT3: return context->isLightEnabled(3); break;\r
+ case GL_LIGHT4: return context->isLightEnabled(4); break;\r
+ case GL_LIGHT5: return context->isLightEnabled(5); break;\r
+ case GL_LIGHT6: return context->isLightEnabled(6); break;\r
+ case GL_LIGHT7: return context->isLightEnabled(7); break;\r
+ case GL_FOG: return context->isFogEnabled(); break;\r
+ case GL_TEXTURE_2D: return context->isTexture2Denabled(); break;\r
+ case GL_TEXTURE_EXTERNAL_OES: return context->isTextureExternalEnabled(); break;\r
+ case GL_ALPHA_TEST: return context->isAlphaTestEnabled(); break;\r
+ case GL_COLOR_LOGIC_OP: return context->isColorLogicOpEnabled(); break;\r
+ case GL_POINT_SMOOTH: return context->isPointSmoothEnabled(); break;\r
+ case GL_LINE_SMOOTH: return context->isLineSmoothEnabled(); break;\r
+ case GL_COLOR_MATERIAL: return context->isColorMaterialEnabled(); break;\r
+ case GL_NORMALIZE: return context->isNormalizeEnabled(); break;\r
+ case GL_RESCALE_NORMAL: return context->isRescaleNormalEnabled(); break;\r
+ case GL_VERTEX_ARRAY: return context->isVertexArrayEnabled(); break;\r
+ case GL_NORMAL_ARRAY: return context->isNormalArrayEnabled(); break;\r
+ case GL_COLOR_ARRAY: return context->isColorArrayEnabled(); break;\r
+ case GL_POINT_SIZE_ARRAY_OES: return context->isPointSizeArrayEnabled(); break;\r
+ case GL_TEXTURE_COORD_ARRAY: return context->isTextureCoordArrayEnabled(); break;\r
+ case GL_MULTISAMPLE: return context->isMultisampleEnabled(); break;\r
+ case GL_SAMPLE_ALPHA_TO_ONE: return context->isSampleAlphaToOneEnabled(); break;\r
+ case GL_CLIP_PLANE0: return context->isClipPlaneEnabled(0); break;\r
+ case GL_CLIP_PLANE1: return context->isClipPlaneEnabled(1); break;\r
+ case GL_CLIP_PLANE2: return context->isClipPlaneEnabled(2); break;\r
+ case GL_CLIP_PLANE3: return context->isClipPlaneEnabled(3); break;\r
+ case GL_CLIP_PLANE4: return context->isClipPlaneEnabled(4); break;\r
+ case GL_CLIP_PLANE5: return context->isClipPlaneEnabled(5); break;\r
+ case GL_POINT_SPRITE_OES: return context->isPointSpriteEnabled(); break;\r
default:\r
return error(GL_INVALID_ENUM, GL_FALSE);\r
}\r
\r
void LightModelf(GLenum pname, GLfloat param)\r
{\r
- UNIMPLEMENTED();\r
+ TRACE("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);\r
+\r
+ es1::Context *context = es1::getContext();\r
+\r
+ if(context)\r
+ {\r
+ switch(pname)\r
+ {\r
+ case GL_LIGHT_MODEL_TWO_SIDE:\r
+ context->setLightModelTwoSide(param != 0.0f);\r
+ break;\r
+ case GL_LIGHT_MODEL_AMBIENT:\r
+ return error(GL_INVALID_ENUM); // Need four values, should call glLightModelfv() instead\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+ }\r
}\r
\r
void LightModelfv(GLenum pname, const GLfloat *params)\r
context->setGlobalAmbient(params[0], params[1], params[2], params[3]);\r
break;\r
case GL_LIGHT_MODEL_TWO_SIDE:\r
- UNIMPLEMENTED();\r
+ context->setLightModelTwoSide(params[0] != 0.0f);\r
break;\r
default:\r
return error(GL_INVALID_ENUM);\r
{\r
switch(pname)\r
{\r
- case GL_SPOT_EXPONENT: UNIMPLEMENTED(); break;\r
- case GL_SPOT_CUTOFF: UNIMPLEMENTED(); break;\r
- case GL_CONSTANT_ATTENUATION: context->setLightAttenuationConstant(index, param); break;\r
- case GL_LINEAR_ATTENUATION: context->setLightAttenuationLinear(index, param); break;\r
- case GL_QUADRATIC_ATTENUATION: context->setLightAttenuationQuadratic(index, param); break;\r
+ case GL_SPOT_EXPONENT:\r
+ if(param < 0.0f || param > 128.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setSpotLightExponent(index, param);\r
+ break;\r
+ case GL_SPOT_CUTOFF:\r
+ if((param < 0.0f || param > 90.0f) && param != 180.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setSpotLightCutoff(index, param);\r
+ break;\r
+ case GL_CONSTANT_ATTENUATION:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationConstant(index, param);\r
+ break;\r
+ case GL_LINEAR_ATTENUATION:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationLinear(index, param);\r
+ break;\r
+ case GL_QUADRATIC_ATTENUATION:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationQuadratic(index, param);\r
+ break;\r
+ case GL_AMBIENT:\r
+ case GL_DIFFUSE:\r
+ case GL_SPECULAR:\r
+ case GL_POSITION:\r
+ case GL_SPOT_DIRECTION:\r
+ return error(GL_INVALID_ENUM); // Need four values, should call glLightfv() instead\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
case GL_SPECULAR: context->setLightSpecular(index, params[0], params[1], params[2], params[3]); break;\r
case GL_POSITION: context->setLightPosition(index, params[0], params[1], params[2], params[3]); break;\r
case GL_SPOT_DIRECTION: context->setLightDirection(index, params[0], params[1], params[2]); break;\r
- case GL_SPOT_EXPONENT: UNIMPLEMENTED(); break;\r
- case GL_SPOT_CUTOFF: UNIMPLEMENTED(); break;\r
- case GL_CONSTANT_ATTENUATION: context->setLightAttenuationConstant(index, params[0]); break;\r
- case GL_LINEAR_ATTENUATION: context->setLightAttenuationLinear(index, params[0]); break;\r
- case GL_QUADRATIC_ATTENUATION: context->setLightAttenuationQuadratic(index, params[0]); break;\r
+ case GL_SPOT_EXPONENT:\r
+ if(params[0] < 0.0f || params[0] > 128.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setSpotLightExponent(index, params[0]);\r
+ break;\r
+ case GL_SPOT_CUTOFF:\r
+ if((params[0] < 0.0f || params[0] > 90.0f) && params[0] != 180.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setSpotLightCutoff(index, params[0]);\r
+ break;\r
+ case GL_CONSTANT_ATTENUATION:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationConstant(index, params[0]);\r
+ break;\r
+ case GL_LINEAR_ATTENUATION:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationLinear(index, params[0]);\r
+ break;\r
+ case GL_QUADRATIC_ATTENUATION:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setLightAttenuationQuadratic(index, params[0]);\r
+ break;\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
\r
void LogicOp(GLenum opcode)\r
{\r
- UNIMPLEMENTED();\r
+ TRACE("(GLenum opcode = 0x%X)", opcode);\r
+\r
+ switch(opcode)\r
+ {\r
+ case GL_CLEAR:\r
+ case GL_SET:\r
+ case GL_COPY:\r
+ case GL_COPY_INVERTED:\r
+ case GL_NOOP:\r
+ case GL_INVERT:\r
+ case GL_AND:\r
+ case GL_NAND:\r
+ case GL_OR:\r
+ case GL_NOR:\r
+ case GL_XOR:\r
+ case GL_EQUIV:\r
+ case GL_AND_REVERSE:\r
+ case GL_AND_INVERTED:\r
+ case GL_OR_REVERSE:\r
+ case GL_OR_INVERTED:\r
+ break;\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+\r
+ es1::Context *context = es1::getContext();\r
+\r
+ if(context)\r
+ {\r
+ context->setLogicalOperation(opcode);\r
+ }\r
}\r
\r
void Materialf(GLenum face, GLenum pname, GLfloat param)\r
switch(pname)\r
{\r
case GL_SHININESS:\r
+ if(param < 0.0f || param > 128.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
context->setMaterialShininess(param);\r
break;\r
+ case GL_AMBIENT:\r
+ case GL_DIFFUSE:\r
+ case GL_AMBIENT_AND_DIFFUSE:\r
+ case GL_SPECULAR:\r
+ case GL_EMISSION:\r
+ return error(GL_INVALID_ENUM); // Need four values, should call glMaterialfv() instead\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
\r
void PointParameterf(GLenum pname, GLfloat param)\r
{\r
- UNIMPLEMENTED();\r
+ TRACE("(GLenum pname = 0x%X, GLfloat param = %f)", pname, param);\r
+\r
+ es1::Context *context = es1::getContext();\r
+\r
+ if(context)\r
+ {\r
+ switch(pname)\r
+ {\r
+ case GL_POINT_SIZE_MIN:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointSizeMin(param);\r
+ break;\r
+ case GL_POINT_SIZE_MAX:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointSizeMax(param);\r
+ break;\r
+ case GL_POINT_FADE_THRESHOLD_SIZE:\r
+ if(param < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointFadeThresholdSize(param);\r
+ break;\r
+ case GL_POINT_DISTANCE_ATTENUATION:\r
+ return error(GL_INVALID_ENUM); // Needs three values, should call glPointParameterfv() instead\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+ }\r
}\r
\r
void PointParameterfv(GLenum pname, const GLfloat *params)\r
{\r
- UNIMPLEMENTED();\r
+ TRACE("(GLenum pname = 0x%X, const GLfloat *params)", pname);\r
+\r
+ es1::Context *context = es1::getContext();\r
+\r
+ if(context)\r
+ {\r
+ switch(pname)\r
+ {\r
+ case GL_POINT_SIZE_MIN:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointSizeMin(params[0]);\r
+ break;\r
+ case GL_POINT_SIZE_MAX:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointSizeMax(params[0]);\r
+ break;\r
+ case GL_POINT_DISTANCE_ATTENUATION:\r
+ context->setPointDistanceAttenuation(params[0], params[1], params[2]);\r
+ break;\r
+ case GL_POINT_FADE_THRESHOLD_SIZE:\r
+ if(params[0] < 0.0f)\r
+ {\r
+ return error(GL_INVALID_VALUE);\r
+ }\r
+ context->setPointFadeThresholdSize(params[0]);\r
+ break;\r
+ default:\r
+ return error(GL_INVALID_ENUM);\r
+ }\r
+ }\r
}\r
\r
void PointParameterx(GLenum pname, GLfixed param)\r
case GL_GENERATE_MIPMAP:\r
texture->setGenerateMipmap((GLboolean)param);\r
break;\r
+ case GL_TEXTURE_CROP_RECT_OES:\r
+ return error(GL_INVALID_ENUM); // Needs four values, should call glTexParameterfv() instead\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
case GL_GENERATE_MIPMAP:\r
texture->setGenerateMipmap((GLboolean)param);\r
break;\r
+ case GL_TEXTURE_CROP_RECT_OES:\r
+ return error(GL_INVALID_ENUM); // Needs four values, should call glTexParameteriv() instead\r
default:\r
return error(GL_INVALID_ENUM);\r
}\r
switch(texFormat)\r
{\r
case GL_LUMINANCE:\r
- case GL_RGB:
+ case GL_RGB:\r
case GL_RGB565_OES: // GL_OES_framebuffer_object\r
case GL_RGB8_OES: // GL_OES_rgb8_rgba8\r
return true;\r
case GL_LUMINANCE_ALPHA:\r
case GL_RGBA:\r
case GL_BGRA_EXT: // GL_EXT_texture_format_BGRA8888\r
- case GL_RGBA4_OES: // GL_OES_framebuffer_object
+ case GL_RGBA4_OES: // GL_OES_framebuffer_object\r
case GL_RGB5_A1_OES: // GL_OES_framebuffer_object\r
case GL_RGBA8_OES: // GL_OES_rgb8_rgba8\r
return true;\r
return sw::BLENDOP_ADD;\r
}\r
\r
+ sw::LogicalOperation ConvertLogicalOperation(GLenum logicalOperation)\r
+ {\r
+ switch(logicalOperation)\r
+ {\r
+ case GL_CLEAR: return sw::LOGICALOP_CLEAR;\r
+ case GL_SET: return sw::LOGICALOP_SET;\r
+ case GL_COPY: return sw::LOGICALOP_COPY;\r
+ case GL_COPY_INVERTED: return sw::LOGICALOP_COPY_INVERTED;\r
+ case GL_NOOP: return sw::LOGICALOP_NOOP;\r
+ case GL_INVERT: return sw::LOGICALOP_INVERT;\r
+ case GL_AND: return sw::LOGICALOP_AND;\r
+ case GL_NAND: return sw::LOGICALOP_NAND;\r
+ case GL_OR: return sw::LOGICALOP_OR;\r
+ case GL_NOR: return sw::LOGICALOP_NOR;\r
+ case GL_XOR: return sw::LOGICALOP_XOR;\r
+ case GL_EQUIV: return sw::LOGICALOP_EQUIV;\r
+ case GL_AND_REVERSE: return sw::LOGICALOP_AND_REVERSE;\r
+ case GL_AND_INVERTED: return sw::LOGICALOP_AND_INVERTED;\r
+ case GL_OR_REVERSE: return sw::LOGICALOP_OR_REVERSE;\r
+ case GL_OR_INVERTED: return sw::LOGICALOP_OR_INVERTED;\r
+ default: UNREACHABLE(logicalOperation);\r
+ }\r
+\r
+ return sw::LOGICALOP_COPY;\r
+ }\r
+\r
sw::StencilOperation ConvertStencilOp(GLenum stencilOp)\r
{\r
switch(stencilOp)\r
sampleMask = 0xFFFFFFFF;
colorLogicOpEnabled = false;
- logicalOperation = LogicalOperation::LOGICALOP_COPY;
+ logicalOperation = LOGICALOP_COPY;
}
const float &Context::exp2Bias()
LogicalOperation Context::colorLogicOp()
{
- return colorLogicOpEnabled ? logicalOperation : LogicalOperation::LOGICALOP_COPY;
+ return colorLogicOpEnabled ? logicalOperation : LOGICALOP_COPY;
}
BlendFactor Context::sourceBlendFactor()
void PixelRoutine::logicOperation(Registers &r, int index, Pointer<Byte> &cBuffer, Vector4s ¤t, Int &x)
{
- if(state.logicalOperation == LogicalOperation::LOGICALOP_COPY)
+ if(state.logicalOperation == LOGICALOP_COPY)
{
return;
}
current.z = 0;
break;
case LOGICALOP_SET:
- current.x = 0xFFFF;
- current.y = 0xFFFF;
- current.z = 0xFFFF;
+ current.x = 0xFFFFu;
+ current.y = 0xFFFFu;
+ current.z = 0xFFFFu;
break;
case LOGICALOP_COPY:
ASSERT(false); // Optimized out
OSDN Git Service
