/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
extern INDEX mdl_iShadowQuality;
// model shadow precision
// 0 = no shadows
// 1 = one simple shadow
// 2 = one complex shadow
// 3 = all shadows
/*
* Compare two models for sorting.
*/
static inline int CompareDelayedModels( const CDelayedModel &dm0, const CDelayedModel &dm1)
{
BOOL bHasAlpha0 = dm0.dm_ulFlags&DMF_HASALPHA;
BOOL bHasAlpha1 = dm1.dm_ulFlags&DMF_HASALPHA;
if (! bHasAlpha0 && bHasAlpha1) return -1;
else if ( bHasAlpha0 && !bHasAlpha1) return +1;
if (dm0.dm_fDistance<dm1.dm_fDistance) return -1;
else if (dm0.dm_fDistance>dm1.dm_fDistance) return +1;
else return 0;
}
static int qsort_CompareDelayedModels( const void *ppdm0, const void *ppdm1)
{
CDelayedModel &dm0 = **(CDelayedModel **)ppdm0;
CDelayedModel &dm1 = **(CDelayedModel **)ppdm1;
return +CompareDelayedModels(dm0, dm1);
}
static inline FLOAT IntensityAtDistance( FLOAT fFallOff, FLOAT fHotSpot, FLOAT fDistance)
{
// intensity is zero if further than fall-off range
if( fDistance>fFallOff) return 0.0f;
// intensity is maximum if closer than hot-spot range
if( fDistance<fHotSpot) return 1.0f;
// interpolate if between fall-off and hot-spot range
return (fFallOff-fDistance)/(fFallOff-fHotSpot);
}
/* Find lights for one model. */
BOOL CRenderer::FindModelLights( CEntity &en, const CPlacement3D &plModel,
COLOR &colLight, COLOR &colAmbient, FLOAT &fTotalShadowIntensity,
FLOAT3D &vTotalLightDirection, FLOATplane3D &plFloorPlane)
{
// find shading info if not already cached
if (en.en_psiShadingInfo!=NULL && !(en.en_ulFlags&ENF_VALIDSHADINGINFO)) {
_pfRenderProfile.StartTimer(CRenderProfile::PTI_FINDSHADINGINFO);
_pfRenderProfile.IncrementTimerAveragingCounter(CRenderProfile::PTI_FINDSHADINGINFO, 1);
if (en.en_ulFlags&ENF_NOSHADINGINFO) {
en.en_psiShadingInfo=NULL;
} else {
en.FindShadingInfo();
}
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDSHADINGINFO);
}
_pfRenderProfile.StartTimer(CRenderProfile::PTI_FINDLIGHTS);
// clear list of active lights
_amlLights.PopAll();
// if there is no valid shading info
if( en.en_psiShadingInfo==NULL/* || en.en_psiShadingInfo->si_pbpoPolygon==NULL*/)
{ // no shadow
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return FALSE;
}
// if there is valid shading info
else
{
// if model is above terrain
if(en.en_psiShadingInfo->si_ptrTerrain!=NULL) {
CTerrain *ptrTerrain = en.en_psiShadingInfo->si_ptrTerrain;
// if full bright rendering
if (_wrpWorldRenderPrefs.wrp_shtShadows==CWorldRenderPrefs::SHT_NONE) {
// no model shading
colLight = C_BLACK;
colAmbient = C_GRAY;
vTotalLightDirection = FLOAT3D(1.0f, -1.0f, 1.0f);
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return FALSE;
}
// create floor plane for shadow
ASSERT(en.en_psiShadingInfo->si_lnInPolygon.IsLinked());
COLOR colShade = ptrTerrain->GetShadeColor(en.en_psiShadingInfo);
colLight = MulColors(colShade,0xD8D8D8FF);
colAmbient = MulColors(colShade,0xB2B2B2FF);
vTotalLightDirection = FLOAT3D(1.0f, -1.0f, 1.0f);
fTotalShadowIntensity = 0.5f;
plFloorPlane = ptrTerrain->GetPlaneFromPoint(en.en_psiShadingInfo->si_vNearPoint);
// else if model is above polygon
} else if(en.en_psiShadingInfo->si_pbpoPolygon!=NULL) {
// if full bright rendering
if (_wrpWorldRenderPrefs.wrp_shtShadows==CWorldRenderPrefs::SHT_NONE) {
// no model shading
colLight = C_BLACK;
colAmbient = C_GRAY;
vTotalLightDirection = FLOAT3D(1.0f, -1.0f, 1.0f);
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return FALSE;
}
// create floor plane for shadow
ASSERT(en.en_psiShadingInfo->si_lnInPolygon.IsLinked());
plFloorPlane = en.en_psiShadingInfo->si_pbpoPolygon->bpo_pbplPlane->bpl_plAbsolute;
// if full bright polygon
if( en.en_psiShadingInfo->si_pbpoPolygon->bpo_ulFlags&BPOF_FULLBRIGHT) {
// take light from polygon shadow
COLOR col = en.en_psiShadingInfo->si_pbpoPolygon->bpo_colShadow;
colLight = LerpColor( C_BLACK, col, 0.25f);
colAmbient = LerpColor( C_BLACK, col, 0.33f);
fTotalShadowIntensity = NormByteToFloat((en.en_psiShadingInfo->si_pbpoPolygon->bpo_colShadow&CT_AMASK)>>CT_ASHIFT);
vTotalLightDirection = FLOAT3D(1.0f, -1.0f, 1.0f);
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return TRUE;
}
// get the shadow map of the underlying polygon
CBrushShadowMap &bsm = en.en_psiShadingInfo->si_pbpoPolygon->bpo_smShadowMap;
// get ambient light
UBYTE ubAR, ubAG, ubAB;
ColorToRGB( bsm.GetBrushPolygon()->bpo_pbscSector->bsc_colAmbient, ubAR, ubAG, ubAB);
SLONG slSAR=ubAR, slSAG=ubAG, slSAB=ubAB;
fTotalShadowIntensity = 0.0f;
// for each shadow layer
{FOREACHINLIST(CBrushShadowLayer, bsl_lnInShadowMap, bsm.bsm_lhLayers, itbsl)
{
// get the light source
CLightSource *plsLight = itbsl->bsl_plsLightSource;
// remember the light parameters
UBYTE ubR, ubG, ubB;
UBYTE ubDAR, ubDAG, ubDAB;
plsLight->GetLightColorAndAmbient( ubR, ubG, ubB, ubDAR, ubDAG, ubDAB);
// add directional ambient if needed
if( en.en_psiShadingInfo->si_pbpoPolygon->bpo_ulFlags&BPOF_HASDIRECTIONALAMBIENT) {
slSAR += ubDAR;
slSAG += ubDAG;
slSAB += ubDAB;
}
// get the layer intensity at the point
FLOAT fShadowFactor;
if (en.en_ulFlags&ENF_CLUSTERSHADOWS) {
fShadowFactor = 1.0f;
} else {
fShadowFactor = itbsl->GetLightStrength( en.en_psiShadingInfo->si_pixShadowU, en.en_psiShadingInfo->si_pixShadowV,
en.en_psiShadingInfo->si_fUDRatio, en.en_psiShadingInfo->si_fLRRatio);
}
// skip this light if no intensity
if( fShadowFactor<0.01f) continue;
const CPlacement3D &plLight = plsLight->ls_penEntity->GetPlacement();
const FLOAT3D &vLight = plLight.pl_PositionVector;
// get its parameters at the model position
FLOAT3D vDirection;
FLOAT fDistance;
FLOAT fFallOffFactor;
if (plsLight->ls_ulFlags&LSF_DIRECTIONAL) {
fFallOffFactor = 1.0f;
AnglesToDirectionVector(plLight.pl_OrientationAngle, vDirection);
plModel.pl_PositionVector-vLight;
if (!(en.en_psiShadingInfo->si_pbpoPolygon->bpo_ulFlags&BPOF_HASDIRECTIONALLIGHT)) {
ubR = ubG = ubB = 0;
}
fDistance = 1.0f;
} else {
vDirection = plModel.pl_PositionVector-vLight;
fDistance = vDirection.Length();
if (fDistance>plsLight->ls_rFallOff) {
continue;
} else if (fDistance<plsLight->ls_rHotSpot) {
fFallOffFactor = 1.0f;
} else {
fFallOffFactor = (plsLight->ls_rFallOff-fDistance)/
(plsLight->ls_rFallOff-plsLight->ls_rHotSpot);
}
}
// add the light to active lights
struct ModelLight &ml = _amlLights.Push();
ml.ml_plsLight = plsLight;
// normalize direction vector
if (fDistance>0.001f) {
ml.ml_vDirection = vDirection/fDistance;
} else {
ml.ml_vDirection = FLOAT3D(0.0f,0.0f,0.0f);
}
// special case for substract sector ambient light
if (plsLight->ls_ulFlags&LSF_SUBSTRACTSECTORAMBIENT) {
ubR = (UBYTE)Clamp( (SLONG)ubR-slSAR, 0L, 255L);
ubG = (UBYTE)Clamp( (SLONG)ubG-slSAG, 0L, 255L);
ubB = (UBYTE)Clamp( (SLONG)ubB-slSAB, 0L, 255L);
}
// calculate light intensity
FLOAT fShade = (ubR+ubG+ubB)*(2.0f/(3.0f*255.0f));
ml.ml_fShadowIntensity = fShade*fShadowFactor;
fTotalShadowIntensity += ml.ml_fShadowIntensity;
// special case for dark light
if (plsLight->ls_ulFlags&LSF_DARKLIGHT) {
ml.ml_fR = -ubR*fFallOffFactor;
ml.ml_fG = -ubG*fFallOffFactor;
ml.ml_fB = -ubB*fFallOffFactor;
} else {
ml.ml_fR = +ubR*fFallOffFactor;
ml.ml_fG = +ubG*fFallOffFactor;
ml.ml_fB = +ubB*fFallOffFactor;
}
}}
FLOAT fTR=0.0f; FLOAT fTG=0.0f; FLOAT fTB=0.0f;
FLOAT3D vDirection(0.0f,0.0f,0.0f);
// for each active light
{for(INDEX iLight=0; iLight<_amlLights.Count(); iLight++) {
struct ModelLight &ml = _amlLights[iLight];
// add it to total intensity
fTR += ml.ml_fR;
fTG += ml.ml_fG;
fTB += ml.ml_fB;
// add it to direction vector
FLOAT fWeight = Abs(ml.ml_fR+ml.ml_fG+ml.ml_fB) * (1.0f/(3.0f*255.0f));
vDirection+=ml.ml_vDirection*fWeight;
}}
// normalize average direction vector
FLOAT fDirection = vDirection.Length();
if (fDirection>0.001f) {
vDirection /= fDirection;
} else {
vDirection = FLOAT3D(0.0f,0.0f,0.0f);
}
// for each active light
FLOAT fDR=0.0f; FLOAT fDG=0.0f; FLOAT fDB=0.0f;
{for(INDEX iLight=0; iLight<_amlLights.Count(); iLight++) {
struct ModelLight &ml = _amlLights[iLight];
// find its contribution to direction vector
const FLOAT fFactor = ClampDn( vDirection%ml.ml_vDirection, 0.0f);
// add it to directional intensity
fDR += ml.ml_fR*fFactor;
fDG += ml.ml_fG*fFactor;
fDB += ml.ml_fB*fFactor;
}}
// adjust ambient light with gradient if needed
ULONG ulGradientType = en.en_psiShadingInfo->si_pbpoPolygon->bpo_bppProperties.bpp_ubGradientType;
if( ulGradientType>0) {
CGradientParameters gp;
COLOR colGradientPoint;
CEntity *pen = en.en_psiShadingInfo->si_pbpoPolygon->bpo_pbscSector->bsc_pbmBrushMip->bm_pbrBrush->br_penEntity;
if( pen!=NULL && pen->GetGradient( ulGradientType, gp)) {
FLOAT fGrPt = (en.en_psiShadingInfo->si_vNearPoint % gp.gp_vGradientDir - gp.gp_fH0) / (gp.gp_fH1-gp.gp_fH0);
fGrPt = Clamp( fGrPt, 0.0f, 1.0f);
colGradientPoint = LerpColor( gp.gp_col0, gp.gp_col1, fGrPt);
UBYTE ubGR,ubGG,ubGB;
ColorToRGB( colGradientPoint, ubGR,ubGG,ubGB);
// add or substract gradient component to total ambient
if( gp.gp_bDark) { slSAR-=ubGR; slSAG-=ubGG; slSAB-=ubGB; }
else { slSAR+=ubGR; slSAG+=ubGG; slSAB+=ubGB; }
}
}
// clamp ambient component
slSAR = Clamp( slSAR, 0L, 255L);
slSAG = Clamp( slSAG, 0L, 255L);
slSAB = Clamp( slSAB, 0L, 255L);
// calculate average light properties
SLONG slAR = Clamp( (SLONG)FloatToInt(fTR-fDR) +slSAR, 0L, 255L);
SLONG slAG = Clamp( (SLONG)FloatToInt(fTG-fDG) +slSAG, 0L, 255L);
SLONG slAB = Clamp( (SLONG)FloatToInt(fTB-fDB) +slSAB, 0L, 255L);
SLONG slLR = Clamp( (SLONG)FloatToInt(fDR), 0L, 255L);
SLONG slLG = Clamp( (SLONG)FloatToInt(fDG), 0L, 255L);
SLONG slLB = Clamp( (SLONG)FloatToInt(fDB), 0L, 255L);
colLight = RGBToColor( slLR,slLG,slLB);
colAmbient = RGBToColor( slAR,slAG,slAB);
// adjust for changed polygon shadow color
COLOR colShadowMap = en.en_psiShadingInfo->si_pbpoPolygon->bpo_colShadow;
CTextureBlending &tbShadow = re_pwoWorld->wo_atbTextureBlendings[
en.en_psiShadingInfo->si_pbpoPolygon->bpo_bppProperties.bpp_ubShadowBlend];
COLOR colShadowMapAdjusted = MulColors(colShadowMap, tbShadow.tb_colMultiply);
colLight = MulColors( colLight, colShadowMapAdjusted);
colAmbient = MulColors( colAmbient, colShadowMapAdjusted);
vTotalLightDirection = vDirection;
// else no valid shading info
} else {
// no shadow
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return FALSE;
}
}
_pfRenderProfile.StopTimer(CRenderProfile::PTI_FINDLIGHTS);
return TRUE;
}
/*
* Render one model with shadow (eventually)
*/
void CRenderer::RenderOneModel( CEntity &en, CModelObject &moModel, const CPlacement3D &plModel,
const FLOAT fDistanceFactor, BOOL bRenderShadow, ULONG ulDMFlags)
{
// skip invisible models
if( moModel.mo_Stretch == FLOAT3D(0,0,0)) return;
// do nothing, if rendering shadows and this model doesn't cast cluster shadows
if( re_bRenderingShadows && !(en.en_ulFlags&ENF_CLUSTERSHADOWS)) return;
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERONEMODEL);
CPlacement3D plLight;
plLight.pl_PositionVector = plModel.pl_PositionVector + FLOAT3D(3.0f,3.0f,3.0f);
plLight.pl_OrientationAngle = ANGLE3D(AngleDeg(30.0f), AngleDeg(-45.0f),0);
// create a default light
COLOR colLight = C_GRAY;
COLOR colAmbient = C_dGRAY;
FLOAT3D vTotalLightDirection( 1.0f, -1.0f, 1.0f);
FLOATplane3D plFloorPlane(FLOAT3D( 0.0f, 1.0f, 0.0f), 0.0f);
BOOL bRenderModelShadow = FALSE;
FLOAT fTotalShadowIntensity = 0.0f;
// if not rendering cluster shadows
if( !re_bRenderingShadows) {
// find model lights
bRenderModelShadow = FindModelLights( en, plModel, colLight, colAmbient,
fTotalShadowIntensity, vTotalLightDirection, plFloorPlane);
}
// let the entity adjust shading parameters if it wants to
mdl_iShadowQuality = Clamp( mdl_iShadowQuality, 0L, 3L);
const BOOL bAllowShadows = en.AdjustShadingParameters( vTotalLightDirection, colLight, colAmbient);
bRenderModelShadow = (bRenderModelShadow && bAllowShadows && bRenderShadow && mdl_iShadowQuality>0);
// prepare render model structure
CRenderModel rm;
rm.rm_vLightDirection = vTotalLightDirection;
rm.rm_fDistanceFactor = fDistanceFactor;
rm.rm_colLight = colLight;
rm.rm_colAmbient = colAmbient;
rm.SetObjectPlacement(plModel);
if( ulDMFlags & DMF_FOG) rm.rm_ulFlags |= RMF_FOG;
if( ulDMFlags & DMF_HAZE) rm.rm_ulFlags |= RMF_HAZE;
if( ulDMFlags & DMF_INSIDE) rm.rm_ulFlags |= RMF_INSIDE;
if( ulDMFlags & DMF_INMIRROR) rm.rm_ulFlags |= RMF_INMIRROR;
// mark that we don't actualy need entire model
if( re_penViewer==&en) {
rm.rm_ulFlags |= RMF_SPECTATOR;
bRenderModelShadow = FALSE;
}
// TEMP: disable Truform usage on weapon models
if( IsOfClass( &en, "Player Weapons")) rm.rm_ulFlags |= RMF_WEAPON;
// set tesselation level of models
rm.rm_iTesselationLevel = (INDEX) (en.GetMaxTessellationLevel());
// prepare CRenderModel structure for rendering of one model
moModel.SetupModelRendering(rm);
// determine shadow intensity
fTotalShadowIntensity *= NormByteToFloat( (moModel.mo_colBlendColor&CT_AMASK)>>CT_ASHIFT);
fTotalShadowIntensity = Clamp( fTotalShadowIntensity, 0.0f, 1.0f);
// if should render shadow for this model
if( bRenderModelShadow && !(en.en_ulFlags&ENF_CLUSTERSHADOWS) && moModel.HasShadow(rm.rm_iMipLevel)) {
// if only simple shadow
if( mdl_iShadowQuality==1) {
// render simple shadow
fTotalShadowIntensity = 0.1f + fTotalShadowIntensity*0.9f;
moModel.AddSimpleShadow( rm, fTotalShadowIntensity, plFloorPlane);
}
// if only one shadow
else if( mdl_iShadowQuality==2) {
// render one shadow of model from shading light direction
const FLOAT fHotSpot = 1E10f;
const FLOAT fFallOff = 1E11f;
CPlacement3D plLight;
plLight.pl_PositionVector = plModel.pl_PositionVector - rm.rm_vLightDirection*1000.0f;
moModel.RenderShadow( rm, plLight, fFallOff, fHotSpot, fTotalShadowIntensity, plFloorPlane);
}
// if full shadows
else if( mdl_iShadowQuality==3) {
// for each active light
for( INDEX iLight=0; iLight<_amlLights.Count(); iLight++) {
struct ModelLight &ml = _amlLights[iLight];
// skip light if doesn't cast shadows
if( !(ml.ml_plsLight->ls_ulFlags&LSF_CASTSHADOWS)) continue;
// get light parameters
CPlacement3D plLight = ml.ml_plsLight->ls_penEntity->en_plPlacement;
FLOAT fHotSpot = ml.ml_plsLight->ls_rHotSpot;
FLOAT fFallOff = ml.ml_plsLight->ls_rFallOff;
if (ml.ml_plsLight->ls_ulFlags & LSF_DIRECTIONAL) {
fHotSpot = 1E10f;
fFallOff = 1E11f;
FLOAT3D vDirection;
AnglesToDirectionVector( plLight.pl_OrientationAngle, vDirection);
plLight.pl_PositionVector = plModel.pl_PositionVector-(vDirection*1000.0f);
}
// render one shadow of model
const FLOAT fShadowIntensity = Clamp( ml.ml_fShadowIntensity, 0.0f, 1.0f);
moModel.RenderShadow( rm, plLight, fFallOff, fHotSpot, fShadowIntensity, plFloorPlane);
}
}
}
// if the entity is not the viewer, or this is not primary renderer
if( re_penViewer!=&en) {
// render model
moModel.RenderModel(rm);
// if the entity is viewer
} else {
// just remember the shading info (needed for first-person-weapon rendering)
_vViewerLightDirection = rm.rm_vLightDirection;
_colViewerLight = rm.rm_colLight;
_colViewerAmbient = rm.rm_colAmbient;
}
// all done
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERONEMODEL);
}
/*
* Render one ska model with shadow (eventually)
*/
void CRenderer::RenderOneSkaModel( CEntity &en, const CPlacement3D &plModel,
const FLOAT fDistanceFactor, BOOL bRenderShadow, ULONG ulDMFlags)
{
// skip invisible models
if( en.GetModelInstance()->mi_vStretch == FLOAT3D(0,0,0)) return;
// do nothing, if rendering shadows and this model doesn't cast cluster shadows
if( re_bRenderingShadows && !(en.en_ulFlags&ENF_CLUSTERSHADOWS)) return;
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERONEMODEL);
CPlacement3D plLight;
plLight.pl_PositionVector = plModel.pl_PositionVector + FLOAT3D(3.0f,3.0f,3.0f);
plLight.pl_OrientationAngle = ANGLE3D(AngleDeg(30.0f), AngleDeg(-45.0f),0);
// create a default light
COLOR colLight = C_GRAY;
COLOR colAmbient = C_dGRAY;
FLOAT3D vTotalLightDirection( 1.0f, -1.0f, 1.0f);
FLOATplane3D plFloorPlane(FLOAT3D( 0.0f, 1.0f, 0.0f), 0.0f);
BOOL bRenderModelShadow = FALSE;
FLOAT fTotalShadowIntensity = 0.0f;
// if not rendering cluster shadows
if( !re_bRenderingShadows) {
// find model lights
bRenderModelShadow = FindModelLights( en, plModel, colLight, colAmbient,
fTotalShadowIntensity, vTotalLightDirection, plFloorPlane);
}
// let the entity adjust shading parameters if it wants to
mdl_iShadowQuality = Clamp( mdl_iShadowQuality, 0L, 3L);
const BOOL bAllowShadows = en.AdjustShadingParameters( vTotalLightDirection, colLight, colAmbient);
bRenderModelShadow = (bRenderModelShadow && bAllowShadows && bRenderShadow && mdl_iShadowQuality>0);
ULONG &ulRenFlags = RM_GetRenderFlags();
ulRenFlags = 0;
if( ulDMFlags & DMF_FOG) ulRenFlags |= RMF_FOG;
if( ulDMFlags & DMF_HAZE) ulRenFlags |= RMF_HAZE;
if( ulDMFlags & DMF_INSIDE) ulRenFlags |= RMF_INSIDE;
if( ulDMFlags & DMF_INMIRROR) ulRenFlags |= RMF_INMIRROR;
// mark that we don't actualy need entire model
if( re_penViewer==&en) {
ulRenFlags |= RMF_SPECTATOR;
bRenderModelShadow = FALSE;
}
RM_SetObjectPlacement(en.GetLerpedPlacement());
RM_SetLightColor(colAmbient,colLight);
RM_SetLightDirection(vTotalLightDirection);
// determine shadow intensity
fTotalShadowIntensity *= NormByteToFloat( (en.GetModelInstance()->GetModelColor()&CT_AMASK)>>CT_ASHIFT);
fTotalShadowIntensity = Clamp( fTotalShadowIntensity, 0.0f, 1.0f);
// if should render shadow for this model
if( bRenderModelShadow && !(en.en_ulFlags&ENF_CLUSTERSHADOWS) && en.GetModelInstance()->HasShadow(1/*rm.rm_iMipLevel*/)) {
// if only simple shadow
if( mdl_iShadowQuality==1) {
// render simple shadow
fTotalShadowIntensity = 0.1f + fTotalShadowIntensity*0.9f;
en.GetModelInstance()->AddSimpleShadow(fTotalShadowIntensity, plFloorPlane);
}
// if only one shadow
else if( mdl_iShadowQuality==2) {
/*
// render one shadow of model from shading light direction
const FLOAT fHotSpot = 1E10f;
const FLOAT fFallOff = 1E11f;
CPlacement3D plLight;
plLight.pl_PositionVector = plModel.pl_PositionVector - vTotalLightDirection*1000.0f;
// moModel.RenderShadow( rm, plLight, fFallOff, fHotSpot, fTotalShadowIntensity, plFloorPlane);
*/
fTotalShadowIntensity = 0.1f + fTotalShadowIntensity*0.9f;
en.GetModelInstance()->AddSimpleShadow(fTotalShadowIntensity, plFloorPlane);
}
// if full shadows
else if( mdl_iShadowQuality==3) {
/*
// for each active light
for( INDEX iLight=0; iLight<_amlLights.Count(); iLight++) {
struct ModelLight &ml = _amlLights[iLight];
// skip light if doesn't cast shadows
if( !(ml.ml_plsLight->ls_ulFlags&LSF_CASTSHADOWS)) continue;
// get light parameters
CPlacement3D plLight = ml.ml_plsLight->ls_penEntity->en_plPlacement;
FLOAT fHotSpot = ml.ml_plsLight->ls_rHotSpot;
FLOAT fFallOff = ml.ml_plsLight->ls_rFallOff;
if (ml.ml_plsLight->ls_ulFlags & LSF_DIRECTIONAL) {
fHotSpot = 1E10f;
fFallOff = 1E11f;
FLOAT3D vDirection;
AnglesToDirectionVector( plLight.pl_OrientationAngle, vDirection);
plLight.pl_PositionVector = plModel.pl_PositionVector-(vDirection*1000.0f);
}
// render one shadow of model
const FLOAT fShadowIntensity = Clamp( ml.ml_fShadowIntensity, 0.0f, 1.0f);
// moModel.RenderShadow( rm, plLight, fFallOff, fHotSpot, fShadowIntensity, plFloorPlane);
}
*/
fTotalShadowIntensity = 0.1f + fTotalShadowIntensity*0.9f;
en.GetModelInstance()->AddSimpleShadow(fTotalShadowIntensity, plFloorPlane);
}
}
// if the entity is not the viewer, or this is not primary renderer
if( re_penViewer!=&en) {
// render model
RM_SetBoneAdjustCallback(&EntityAdjustBonesCallback,&en);
RM_SetShaderParamsAdjustCallback(&EntityAdjustShaderParamsCallback,&en);
RM_RenderSKA(*en.GetModelInstanceForRendering());
// if the entity is viewer
} else {
// just remember the shading info (needed for first-person-weapon rendering)
_vViewerLightDirection = vTotalLightDirection;
_colViewerLight = colLight;
_colViewerAmbient = colAmbient;
}
// all done
// _pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERONEMODEL);
}
/*
* Render models that were kept for delayed rendering.
*/
void CRenderer::RenderModels( BOOL bBackground)
{
if( _bMultiPlayer) gfx_bRenderModels = 1; // must render in multiplayer mode!
if( !gfx_bRenderModels && !re_bRenderingShadows) return;
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERMODELS);
// sort all the delayed models by distance
qsort(re_admDelayedModels.GetArrayOfPointers(), re_admDelayedModels.Count(),
sizeof(CDelayedModel *), qsort_CompareDelayedModels);
CAnyProjection3D *papr;
if( bBackground) {
papr = &re_prBackgroundProjection;
} else {
papr = &re_prProjection;
}
// begin model rendering
if( !re_bRenderingShadows) {
BeginModelRenderingView( *papr, re_pdpDrawPort);
RM_BeginRenderingView( *papr, re_pdpDrawPort);
} else {
BeginModelRenderingMask( *papr, re_pubShadow, re_slShadowWidth, re_slShadowHeight);
RM_BeginModelRenderingMask( *papr, re_pubShadow, re_slShadowWidth, re_slShadowHeight);
}
// for each of models that were kept for delayed rendering
for( INDEX iModel=0; iModel<re_admDelayedModels.Count(); iModel++) {
CDelayedModel &dm = re_admDelayedModels[iModel];
CEntity &en = *dm.dm_penModel;
BOOL bIsBackground = re_bBackgroundEnabled && (en.en_ulFlags&ENF_BACKGROUND);
// skip if not rendered in this pass or not visible
if( (bBackground && !bIsBackground)
|| (!bBackground && bIsBackground)
|| !(dm.dm_ulFlags&DMF_VISIBLE)) continue;
if(en.en_RenderType == CEntity::RT_SKAMODEL || en.en_RenderType == CEntity::RT_SKAEDITORMODEL)
{
RenderOneSkaModel(en, en.GetLerpedPlacement(), dm.dm_fMipFactor, TRUE, dm.dm_ulFlags);
// if selected entities should be drawn and this one is selected
if( !re_bRenderingShadows && _wrpWorldRenderPrefs.wrp_stSelection==CWorldRenderPrefs::ST_ENTITIES
&& _wrpWorldRenderPrefs.wrp_pmoSelectedEntity!=NULL && en.IsSelected(ENF_SELECTED))
{ // get bounding box of current frame
FLOATaabbox3D boxModel;
en.GetModelInstance()->GetCurrentColisionBox(boxModel);
// if model has collision
if( en.en_pciCollisionInfo!=NULL ) {
// get its collision box
INDEX iCollision = en.GetCollisionBoxIndex();
FLOAT3D vMin = en.GetModelInstance()->GetCollisionBoxMin(iCollision);
FLOAT3D vMax = en.GetModelInstance()->GetCollisionBoxMax(iCollision);
// extend the box by the collision box
boxModel|=FLOATaabbox3D(vMin, vMax);
}
// set position of marker at top of the model and it size to be proportional to the model
boxModel.StretchByVector(en.GetModelInstance()->mi_vStretch);
FLOAT fSize = boxModel.Size().Length()*0.3f;
_wrpWorldRenderPrefs.wrp_pmoSelectedEntity->mo_Stretch = FLOAT3D( fSize, fSize, fSize);
CPlacement3D plSelection = en.GetLerpedPlacement();
plSelection.Translate_OwnSystem( FLOAT3D(0.0f, boxModel.Max()(2), 0.0f));
// render the selection model without shadow
RenderOneModel( en, *_wrpWorldRenderPrefs.wrp_pmoSelectedEntity, plSelection, dm.dm_fMipFactor, FALSE, 0);
}
}
else
{
// render the model with its shadow
CModelObject &moModelObject = *dm.dm_pmoModel;
RenderOneModel( en, moModelObject, en.GetLerpedPlacement(), dm.dm_fMipFactor, TRUE, dm.dm_ulFlags);
// if selected entities should be drawn and this one is selected
if( !re_bRenderingShadows && _wrpWorldRenderPrefs.wrp_stSelection==CWorldRenderPrefs::ST_ENTITIES
&& _wrpWorldRenderPrefs.wrp_pmoSelectedEntity!=NULL && en.IsSelected(ENF_SELECTED))
{ // get bounding box of current frame
FLOATaabbox3D boxModel;
moModelObject.GetCurrentFrameBBox(boxModel);
// if model has collision
if( en.en_pciCollisionInfo!=NULL &&
(en.GetRenderType()==CEntity::RT_MODEL || en.GetRenderType()==CEntity::RT_EDITORMODEL)) {
// get its collision box
INDEX iCollision = en.GetCollisionBoxIndex();
FLOAT3D vMin = moModelObject.GetCollisionBoxMin(iCollision);
FLOAT3D vMax = moModelObject.GetCollisionBoxMax(iCollision);
// extend the box by the collision box
boxModel|=FLOATaabbox3D(vMin, vMax);
}
// set position of marker at top of the model and it size to be proportional to the model
boxModel.StretchByVector(moModelObject.mo_Stretch);
FLOAT fSize = boxModel.Size().Length()*0.3f;
_wrpWorldRenderPrefs.wrp_pmoSelectedEntity->mo_Stretch = FLOAT3D( fSize, fSize, fSize);
CPlacement3D plSelection = en.GetLerpedPlacement();
plSelection.Translate_OwnSystem( FLOAT3D(0.0f, boxModel.Max()(2), 0.0f));
// render the selection model without shadow
RenderOneModel( en, *_wrpWorldRenderPrefs.wrp_pmoSelectedEntity, plSelection, dm.dm_fMipFactor, FALSE, 0);
}
}
}
// end model rendering
if( !re_bRenderingShadows) {
EndModelRenderingView(FALSE); // don't restore ortho projection for now
RM_EndRenderingView(FALSE);
} else {
EndModelRenderingMask();
RM_EndModelRenderingMask();
}
// done
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERMODELS);
}
extern CEntity *_Particle_penCurrentViewer;
extern FLOAT _Particle_fCurrentMip;
extern BOOL _Particle_bHasFog;
extern BOOL _Particle_bHasHaze;
void Particle_PrepareEntity( FLOAT fMipFactor, BOOL bHasFog, BOOL bHasHaze, CEntity *penViewer)
{
_Particle_fCurrentMip = fMipFactor;
_Particle_bHasFog = bHasFog;
_Particle_bHasHaze = bHasHaze;
_Particle_penCurrentViewer = penViewer;
}
/* Render particles for models that were kept for delayed rendering. */
void CRenderer::RenderParticles(BOOL bBackground)
{
if( _bMultiPlayer) gfx_bRenderParticles = 1; // must render in multiplayer mode!
if( re_bRenderingShadows || !gfx_bRenderParticles) return;
_pfRenderProfile.StartTimer(CRenderProfile::PTI_RENDERPARTICLES);
// prepare gfx library for particles
if (bBackground) {
Particle_PrepareSystem(re_pdpDrawPort, re_prBackgroundProjection);
} else {
Particle_PrepareSystem(re_pdpDrawPort, re_prProjection);
}
// for each of models that were kept for delayed rendering
for(INDEX iModel=0; iModel<re_admDelayedModels.Count(); iModel++) {
CDelayedModel &dm = re_admDelayedModels[iModel];
CEntity &en = *dm.dm_penModel;
BOOL bIsBackground = re_bBackgroundEnabled && (en.en_ulFlags&ENF_BACKGROUND);
// if not rendered in this pass
if( (bBackground && !bIsBackground) || (!bBackground && bIsBackground)) continue;
Particle_PrepareEntity( dm.dm_fMipFactor, dm.dm_ulFlags&DMF_FOG, dm.dm_ulFlags&DMF_HAZE, re_penViewer);
// render particles made by this entity
en.RenderParticles();
_Particle_penCurrentViewer = NULL;
}
// end gfx library for particles
Particle_EndSystem(FALSE);
_pfRenderProfile.StopTimer(CRenderProfile::PTI_RENDERPARTICLES);
}
void DeleteLensFlare(CLightSource *pls)
{
// for each renderer
for (INDEX ire = 0; ire<MAX_RENDERERS; ire++) {
CRenderer &re = _areRenderers[ire];
// for each lens flare of this light source
for(INDEX iFlare=0; iFlare<re.re_alfiLensFlares.Count(); iFlare++) {
CLensFlareInfo &lfi = re.re_alfiLensFlares[iFlare];
if (lfi.lfi_plsLightSource == pls) {
// invalidate lens flare info to be deleted in next rendering
lfi.lfi_plsLightSource = NULL;
}
}
}
}
/* Render lens flares. */
void CRenderer::RenderLensFlares(void)
{
// make sure we have orthographic projection
re_pdpDrawPort->SetOrtho();
// if there are no flares or flares are off, do nothing
gfx_iLensFlareQuality = Clamp( gfx_iLensFlareQuality, 0L, 3L);
if( gfx_iLensFlareQuality==0 || re_alfiLensFlares.Count()==0) return;
// get drawport ID
ASSERT( re_pdpDrawPort!=NULL);
const ULONG ulDrawPortID = re_pdpDrawPort->GetID();
// for each lens flare of this drawport
{for(INDEX iFlare=0; iFlare<re_alfiLensFlares.Count(); iFlare++) {
CLensFlareInfo &lfi = re_alfiLensFlares[iFlare];
// skip if not in this drawport
if( lfi.lfi_ulDrawPortID!=ulDrawPortID && lfi.lfi_iMirrorLevel==0) continue;
// test if it is still visible
lfi.lfi_ulFlags &= ~LFF_VISIBLE;
if( re_pdpDrawPort->IsPointVisible( (PIX) lfi.lfi_fI, (PIX) lfi.lfi_fJ, lfi.lfi_fOoK, lfi.lfi_iID, lfi.lfi_iMirrorLevel)) {
lfi.lfi_ulFlags |= LFF_VISIBLE;
}
}}
// get count of currently existing flares and time
INDEX ctFlares = re_alfiLensFlares.Count();
const TIME tmNow = _pTimer->GetRealTimeTick();
// for each lens flare
INDEX iFlare=0;
while(iFlare<ctFlares) {
CLensFlareInfo &lfi = re_alfiLensFlares[iFlare];
// if the flare is not active any more, or its drawport was not refreshed long
if( lfi.lfi_plsLightSource==NULL || // marked when entity is deleted
(lfi.lfi_ulDrawPortID==ulDrawPortID &&
(!(lfi.lfi_ulFlags&LFF_ACTIVE) || lfi.lfi_plsLightSource->ls_plftLensFlare==NULL)) ||
(lfi.lfi_ulDrawPortID!=ulDrawPortID && lfi.lfi_tmLastFrame<tmNow-5.0f)) {
// delete it by moving the last one on its place
lfi = re_alfiLensFlares[ctFlares-1];
re_alfiLensFlares[ctFlares-1].Clear();
ctFlares--;
// if the flare is still active
} else {
// go to next flare
iFlare++;
}
}
// remove unused flares at the end
if( ctFlares==0) re_alfiLensFlares.PopAll();
else re_alfiLensFlares.PopUntil(ctFlares-1);
// for each lens flare of this drawport
{for(INDEX iFlare=0; iFlare<re_alfiLensFlares.Count(); iFlare++) {
CLensFlareInfo &lfi = re_alfiLensFlares[iFlare];
if (lfi.lfi_ulDrawPortID!=ulDrawPortID || lfi.lfi_plsLightSource->ls_plftLensFlare==NULL) {
continue;
}
// clear active flag for next frame
lfi.lfi_ulFlags &= ~LFF_ACTIVE;
// fade the flare in/out
#define FLAREINSPEED (0.2f)
#define FLAREOUTSPEED (0.1f)
if( lfi.lfi_ulFlags&LFF_VISIBLE) {
lfi.lfi_fFadeFactor += (tmNow-lfi.lfi_tmLastFrame) / FLAREINSPEED;
} else {
lfi.lfi_fFadeFactor -= (tmNow-lfi.lfi_tmLastFrame) / FLAREOUTSPEED;
}
lfi.lfi_fFadeFactor = Max( Min(lfi.lfi_fFadeFactor, 1.0f), 0.0f);
// reset timer of flare
lfi.lfi_tmLastFrame = tmNow;
// skip if the flare is invisible
if( lfi.lfi_fFadeFactor<0.01f) continue;
// calculate general flare factors
FLOAT fScreenSizeI = re_pdpDrawPort->GetWidth();
FLOAT fScreenSizeJ = re_pdpDrawPort->GetHeight();
FLOAT fScreenCenterI = fScreenSizeI*0.5f;
FLOAT fScreenCenterJ = fScreenSizeJ*0.5f;
FLOAT fLightI = lfi.lfi_fI;
FLOAT fLightJ = lfi.lfi_fJ;
FLOAT fIPositionFactor = (fLightI-fScreenCenterI)/fScreenSizeI;
FLOAT fReflectionDirI = fScreenCenterI-fLightI;
FLOAT fReflectionDirJ = fScreenCenterJ-fLightJ;
UBYTE ubR, ubG, ubB;
lfi.lfi_plsLightSource->GetLightColor(ubR, ubG, ubB);
UBYTE ubI = (ULONG(ubR)+ULONG(ubG)+ULONG(ubB))/3;
FLOAT fReflectionDistance = sqrt(fReflectionDirI*fReflectionDirI+fReflectionDirJ*fReflectionDirJ);
FLOAT fOfCenterFadeFactor = 1.0f-2.0f*fReflectionDistance/fScreenSizeI;
fOfCenterFadeFactor = Max(fOfCenterFadeFactor, 0.0f);
FLOAT fFogHazeFade = 1.0f;
// if in haze
if( lfi.lfi_ulFlags&LFF_HAZE) {
// get haze strength at light position
FLOAT fS = (-lfi.lfi_vProjected(3)+_haze_fAdd)*_haze_fMul;
FLOAT fHazeStrength = NormByteToFloat(GetHazeAlpha(fS));
// fade flare with haze
fFogHazeFade *= 1-fHazeStrength;
}
// if in fog
if( lfi.lfi_ulFlags&LFF_FOG) {
// get fog strength at light position
GFXTexCoord tex;
tex.st.s= -lfi.lfi_vProjected(3)*_fog_fMulZ;
tex.st.t = (lfi.lfi_vProjected%_fog_vHDirView+_fog_fAddH)*_fog_fMulH;
FLOAT fFogStrength = NormByteToFloat(GetFogAlpha(tex));
// fade flare with fog
fFogHazeFade *= 1-fFogStrength;
}
// get number of flares to render for this light
CStaticArray<COneLensFlare> &aolf = lfi.lfi_plsLightSource->ls_plftLensFlare->lft_aolfFlares;
INDEX ctReflections = aolf.Count();
// clamp number reflections if required
if( gfx_iLensFlareQuality<2 || _wrpWorldRenderPrefs.wrp_lftLensFlares==CWorldRenderPrefs::LFT_SINGLE_FLARE) {
ctReflections = 1;
}
// for each flare in the lens flare effect
{for(INDEX iReflection=0; iReflection<ctReflections; iReflection++) {
COneLensFlare &olf = aolf[iReflection];
// calculate its fading factors
FLOAT fFadeFactor = lfi.lfi_fFadeFactor * IntensityAtDistance(
lfi.lfi_plsLightSource->ls_rFallOff*olf.oft_fFallOffFactor,
lfi.lfi_plsLightSource->ls_rHotSpot*olf.oft_fFallOffFactor,
lfi.lfi_fDistance);
fFadeFactor*=fFogHazeFade;
if (olf.olf_ulFlags&OLF_FADEOFCENTER) {
fFadeFactor*=fOfCenterFadeFactor;
}
FLOAT fSizeIFactor = fScreenSizeI;
if (olf.olf_ulFlags&OLF_FADESIZE) {
fSizeIFactor *= fFadeFactor;
}
FLOAT fIntensityFactor = olf.olf_fLightAmplification;
if (olf.olf_ulFlags&OLF_FADEINTENSITY) {
fIntensityFactor *= fFadeFactor;
}
// calculate flare size
FLOAT fSizeI = olf.olf_fSizeIOverScreenSizeI*fSizeIFactor;
FLOAT fSizeJ = olf.olf_fSizeJOverScreenSizeI*fSizeIFactor;
// skip if this flare is invisible
if( fIntensityFactor<0.01f || fSizeI<2.0f || fSizeJ<2.0f) continue;
// determine color
FLOAT fThisR = (ubR + (FLOAT(ubI)-ubR)*olf.olf_fLightDesaturation)*fIntensityFactor;
FLOAT fThisG = (ubG + (FLOAT(ubI)-ubG)*olf.olf_fLightDesaturation)*fIntensityFactor;
FLOAT fThisB = (ubB + (FLOAT(ubI)-ubB)*olf.olf_fLightDesaturation)*fIntensityFactor;
UBYTE ubThisR = (UBYTE) (Min( fThisR, 255.0f));
UBYTE ubThisG = (UBYTE) (Min( fThisG, 255.0f));
UBYTE ubThisB = (UBYTE) (Min( fThisB, 255.0f));
COLOR colBlending = RGBToColor( ubThisR,ubThisG,ubThisB);
// render the flare
re_pdpDrawPort->RenderLensFlare(
&olf.olf_toTexture,
fLightI+olf.olf_fReflectionPosition*fReflectionDirI,
fLightJ+olf.olf_fReflectionPosition*fReflectionDirJ,
fSizeI, fSizeJ,
olf.olf_aRotationFactor*fIPositionFactor,
colBlending);
}} // for each flare in the lens flare effect
// if screen glare is on
CLensFlareType &lft = *lfi.lfi_plsLightSource->ls_plftLensFlare;
FLOAT fGlearCompression = lft.lft_fGlareCompression;
if( gfx_iLensFlareQuality>2
&& _wrpWorldRenderPrefs.wrp_lftLensFlares >= CWorldRenderPrefs::LFT_REFLECTIONS_AND_GLARE
&& lft.lft_fGlareIntensity>0.01f) {
// calculate glare factor for current position
FLOAT fIntensity = IntensityAtDistance( lfi.lfi_plsLightSource->ls_rFallOff*lft.lft_fGlareFallOffFactor,
lfi.lfi_plsLightSource->ls_rHotSpot*lft.lft_fGlareFallOffFactor,
lfi.lfi_fDistance);
FLOAT fCenterFactor = (1-fOfCenterFadeFactor);
FLOAT fGlare = lft.lft_fGlareIntensity*fIntensity
* (exp(1/(1+fGlearCompression*fCenterFactor*fCenterFactor)) -1) / (exp(1)-1);
ULONG ulGlareA = ClampUp( NormFloatToByte(fGlare), 255UL);
// if there is any relevant glare
if( ulGlareA>1) {
// calculate glare color
FLOAT fGlareR = (ubR + (FLOAT(ubI)-ubR) *lft.lft_fGlareDesaturation);
FLOAT fGlareG = (ubG + (FLOAT(ubI)-ubG) *lft.lft_fGlareDesaturation);
FLOAT fGlareB = (ubB + (FLOAT(ubI)-ubB) *lft.lft_fGlareDesaturation);
FLOAT fMax = Max( fGlareR, Max(fGlareG, fGlareB));
FLOAT fBrightFactor = 255.0f/fMax;
fGlareR *= fBrightFactor;
fGlareG *= fBrightFactor;
fGlareB *= fBrightFactor;
ULONG ulGlareR = ClampUp( FloatToInt(fGlareR), 255L);
ULONG ulGlareG = ClampUp( FloatToInt(fGlareG), 255L);
ULONG ulGlareB = ClampUp( FloatToInt(fGlareB), 255L);
// add the glare to screen blending
re_pdpDrawPort->dp_ulBlendingRA += ulGlareR*ulGlareA;
re_pdpDrawPort->dp_ulBlendingGA += ulGlareG*ulGlareA;
re_pdpDrawPort->dp_ulBlendingBA += ulGlareB*ulGlareA;
re_pdpDrawPort->dp_ulBlendingA += ulGlareA;
}
}
}}
}