protected internal virtual void copy(BaseRenderer from)
{
imageWriterSkipEOL = from.imageWriterSkipEOL;
depthWriterSkipEOL = from.depthWriterSkipEOL;
compiledRendererKey = from.compiledRendererKey;
compiledRenderer = from.compiledRenderer;
lighting = from.lighting;
textureAccess = from.textureAccess;
transform2D = from.transform2D;
nearZ = from.nearZ;
farZ = from.farZ;
scissorX1 = from.scissorX1;
scissorY1 = from.scissorY1;
scissorX2 = from.scissorX2;
scissorY2 = from.scissorY2;
cachedTexture = from.cachedTexture;
isTriangle = from.isTriangle;
colorTestRef = from.colorTestRef;
colorTestMsk = from.colorTestMsk;
alphaRef = from.alphaRef;
alphaMask = from.alphaMask;
stencilRef = from.stencilRef;
stencilMask = from.stencilMask;
sfix = from.sfix;
dfix = from.dfix;
colorMask = from.colorMask;
primaryColorSetGlobally = from.primaryColorSetGlobally;
texTranslateX = from.texTranslateX;
texTranslateY = from.texTranslateY;
texScaleX = from.texScaleX;
texScaleY = from.texScaleY;
textureWidth = from.textureWidth;
textureHeight = from.textureHeight;
texEnvColorB = from.texEnvColorB;
texEnvColorG = from.texEnvColorG;
texEnvColorR = from.texEnvColorR;
envMapLightPosU = from.envMapLightPosU;
envMapLightPosV = from.envMapLightPosV;
envMapDiffuseLightU = from.envMapDiffuseLightU;
envMapDiffuseLightV = from.envMapDiffuseLightV;
envMapShininess = from.envMapShininess;
texMinFilter = from.texMinFilter;
texMagFilter = from.texMagFilter;
primaryColor = from.primaryColor;
ditherMatrix = from.ditherMatrix;
}
private LongLongKey getBaseRendererKey(GeContext context)
{
LongLongKey key = new LongLongKey();
key.addKeyComponent(RuntimeContext.hasMemoryInt());
key.addKeyComponent(transform2D);
key.addKeyComponent(clearMode);
if (clearMode)
{
key.addKeyComponent(context.clearModeColor);
key.addKeyComponent(context.clearModeStencil);
key.addKeyComponent(context.clearModeDepth);
}
else
{
key.addKeyComponent(false);
key.addKeyComponent(false);
key.addKeyComponent(false);
}
key.addKeyComponent(nearZ == 0x0000);
key.addKeyComponent(farZ == 0xFFFF);
key.addKeyComponent(context.colorTestFlag.Enabled ? context.colorTestFunc : GeCommands.CTST_COLOR_FUNCTION_ALWAYS_PASS_PIXEL, 2);
if (context.alphaTestFlag.Enabled)
{
key.addKeyComponent(context.alphaFunc, 3);
key.addKeyComponent(context.alphaRef == 0x00);
key.addKeyComponent(context.alphaRef == 0xFF);
}
else
{
key.addKeyComponent(GeCommands.ATST_ALWAYS_PASS_PIXEL, 3);
key.addKeyComponent(false);
key.addKeyComponent(false);
}
if (context.stencilTestFlag.Enabled)
{
key.addKeyComponent(context.stencilFunc, 3);
key.addKeyComponent(context.stencilOpFail, 3);
key.addKeyComponent(context.stencilOpZFail, 3);
key.addKeyComponent(context.stencilOpZPass, 3);
}
else
{
key.addKeyComponent(GeCommands.STST_FUNCTION_ALWAYS_PASS_STENCIL_TEST, 3);
// Use invalid stencil operations
key.addKeyComponent(7, 3);
key.addKeyComponent(7, 3);
key.addKeyComponent(7, 3);
}
key.addKeyComponent(context.depthTestFlag.Enabled ? context.depthFunc : GeCommands.ZTST_FUNCTION_ALWAYS_PASS_PIXEL, 3);
if (context.blendFlag.Enabled)
{
key.addKeyComponent(context.blendEquation, 3);
key.addKeyComponent(context.blend_src, 4);
key.addKeyComponent(context.blend_dst, 4);
key.addKeyComponent(context.sfix == 0x000000);
key.addKeyComponent(context.sfix == 0xFFFFFF);
key.addKeyComponent(context.dfix == 0x000000);
key.addKeyComponent(context.dfix == 0xFFFFFF);
}
else
{
// Use an invalid blend equation value
key.addKeyComponent(7, 3);
key.addKeyComponent(15, 4);
key.addKeyComponent(15, 4);
key.addKeyComponent(false);
key.addKeyComponent(false);
key.addKeyComponent(false);
key.addKeyComponent(false);
}
key.addKeyComponent(context.colorLogicOpFlag.Enabled ? context.logicOp : GeCommands.LOP_COPY, 4);
key.addKeyComponent(PixelColor.getColor(context.colorMask) == 0x00000000);
key.addKeyComponent(context.depthMask);
key.addKeyComponent(context.textureFlag.Enabled);
key.addKeyComponent(useVertexTexture);
key.addKeyComponent(context.lightingFlag.Enabled);
key.addKeyComponent(setVertexPrimaryColor);
key.addKeyComponent(primaryColorSetGlobally);
key.addKeyComponent(isTriangle);
key.addKeyComponent(context.mat_flags, 3);
key.addKeyComponent(context.useVertexColor);
key.addKeyComponent(context.textureColorDoubled);
key.addKeyComponent(context.lightMode, 1);
key.addKeyComponent(context.tex_map_mode, 2);
if (context.tex_map_mode == GeCommands.TMAP_TEXTURE_MAP_MODE_TEXTURE_MATRIX)
{
key.addKeyComponent(context.tex_proj_map_mode, 2);
}
else
{
key.addKeyComponent(0, 2);
}
key.addKeyComponent(context.tex_translate_x == 0f);
key.addKeyComponent(context.tex_translate_y == 0f);
key.addKeyComponent(context.tex_scale_x == 1f);
key.addKeyComponent(context.tex_scale_y == 1f);
key.addKeyComponent(context.tex_wrap_s, 1);
key.addKeyComponent(context.tex_wrap_t, 1);
key.addKeyComponent(context.textureFunc, 3);
key.addKeyComponent(context.textureAlphaUsed);
key.addKeyComponent(context.psm, 2);
key.addKeyComponent(context.tex_min_filter, 3);
key.addKeyComponent(context.tex_mag_filter, 1);
key.addKeyComponent(isLogTraceEnabled);
key.addKeyComponent(DurationStatistics.collectStatistics);
key.addKeyComponent(context.ditherFlag.Enabled);
return(key);
}
protected internal virtual void initRendering(GeContext context)
{
if (renderingInitialized)
{
return;
}
fbp = getFrameBufferAddress(context.fbp);
psm = context.psm;
zbp = getFrameBufferAddress(context.zbp);
colorTestRef = getColorBGR(context.colorTestRef);
colorTestMsk = getColorBGR(context.colorTestMsk);
alphaRef = context.alphaRef & context.alphaMask;
alphaMask = context.alphaMask;
stencilRef = context.stencilRef & context.stencilMask;
stencilMask = context.stencilMask;
sfix = context.sfix;
dfix = context.dfix;
colorMask = getColor(context.colorMask);
textureWidth = context.texture_width[mipmapLevel];
textureHeight = context.texture_height[mipmapLevel];
texEnvColorB = getColor(context.tex_env_color[2]);
texEnvColorG = getColor(context.tex_env_color[1]);
texEnvColorR = getColor(context.tex_env_color[0]);
texMinFilter = context.tex_min_filter;
texMagFilter = context.tex_mag_filter;
primaryColor = getColor(context.vertexColor);
baseRendererKey = getBaseRendererKey(context);
if (!transform2D && context.lightingFlag.Enabled)
{
lighting = new Lighting(context.view_uploaded_matrix, context.mat_emissive, context.ambient_light, context.lightFlags, context.light_pos, context.light_kind, context.light_type, context.lightAmbientColor, context.lightDiffuseColor, context.lightSpecularColor, context.lightConstantAttenuation, context.lightLinearAttenuation, context.lightQuadraticAttenuation, context.spotLightCutoff, context.spotLightCosCutoff, context.light_dir, context.spotLightExponent, context.materialShininess, context.lightMode, context.vinfo.normal != 0);
}
// Is the lighting model using the material color from the vertex color?
if (!transform2D && context.lightingFlag.Enabled && context.mat_flags != 0 && context.useVertexColor && context.vinfo.color != 0 && isTriangle)
{
setVertexPrimaryColor = true;
}
primaryColorSetGlobally = false;
if (transform2D || !context.lightingFlag.Enabled)
{
// No lighting, take the primary color from the vertex.
// This will be done by the BasePrimitiveRenderer when the vertices are known.
if (context.useVertexColor && context.vinfo.color != 0)
{
setVertexPrimaryColor = true;
if (!isTriangle)
{
// Use the color of the 2nd sprite vertex
primaryColorSetGlobally = true;
}
}
else
{
// Use context.vertexColor as the primary color
primaryColorSetGlobally = true;
}
}
textureAccess = null;
if (isUsingTexture(context))
{
int textureBufferWidth = VideoEngine.alignBufferWidth(context.texture_buffer_width[mipmapLevel], context.texture_storage);
int textureHeight = context.texture_height[mipmapLevel];
int textureAddress = context.texture_base_pointer[mipmapLevel];
if (cachedTexture == null)
{
int[] clut32 = VideoEngine.Instance.readClut32(mipmapLevel);
short[] clut16 = VideoEngine.Instance.readClut16(mipmapLevel);
// Always request the whole buffer width
IMemoryReader imageReader = ImageReader.getImageReader(textureAddress, textureBufferWidth, textureHeight, textureBufferWidth, context.texture_storage, context.texture_swizzle, context.tex_clut_addr, context.tex_clut_mode, context.tex_clut_num_blocks, context.tex_clut_start, context.tex_clut_shift, context.tex_clut_mask, clut32, clut16);
textureAccess = new RandomTextureAccessReader(imageReader, textureBufferWidth, textureHeight);
}
else
{
textureAccess = cachedTexture.OriginalTexture;
}
// Avoid an access outside the texture area
textureAccess = TextureClip.getTextureClip(context, mipmapLevel, textureAccess, textureBufferWidth, textureHeight);
}
renderingInitialized = true;
}
private RendererTemplate compileRenderer(BasePrimitiveRenderer renderer, LongLongKey id, GeContext context)
{
if (log.InfoEnabled)
{
Console.WriteLine(string.Format("Compiling Renderer {0}", id));
}
Dictionary <string, object> variables = new Dictionary <string, object>();
// All these variables have to be defined as static members in the class RendererTemplate.
variables["hasMemInt"] = Convert.ToBoolean(RuntimeContext.hasMemoryInt());
variables["transform2D"] = Convert.ToBoolean(renderer.transform2D);
variables["clearMode"] = Convert.ToBoolean(renderer.clearMode);
variables["clearModeColor"] = Convert.ToBoolean(context.clearModeColor);
variables["clearModeStencil"] = Convert.ToBoolean(context.clearModeStencil);
variables["clearModeDepth"] = Convert.ToBoolean(context.clearModeDepth);
variables["needSourceDepthRead"] = Convert.ToBoolean(renderer.needSourceDepthRead);
variables["needDestinationDepthRead"] = Convert.ToBoolean(renderer.needDestinationDepthRead);
variables["needDepthWrite"] = Convert.ToBoolean(renderer.needDepthWrite);
variables["needTextureUV"] = Convert.ToBoolean(renderer.needTextureUV);
variables["simpleTextureUV"] = Convert.ToBoolean(renderer.simpleTextureUV);
variables["swapTextureUV"] = Convert.ToBoolean(renderer.swapTextureUV);
variables["needScissoringX"] = Convert.ToBoolean(renderer.needScissoringX);
variables["needScissoringY"] = Convert.ToBoolean(renderer.needScissoringY);
variables["nearZ"] = new int?(renderer.nearZ);
variables["farZ"] = new int?(renderer.farZ);
variables["colorTestFlagEnabled"] = Convert.ToBoolean(context.colorTestFlag.Enabled);
variables["colorTestFunc"] = new int?(context.colorTestFunc);
variables["alphaTestFlagEnabled"] = Convert.ToBoolean(context.alphaTestFlag.Enabled);
variables["alphaFunc"] = new int?(context.alphaFunc);
variables["alphaRef"] = new int?(context.alphaRef);
variables["alphaMask"] = new int?(context.alphaMask);
variables["stencilTestFlagEnabled"] = Convert.ToBoolean(context.stencilTestFlag.Enabled);
variables["stencilFunc"] = new int?(context.stencilFunc);
variables["stencilOpFail"] = new int?(context.stencilOpFail);
variables["stencilOpZFail"] = new int?(context.stencilOpZFail);
variables["stencilOpZPass"] = new int?(context.stencilOpZPass);
variables["stencilRef"] = new int?(context.stencilRef);
variables["depthTestFlagEnabled"] = Convert.ToBoolean(context.depthTestFlag.Enabled);
variables["depthFunc"] = new int?(context.depthFunc);
variables["blendFlagEnabled"] = Convert.ToBoolean(context.blendFlag.Enabled);
variables["blendEquation"] = new int?(context.blendEquation);
variables["blendSrc"] = new int?(context.blend_src);
variables["blendDst"] = new int?(context.blend_dst);
variables["sfix"] = new int?(context.sfix);
variables["dfix"] = new int?(context.dfix);
variables["colorLogicOpFlagEnabled"] = Convert.ToBoolean(context.colorLogicOpFlag.Enabled);
variables["logicOp"] = new int?(context.logicOp);
variables["colorMask"] = new int?(PixelColor.getColor(context.colorMask));
variables["depthMask"] = Convert.ToBoolean(context.depthMask);
variables["textureFlagEnabled"] = Convert.ToBoolean(context.textureFlag.Enabled);
variables["useVertexTexture"] = Convert.ToBoolean(renderer.useVertexTexture);
variables["lightingFlagEnabled"] = Convert.ToBoolean(context.lightingFlag.Enabled);
variables["sameVertexColor"] = Convert.ToBoolean(renderer.sameVertexColor);
variables["setVertexPrimaryColor"] = Convert.ToBoolean(renderer.setVertexPrimaryColor);
variables["primaryColorSetGlobally"] = Convert.ToBoolean(renderer.primaryColorSetGlobally);
variables["isTriangle"] = Convert.ToBoolean(renderer.isTriangle);
variables["matFlagAmbient"] = Convert.ToBoolean((context.mat_flags & CMAT_FLAG_AMBIENT) != 0);
variables["matFlagDiffuse"] = Convert.ToBoolean((context.mat_flags & CMAT_FLAG_DIFFUSE) != 0);
variables["matFlagSpecular"] = Convert.ToBoolean((context.mat_flags & CMAT_FLAG_SPECULAR) != 0);
variables["useVertexColor"] = Convert.ToBoolean(context.useVertexColor);
variables["textureColorDoubled"] = Convert.ToBoolean(context.textureColorDoubled);
variables["lightMode"] = new int?(context.lightMode);
variables["texMapMode"] = new int?(context.tex_map_mode);
variables["texProjMapMode"] = new int?(context.tex_proj_map_mode);
variables["texTranslateX"] = new float?(context.tex_translate_x);
variables["texTranslateY"] = new float?(context.tex_translate_y);
variables["texScaleX"] = new float?(context.tex_scale_x);
variables["texScaleY"] = new float?(context.tex_scale_y);
variables["texWrapS"] = new int?(context.tex_wrap_s);
variables["texWrapT"] = new int?(context.tex_wrap_t);
variables["textureFunc"] = new int?(context.textureFunc);
variables["textureAlphaUsed"] = Convert.ToBoolean(context.textureAlphaUsed);
variables["psm"] = new int?(context.psm);
variables["texMagFilter"] = new int?(context.tex_mag_filter);
variables["needTextureWrapU"] = Convert.ToBoolean(renderer.needTextureWrapU);
variables["needTextureWrapV"] = Convert.ToBoolean(renderer.needTextureWrapV);
variables["needSourceDepthClamp"] = Convert.ToBoolean(renderer.needSourceDepthClamp);
variables["isLogTraceEnabled"] = Convert.ToBoolean(renderer.isLogTraceEnabled);
variables["collectStatistics"] = Convert.ToBoolean(DurationStatistics.collectStatistics);
variables["ditherFlagEnabled"] = Convert.ToBoolean(context.ditherFlag.Enabled);
string specializedClassName = NewCompiledRendererClassName;
ClassSpecializer cs = new ClassSpecializer();
Type specializedClass = cs.specialize(specializedClassName, typeof(RendererTemplate), variables);
RendererTemplate compiledRenderer = null;
if (specializedClass != null)
{
try
{
compiledRenderer = (RendererTemplate)System.Activator.CreateInstance(specializedClass);
}
catch (InstantiationException e)
{
Console.WriteLine("Error while instanciating compiled renderer", e);
}
catch (IllegalAccessException e)
{
Console.WriteLine("Error while instanciating compiled renderer", e);
}
}
return(compiledRenderer);
}
public virtual RendererTemplate getCompiledRenderer(BasePrimitiveRenderer renderer, LongLongKey id, GeContext context)
{
RendererTemplate compiledRenderer = compiledRenderers[id];
if (compiledRenderer == null)
{
compiledRenderer = compileRenderer(renderer, id, context);
if (compiledRenderer != null)
{
compiledRenderers[id] = compiledRenderer;
}
}
return(compiledRenderer);
}
private void setVertexTextures(GeContext context, float[] c1, float[] c2, float[] c3)
{
textureWidth = context.texture_width[mipmapLevel];
textureHeight = context.texture_height[mipmapLevel];
// The rendering will be performed into the following ranges:
// 3D:
// - x: [pxMin..pxMax] (min and max included)
// - y: [pxMin..pxMax] (min and max included)
// 2D:
// - x: [pxMin..pxMax-1] (min included but max excluded)
// - y: [pxMin..pxMax-1] (min included but max excluded)
if (transform2D)
{
prim.pxMax--;
prim.pyMax--;
}
else
{
// Restrict the drawn area to the scissor area.
// We can just update the min/max values, the TextureMapping filter
// will take are of the correct texture mapping.
// We do no longer need a scissoring filter.
if (needScissoringX)
{
prim.pxMin = max(prim.pxMin, scissorX1);
prim.pxMax = min(prim.pxMax, scissorX2);
needScissoringX = false;
}
if (needScissoringY)
{
prim.pyMin = max(prim.pyMin, scissorY1);
prim.pyMax = min(prim.pyMax, scissorY2);
needScissoringY = false;
}
}
prim.destinationWidth = prim.pxMax - prim.pxMin + 1;
prim.destinationHeight = prim.pyMax - prim.pyMin + 1;
if (isUsingTexture(context))
{
simpleTextureUV = !isTriangle;
if (!simpleTextureUV && isTriangle && transform2D)
{
// Check if the 2D triangle can be rendered using a simple texture UV mapping:
// this is only possible when the triangle has a square angle.
//
// 1---2 1---2 1 1
// | / \ | | \ / |
// | / \ | | \ / |
// 3 3 3---2 3---2
//
// 1---3 1---3 1 1
// | / \ | | \ / |
// | / \ | | \ / |
// 2 2 2---3 2---3
//
if (prim.p1x == prim.p2x && prim.t1u == prim.t2u)
{
if (prim.p1y == prim.p3y && prim.t1v == prim.t3v)
{
simpleTextureUV = true;
}
else if (prim.p2y == prim.p3y && prim.t2v == prim.t3v)
{
simpleTextureUV = true;
}
}
else if (prim.p1x == prim.p3x && prim.t1u == prim.t3u)
{
if (prim.p1y == prim.p2y && prim.t1v == prim.t2v)
{
simpleTextureUV = true;
}
else if (prim.p2y == prim.p3y && prim.t2v == prim.t3v)
{
simpleTextureUV = true;
}
}
else if (prim.p2x == prim.p3x && prim.t2u == prim.t3u)
{
if (prim.p1y == prim.p2y && prim.t1v == prim.t2v)
{
simpleTextureUV = true;
}
else if (prim.p1y == prim.p1y && prim.t2v == prim.t3v)
{
simpleTextureUV = true;
}
}
}
if (simpleTextureUV)
{
if (transform2D)
{
bool flipX = false;
bool flipY = false;
if (isTriangle)
{
// Compute texture flips for a triangle
if (prim.t1u != prim.t2u)
{
flipX = (prim.t1u > prim.t2u) ^ (prim.p1x > prim.p2x);
}
if (prim.t1v != prim.t2v)
{
flipY = (prim.t1v > prim.t2v) ^ (prim.p1y > prim.p2y);
}
if (!flipX && prim.t2u != prim.t3u)
{
flipX = (prim.t2u > prim.t3u) ^ (prim.p2x > prim.p3x);
}
if (!flipY && prim.t2v != prim.t3v)
{
flipY = (prim.t2v > prim.t3v) ^ (prim.p2y > prim.p3y);
}
}
else
{
// Compute texture flips for a sprite
flipX = (prim.t1u > prim.t2u) ^ (prim.p1x > prim.p2x);
flipY = (prim.t1v > prim.t2v) ^ (prim.p1y > prim.p2y);
if (flipX && flipY)
{
swapTextureUV = true;
flipX = false;
flipY = false;
}
}
if (isLogTraceEnabled)
{
//JAVA TO C# CONVERTER TODO TASK: The following line has a Java format specifier which cannot be directly translated to .NET:
//ORIGINAL LINE: log.trace(String.format("2D texture flipX=%b, flipY=%b, swapUV=%b, point (%d,%d)-(%d,%d), texture (%d,%d)-(%d,%d)", flipX, flipY, swapTextureUV, prim.pxMin, prim.pyMin, prim.pxMax, prim.pyMax, prim.tuMin, prim.tvMin, prim.tuMax, prim.tvMax));
log.trace(string.Format("2D texture flipX=%b, flipY=%b, swapUV=%b, point (%d,%d)-(%d,%d), texture (%d,%d)-(%d,%d)", flipX, flipY, swapTextureUV, prim.pxMin, prim.pyMin, prim.pxMax, prim.pyMax, prim.tuMin, prim.tvMin, prim.tuMax, prim.tvMax));
}
prim.uStart = flipX ? prim.tuMax : prim.tuMin;
float uEnd = flipX ? prim.tuMin : prim.tuMax;
prim.vStart = flipY ? prim.tvMax : prim.tvMin;
float vEnd = flipY ? prim.tvMin : prim.tvMax;
prim.uStep = (uEnd - prim.uStart) / (swapTextureUV ? prim.destinationHeight : prim.destinationWidth);
prim.vStep = (vEnd - prim.vStart) / (swapTextureUV ? prim.destinationWidth : prim.destinationHeight);
}
else
{
// 3D sprite
prim.uStart = prim.t1u;
float uEnd = prim.t2u;
prim.vStart = prim.t1v;
float vEnd = prim.t2v;
if (prim.p1x == prim.p2x)
{
prim.uStep = 1f;
}
else
{
prim.uStep = (uEnd - prim.uStart) / System.Math.Abs(prim.p2x - prim.p1x);
}
if (prim.p1y == prim.p2y)
{
prim.vStep = 1f;
}
else
{
prim.vStep = (vEnd - prim.vStart) / System.Math.Abs(prim.p2y - prim.p1y);
}
if (isLogTraceEnabled)
{
log.trace(string.Format("3D sprite uStart={0:F}, uStep={1:F}, vStart={2:F}, vStep={3:F}, texTranslateX={4:F}, texTranslateY={5:F}, texScaleX={6:F}, texScaleY={7:F}, point ({8:D},{9:D})-({10:D},{11:D}), texture ({12:D},{13:D})-({14:D},{15:D})", prim.uStart, prim.uStep, prim.vStart, prim.vStep, texTranslateX, texTranslateY, texScaleX, texScaleY, prim.pxMin, prim.pyMin, prim.pxMax, prim.pyMax, prim.tuMin, prim.tvMin, prim.tuMax, prim.tvMax));
}
}
// Perform scissoring and update uStart/uStep and vStart/vStep
if (needScissoringX)
{
int deltaX = scissorX1 - prim.pxMin;
if (deltaX > 0)
{
prim.uStart += prim.uStep * deltaX;
prim.pxMin += deltaX;
if (transform2D)
{
prim.tuMin += Round(prim.uStep * deltaX);
}
}
deltaX = prim.pxMax - scissorX2;
if (deltaX > 0)
{
prim.pxMax -= deltaX;
if (transform2D)
{
prim.tuMax -= Round(prim.uStep * deltaX);
}
}
prim.destinationWidth = prim.pxMax - prim.pxMin + 1;
needScissoringX = false;
}
if (needScissoringY)
{
int deltaY = scissorY1 - prim.pyMin;
if (deltaY > 0)
{
prim.vStart += prim.vStep * deltaY;
prim.pyMin += deltaY;
if (transform2D)
{
prim.tvMin += Round(prim.vStep * deltaY);
}
}
deltaY = prim.pyMax - scissorY2;
if (deltaY > 0)
{
prim.pyMax -= deltaY;
if (transform2D)
{
prim.tvMax -= Round(prim.vStep * deltaY);
}
}
prim.destinationHeight = prim.pyMax - prim.pyMin + 1;
needScissoringY = false;
}
}
}
if (setVertexPrimaryColor)
{
if (c3 != null)
{
pixel.c1a = getColor(c1[3]);
pixel.c1b = getColor(c1[2]);
pixel.c1g = getColor(c1[1]);
pixel.c1r = getColor(c1[0]);
pixel.c2a = getColor(c2[3]);
pixel.c2b = getColor(c2[2]);
pixel.c2g = getColor(c2[1]);
pixel.c2r = getColor(c2[0]);
pixel.c3a = getColor(c3[3]);
pixel.c3b = getColor(c3[2]);
pixel.c3g = getColor(c3[1]);
pixel.c3r = getColor(c3[0]);
pixel.c3 = getColor(c3);
}
if (isTriangle)
{
if (context.shadeModel == GeCommands.SHADE_TYPE_FLAT)
{
// Flat shade model: always use the color of the 3rd triangle vertex
sameVertexColor = true;
}
else
{
sameVertexColor = Utilities.sameColor(c1, c2, c3);
}
// For triangles, take the weighted color from the 3 vertices.
}
else
{
// For sprites, take only the color from the 2nd vertex
primaryColor = getColor(c2);
if (context.textureColorDoubled)
{
primaryColor = doubleColor(primaryColor);
}
}
}
// Try to avoid to compute expensive values
needDepthWrite = getNeedDepthWrite(context);
needSourceDepthRead = needDepthWrite || getNeedSourceDepthRead(context);
needDestinationDepthRead = getNeedDestinationDepthRead(context, needDepthWrite);
if (zbw <= 0)
{
needDepthWrite = false;
needSourceDepthRead = false;
needDestinationDepthRead = false;
}
needTextureUV = getNeedTextureUV(context);
if (transform2D)
{
needTextureWrapU = prim.tuMin < 0 || prim.tuMax >= context.texture_width[mipmapLevel];
needTextureWrapV = prim.tvMin < 0 || prim.tvMax >= context.texture_height[mipmapLevel];
}
else
{
if (context.tex_map_mode != GeCommands.TMAP_TEXTURE_MAP_MODE_TEXTURE_COORDIATES_UV)
{
needTextureWrapU = true;
needTextureWrapV = true;
}
else if (isTriangle && (prim.p1w <= 0f || prim.p2w <= 0f || prim.p3w <= 0f))
{
// Need texture wrapping if one triangle point is behind the eye:
// the texture coordinates might exceed the calculated range due to the perspective correction.
needTextureWrapU = true;
needTextureWrapV = true;
}
else
{
float tuMin, tuMax;
float tvMin, tvMax;
if (isTriangle)
{
tuMin = Utilities.min(prim.t1u, Utilities.min(prim.t2u, prim.t3u));
tuMax = Utilities.max(prim.t1u, Utilities.max(prim.t2u, prim.t3u));
tvMin = Utilities.min(prim.t1v, Utilities.min(prim.t2v, prim.t3v));
tvMax = Utilities.max(prim.t1v, Utilities.max(prim.t2v, prim.t3v));
}
else
{
tuMin = Utilities.min(prim.t1u, prim.t2u);
tuMax = Utilities.max(prim.t1u, prim.t2u);
tvMin = Utilities.min(prim.t1v, prim.t2v);
tvMax = Utilities.max(prim.t1v, prim.t2v);
}
tuMin = tuMin * texScaleX + texTranslateX;
tuMax = tuMax * texScaleX + texTranslateX;
tvMin = tvMin * texScaleY + texTranslateY;
tvMax = tvMax * texScaleY + texTranslateY;
needTextureWrapU = tuMin < 0f || tuMin >= 0.99999f || tuMax < 0f || tuMax >= 0.99999f;
needTextureWrapV = tvMin < 0f || tvMin >= 0.99999f || tvMax < 0f || tvMax >= 0.99999f;
}
}
needSourceDepthClamp = false;
if (needDepthWrite && needSourceDepthRead && isTriangle)
{
if (prim.p1z < 0f || prim.p2z < 0f || prim.p3z < 0f)
{
needSourceDepthClamp = true;
}
else if (prim.p1z > 65535f || prim.p2z > 65535f || prim.p3z > 65535f)
{
needSourceDepthClamp = true;
}
}
prepareWriters();
LongLongKey rendererKey = RendererKey;
if (compiledRenderer == null || !rendererKey.Equals(compiledRendererKey))
{
compiledRendererKey = rendererKey;
compiledRenderer = FilterCompiler.Instance.getCompiledRenderer(this, rendererKey, context);
if (isLogTraceEnabled)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
log.trace(string.Format("Rendering using compiled renderer {0}", compiledRenderer.GetType().FullName));
}
}
if (c3 != null)
{
prim.preComputeTriangleWeights();
}
}
