void
CRenderer::RenderFadingInBuildings(void)
{
RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLBACK);
DeActivateDirectional();
SetAmbientColours();
CVisibilityPlugins::RenderFadingBuildings();
}
void DrawPathLineMask()
{
DrawRadarMask();
unsigned int color;
CVector2D points[2];
if(gCurrentGpsMode != GPS_MODE_DISABLED)
{
color = 0;
points[0].x = 1;
points[0].y = 1;
points[1].x = -1;
points[1].y = -1;
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, NULL);
TransformRadarPointToScreenSpace(points[0], points[0]);
TransformRadarPointToScreenSpace(points[1], points[1]);
SetSpriteVertices(points[1].x, (float)*gScreenHeight, points[1].x, 0.0, 0.0, (float)*gScreenHeight, 0.0, 0.0, &color,
&color, &color, &color);
RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, gSpriteVertices, 4);
SetSpriteVertices(points[0].x, points[0].y, points[0].x, 0.0, points[1].x, points[0].y, points[1].x, 0.0, &color,
&color, &color, &color);
RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, gSpriteVertices, 4);
SetSpriteVertices(points[0].x, (float)*gScreenHeight, points[0].x, points[1].y, points[1].x, (float)*gScreenHeight,
points[1].x, points[1].y, &color, &color, &color, &color);
RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, gSpriteVertices, 4);
SetSpriteVertices((float)*gScreenWidth, (float)*gScreenHeight, (float)*gScreenWidth, 0.0, points[0].x, (float)*gScreenHeight,
points[0].x, 0.0, &color, &color, &color, &color);
RwIm2DRenderPrimitive(rwPRIMTYPETRIFAN, gSpriteVertices, 4);
}
RwD3D9SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);
}
void
DrawEnvMapCoronas(RwV3d at)
{
const float BIG = 89.0f * reflectionTex->raster->width/128.0f;
const float SMALL = 38.0f * reflectionTex->raster->height/128.0f;
float x;
numCoronaVerts = 0;
numCoronaIndices = 0;
x = CGeneral::GetATanOfXY(-at.y, at.x)/(2*M_PI) - 1.0f;
x *= BIG+SMALL;
AddCorona(x, 12.0f, SMALL); x += SMALL;
AddCorona(x, 0.0f, BIG); x += BIG;
AddCorona(x, 12.0f, SMALL); x += SMALL;
AddCorona(x, 0.0f, BIG); x += BIG;
RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDONE);
RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, gpCoronaTexture[0]->raster);
RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, coronaVerts, numCoronaVerts, coronaIndices, numCoronaIndices);
RwRenderStateSet(rwRENDERSTATESRCBLEND, (void*)rwBLENDSRCALPHA);
RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
}
void
DrawDebugEnvMap(void)
{
if(GetAsyncKeyState(VK_F3) & 0x8000)
return;
#ifdef DEBUGENVTEX
MakeScreenQuad();
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, reflectionTex->raster);
RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, screenQuad, 4, screenindices, 6);
#endif
}
void
CRenderer::RenderRoadsAndBuildings(void)
{
RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATECULLMODE, (void*)rwCULLMODECULLBACK);
if(CGame__currArea == 0)
RwRenderStateSet(rwRENDERSTATEALPHATESTFUNCTIONREF, (void*)140);
for(int i = 0; i < ms_nNoOfVisibleEntities; i++){
CEntity *e = ms_aVisibleEntityPtrs[i];
int type = e->nType;
if(type == ENTITY_TYPE_BUILDING){
if(((CAtomicModelInfo*)GetModelInfo(e))->GetWetRoadReflection())
RenderOneRoad(e);
else
RenderOneNonRoad(e);
}
}
// SA does something with the camera's z values here but that has no effect on d3d
for(int i = 0; i < ms_nNoOfVisibleLods; i++)
RenderOneNonRoad(ms_aVisibleLodPtrs[i]);
}
void
RenderReflectionScene(void)
{
if(CCutsceneMgr__ms_running)
reflectionCamPos = TheCamera.GetPosition();
else
reflectionCamPos = FindPlayerPed(-1)->GetPosition();
DefinedState();
/* We do have fog for the sphere map but we have to calculate it ourselves */
RwRenderStateSet(rwRENDERSTATEFOGENABLE, 0);
// Render the opaque world
CRenderer::RenderRoadsAndBuildings();
// and the transparent world
CRenderer::RenderFadingInBuildings();
}
void DrawPathFindLine(RwV2d *points, unsigned int numPoints, float width, unsigned int color)
{
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, NULL);
for(unsigned int i = 0; i < (numPoints - 1); i++)
{
if(!(i & 1))
TransformRealWorldPointToRadarSpace(points[i], gapPathNodes[i]->m_v2dPoint);
TransformRealWorldPointToRadarSpace(points[i+1], gapPathNodes[i+1]->m_v2dPoint);
if(IsLineInsideRadar(points[i], points[i+1]))
{
if(!(i & 1))
TransformRadarPointToScreenSpace(points[i], points[i]);
TransformRadarPointToScreenSpace(points[i+1], points[i+1]);
DrawLine(points[i], points[i+1], width, color);
}
else TransformRadarPointToScreenSpace(points[i+1], points[i+1]);
}
}
void CCustomCarEnvMapPipeline::CustomPipeRenderCB(RwResEntry* repEntry, void* object, RwUInt8 type, RwUInt32 flags)
{
RpAtomic* atomic = (RpAtomic*)atomic;
RwUInt32 geometryFlags = atomic->geometry->flags;
RwBool atomicFlag = CVisibilityPlugins::GetAtomicId(atomic) & 0x6000;
_rwD3D9EnableClippingIfNeeded(object, type);
RwBool lighting = 0;
RwD3D9GetRenderState(D3DRS_LIGHTING, &lighting);
RwBool isLit;
RwBool renderDark = RpLightGetFlags(pDirect) & rpLIGHTLIGHTATOMICS && CVisibilityPlugins::GetAtomicId(atomic) & 0x4000; // R* added this in 1.01
if(lighting || flags & rxGEOMETRY_PRELIT)
{
isLit = 0;
}
else
{
isLit = 1;
RwD3D9SetTexture(NULL, 0);
RwD3D9SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_ARGB(0xFF, 0, 0, 0));
RwD3D9SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG2);
RwD3D9SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
RwD3D9SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
RwD3D9SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_TFACTOR);
}
RxD3D9ResEntryHeader* resEntryHeader = (RxD3D9ResEntryHeader *)(repEntry + 1);
if(resEntryHeader->indexBuffer)
{
RwD3D9SetIndices((IDirect3DIndexBuffer9*)resEntryHeader->indexBuffer);
}
_rwD3D9SetStreams(resEntryHeader->vertexStream, resEntryHeader->useOffsets);
RwD3D9SetVertexDeclaration((IDirect3DVertexDeclaration9*)resEntryHeader->vertexDeclaration);
RxD3D9InstanceData* instancedData = (RxD3D9InstanceData*)(resEntryHeader + 1);
RwInt32 numMeshes = resEntryHeader->numMeshes;
while(numMeshes--)
{
RpMaterial* material = instancedData->material;
RwUInt32* materialFlags = (RwUInt32*)&(material->surfaceProps.specular);
bool applyEnvMap = true;
if(!(*materialFlags & 1) || atomicFlag)
{
applyEnvMap = false;
}
bool applyAlphaBlending = true;
if(!(*materialFlags & 2) || atomicFlag || !(geometryFlags & rpGEOMETRYLOCKTEXCOORDS4))
{
applyAlphaBlending = false;
}
RwBool applySpecMap = lighting == true;
float specularLighting = 0.0f;
float specularPower = 0.0f;
if(g_fx.GetFxQuality() < 2 && (!(*materialFlags & 8) || atomicFlag))
{
applySpecMap = false;
}
else
{
applySpecMap = *materialFlags & 4;
}
if(applySpecMap && !renderDark) // R* added renderDark in 1.01)
{
CustomSpecMapPipeMaterialData* specMapData = PLUGIN_SPECMAP(material, data);
RwD3D9SetLight(1, &gCarEnvMapLight);
RwD3D9EnableLight(1, 1);
specularLighting = 2.0f * m_EnvMapLightingMult * 1.85f * specMapData->specularity;
ClampMax(specularLighting, 1.0f);
specularPower = specMapData->specularity * 100.0f;
RwD3D9SetRenderState(D3DRS_SPECULARENABLE, 1);
RwD3D9SetRenderState(D3DRS_LOCALVIEWER, 0);
RwD3D9SetRenderState(D3DRS_SPECULARMATERIALSOURCE, 0);
}
else
{
RwD3D9SetRenderState(D3DRS_SPECULARENABLE, 0);
}
RwD3D9SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
RwD3D9SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
if(applyEnvMap && !renderDark) // R* added renderDark in 1.01
{
CustomEnvMapPipeMaterialData* envMapData = PLUGIN_ENVMAP(material, data);
D3DMATRIX EnvMapTransform;
RwRenderStateSet(rwRENDERSTATETEXTUREADDRESS, (void*)1);
// As the matrix is allocated on stack (unlike in R*'s code), the matrix should be zeroed first
// so untouched fields don't contain garbage
memset(&EnvMapTransform, 0, sizeof(EnvMapTransform));
EnvMapTransform._11 = FixedPointToFloat<8>(envMapData->scaleX);
EnvMapTransform._22 = FixedPointToFloat<8>(envMapData->scaleY);
EnvMapTransform._33 = 1.0f;
EnvMapTransform._44 = 1.0f;
RwV2d transScale;
D3D9GetTransScaleVector(envMapData, atomic, &transScale);
EnvMapTransform._31 = transScale.x;
EnvMapTransform._32 = transScale.y;
RwD3D9SetTransform(D3DTS_TEXTURE1, &EnvMapTransform);
RwD3D9SetTexture(envMapData->texture, 1);
uint8_t texShine = FixedPointToFloat<255>(envMapData->shininess) * m_EnvMapLightingMult * 1.85f * 254.0f;
ClampMax<uint8_t>(texShine, 255);
RwD3D9SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_XRGB(texShine, texShine, texShine));
RwD3D9SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_MULTIPLYADD);
RwD3D9SetTextureStageState(1, D3DTSS_COLORARG0, D3DTA_CURRENT);
RwD3D9SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
RwD3D9SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_TFACTOR);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
RwD3D9SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACENORMAL | 1);
RwD3D9SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_PROJECTED | D3DTTFF_COUNT1 | D3DTTFF_COUNT2);
RwD3D9SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
}
if(applyAlphaBlending && !renderDark) // R* added renderDark in 1.01)
{
CustomEnvMapPipeAtomicData* envMapAtmData = AllocEnvMapPipeAtomicData(atomic);
CustomEnvMapPipeMaterialData* envMapData = PLUGIN_ENVMAP(material, data);
D3DMATRIX AlphaBlendTransform;
RwV2d scale;
D3D9GetVectorForAlphaBlendingTransform(atomic, envMapAtmData, envMapData, &scale);
// As the matrix is allocated on stack (unlike in R*'s code), the matrix should be zeroed first
// so untouched fields don't contain garbage
memset(&AlphaBlendTransform, 0, sizeof(AlphaBlendTransform));
AlphaBlendTransform._11 = 1.0f;
AlphaBlendTransform._22 = 1.0f;
AlphaBlendTransform._33 = 1.0f;
AlphaBlendTransform._44 = 1.0f;
AlphaBlendTransform._31 = scale.x;
AlphaBlendTransform._32 = scale.y;
RwD3D9SetTransform(D3DTS_TEXTURE1, &AlphaBlendTransform);
RwD3D9SetTexture(envMapData->texture, 1);
uint8_t alpha = m_EnvMapLightingMult * 1.85f * 24.0f;
ClampMax<uint8_t>(alpha, 255);
RwD3D9SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_RGBA(255, 255, 255, alpha));
RwD3D9SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_BLENDFACTORALPHA);
RwD3D9SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
RwD3D9SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_CURRENT);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
RwD3D9SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
RwD3D9SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);
RwD3D9SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
}
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)(instancedData->vertexAlpha || material->color.alpha != 255));
if(isLit)
{
D3D9RenderNotLit(resEntryHeader, instancedData);
}
else
{
if(lighting)
{
RwRGBA matColor = material->color;
if((matColor.red == 0xAF && matColor.blue == 0xFF) ||
(matColor.green == 0xFF && matColor.blue == 0xB9)||
(matColor.green == 0xFF && matColor.blue == 0x3C)||
(matColor.green == 0x3C && matColor.blue == 0xFF)||
(matColor.green == 0xAF && matColor.blue == 0xFF)||
(matColor.red == 0xC8 && matColor.green == 0xFF && matColor.blue == 0x00)||
(matColor.red == 0xFF && matColor.green == 0x00 && matColor.blue == 0xFF)||
(matColor.red == 0xFF && matColor.green == 0xFF && matColor.blue == 0x00))
{
matColor.red = 0;
matColor.green = 0;
matColor.blue = 0;
}
D3D9SetRenderMaterialProperties(&material->surfaceProps, &matColor, flags, specularLighting, specularPower);
}
D3D9RenderPreLit(resEntryHeader, instancedData, flags, instancedData->material->texture);
}
if(applySpecMap)
{
RwD3D9SetRenderState(D3DRS_SPECULARENABLE, 0);
RwD3D9EnableLight(1, 0);
}
instancedData++;
}
D3D9RestoreSurfaceProperties();
RwD3D9SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
RwD3D9SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
RwD3D9SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
RwD3D9SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
}
void
ScreenFX::AVColourCorrection(void)
{
static RwMatrix RGB2YUV = {
{ 0.299f, -0.168736f, 0.500f }, 0,
{ 0.587f, -0.331264f, -0.418688f }, 0,
{ 0.114f, 0.500f, -0.081312f }, 0,
{ 0.000f, 0.000f, 0.000f }, 0,
};
static RwMatrix YUV2RGB = {
{ 1.000f, 1.000f, 1.000f }, 0,
{ 0.000f, -0.344136f, 1.772f }, 0,
{ 1.402f, -0.714136f, 0.000f }, 0,
{ 0.000f, 0.000f, 0.000f }, 0,
};
if(!m_bYCbCrFilter)
return;
UpdateFrontBuffer();
DefinedState();
RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void*)rwFILTERNEAREST);
RwRenderStateSet(rwRENDERSTATEFOGENABLE, (void*)FALSE);
RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)FALSE);
RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)FALSE);
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)pFrontBuffer);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)FALSE);
RwMatrix m;
m.right.x = m_lumaScale;
m.up.x = 0.0f;
m.at.x = 0.0f;
m.pos.x = m_lumaOffset;
m.right.y = 0.0f;
m.up.y = m_cbScale;
m.at.y = 0.0f;
m.pos.y = m_cbOffset;
m.right.z = 0.0f;
m.up.z = 0.0f;
m.at.z = m_crScale;
m.pos.z = m_crOffset;
m.flags = 0;
RwMatrixOptimize(&m, nil);
RwMatrix m2;
RwMatrixMultiply(&m2, &RGB2YUV, &m);
RwMatrixMultiply(&m, &m2, &YUV2RGB);
Grade red, green, blue;
red.r = m.right.x;
red.g = m.up.x;
red.b = m.at.x;
red.a = m.pos.x;
green.r = m.right.y;
green.g = m.up.y;
green.b = m.at.y;
green.a = m.pos.y;
blue.r = m.right.z;
blue.g = m.up.z;
blue.b = m.at.z;
blue.a = m.pos.z;
RwD3D9SetPixelShaderConstant(0, &red, 1);
RwD3D9SetPixelShaderConstant(1, &green, 1);
RwD3D9SetPixelShaderConstant(2, &blue, 1);
RwD3D9SetIm2DPixelShader(gradingPS);
// don't use these
RwIm2DRenderIndexedPrimitive(rwPRIMTYPETRILIST, screenVertices, 4, screenIndices, 6);
RwD3D9SetIm2DPixelShader(nil);
RwRenderStateSet(rwRENDERSTATETEXTUREFILTER, (void*)rwFILTERLINEAR);
RwRenderStateSet(rwRENDERSTATEZTESTENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATEZWRITEENABLE, (void*)TRUE);
RwRenderStateSet(rwRENDERSTATETEXTURERASTER, (void*)NULL);
RwRenderStateSet(rwRENDERSTATEVERTEXALPHAENABLE, (void*)TRUE);
}
