q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-11-29 21:25:54 +01:00
Code Issues Packages Projects Releases Wiki Activity
f697fcc2f5
Serious-Engine/Sources/Engine/Light/LayerMaker.cpp
Matt Lee a4af93fa31 Add GPL header to files
2016-03-11 18:20:51 -06:00

892 lines
31 KiB
C++
Raw Blame History

/* 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. */
#include "stdh.h"
#include <Engine/Rendering/Render_internal.h>
#include <Engine/Brushes/Brush.h>
#include <Engine/Brushes/BrushTransformed.h>
#include <Engine/Light/LightSource.h>
#include <Engine/Base/ListIterator.inl>
#include <Engine/Graphics/Color.h>
#include <Engine/World/World.h>
#include <Engine/Entities/Entity.h>
#include <Engine/Templates/StaticArray.cpp>
#include <Engine/Graphics/GfxLibrary.h>
#include <Engine/Math/Clipping.inl>
#include <Engine/Light/Shadows_internal.h>
#include <Engine/World/WorldEditingProfile.h>
//#include <Engine/Graphics/ImageInfo.h>
//#include <Engine/Base/ErrorReporting.h>
extern INDEX _ctShadowLayers=0;
extern INDEX _ctShadowClusters=0;
// class used for making shadow layers (used only locally)
class CLayerMaker {
// implementation:
public:
// information about current polygon
CBrushPolygon *lm_pbpoPolygon; // the polygon
CBrushShadowMap *lm_pbsmShadowMap; // the shadow map on the polygon
FLOAT lm_fMipFactor; // the mip factor of this polygon
CWorld *lm_pwoWorld; // world for casting rays in
CBrushShadowLayer *lm_pbslLayer;// current layer
// dimensions of currently processed shadow map
MEX lm_mexSizeU; // size in mex
MEX lm_mexSizeV;
MEX lm_mexOffsetU; // offsets in mex
MEX lm_mexOffsetV;
INDEX lm_iMipLevel; // mip level
PIX lm_pixSizeU; // size in pixels
PIX lm_pixSizeV;
struct MipmapTable lm_mmtPolygonMask; // mip map table of the polygon mask
PIX lm_pixLayerMinU; // layer rectangle inside shadow map
PIX lm_pixLayerMinV;
PIX lm_pixLayerSizeU;
PIX lm_pixLayerSizeV;
FLOAT lm_fpixHotU;
FLOAT lm_fpixHotV;
FLOAT lm_fLightPlaneDistance;
struct MipmapTable lm_mmtLayer; // mip map table of the layer
UBYTE *lm_pubPolygonMask; // bit-packed mask of where the current polygon is
UBYTE *lm_pubLayer; // bit-packed mask of where the current light lights the polygon
FLOAT3D lm_vLight; // position of the light source
// gradients for shadow map walking
FLOAT3D lm_vO; // upper left corner of shadow map in 3D
FLOAT3D lm_vStepU; // step between pixels in same row
FLOAT3D lm_vStepV; // step between rows
ANGLE3D lm_aMappingOrientation; // orientation of the texture map in 3D
ANGLE3D lm_aInverseMappingOrientation;
FLOATmatrix3D lm_mToInverseMapping; // matrix for parallel lights
CLightSource *lm_plsLight; // current light
// remember general data
void CalculateData(void);
// make bit-packed mask of where the polygon is in the shadow map
void MakePolygonMask(void);
// make shadow mask for the light
ULONG MakeShadowMask(CBrushShadowLayer *pbsl);
ULONG MakeOneShadowMaskMip(INDEX iMip);
// flip shadow mask around V axis (for parallel lights)
void FlipShadowMask(INDEX iMip);
/* Spread the shadow towards pixels outside of polygon. */
void SpreadShadowMaskOutwards(void);
/* Spread the shadow towards pixels inside of polygon. */
void SpreadShadowMaskInwards(void);
public:
// interface:
/* Constructor. */
CLayerMaker(void);
/* Cast shadows for all layers of a given polygon. */
BOOL CreateLayers(CBrushPolygon &bpo, CWorld &woWorld, BOOL bDoDirectionalLights);
};
/* Make mip-maps of the shadow mask. */
static void MakeMipmapsForMask(UBYTE *pubMask, PIX pixSizeU, PIX pixSizeV, SLONG slTotalSize)
{
// remember pointer after first mip map
UBYTE *pubSecond = pubMask+pixSizeU*pixSizeV;
// start at the first mip map
UBYTE *pubThis = pubMask;
PIX pixThisSizeU = pixSizeU;
PIX pixThisSizeV = pixSizeV;
UBYTE *pubNext;
PIX pixNextSizeU;
PIX pixNextSizeV;
// repeat
for(;;) {
// calculate size and position of next mip map
pubNext = pubThis+pixThisSizeU*pixThisSizeV;
pixNextSizeU = pixThisSizeU/2;
pixNextSizeV = pixThisSizeV/2;
// if the next mip map is too small
if (pixNextSizeU<1 || pixNextSizeV<1) {
// stop
break;
}
// for each pixel in the next mip map
UBYTE *pub = pubNext;
for (PIX pixNextV=0; pixNextV<pixNextSizeV; pixNextV++) {
for (PIX pixNextU=0; pixNextU<pixNextSizeU; pixNextU++) {
// calculate the pixel from four pixels in this mip-map
UBYTE *pubUL = pubThis+pixNextU*2+pixNextV*2*pixThisSizeU;
UBYTE *pubUR = pubUL+1;
UBYTE *pubDL = pubUL+pixThisSizeU;
UBYTE *pubDR = pubDL+1;
ASSERT(pubDR<pubNext);
ULONG ulTotal = ULONG(*pubUL)+ULONG(*pubUR)+ULONG(*pubDL)+ULONG(*pubDR);
*pub++ = ulTotal/4;
}
}
// make next mip-map current
pubThis = pubNext;
pixThisSizeU = pixNextSizeU;
pixThisSizeV = pixNextSizeV;
}
// must have passed exactly all mip-maps
ASSERT(pubNext==pubMask+slTotalSize);
// for each pixel in all mip-maps after first
UBYTE *pubEnd = pubNext;
for (UBYTE *pub=pubSecond; pub<pubEnd; pub++) {
// normalize the pixel to 0-255
if (*pub<=128) {
*pub = 0;
} else {
*pub = 255;
}
}
}
// convert byte packed array to bits (can perform inplace conversion)
// NOTE: needs +8 bytes safety wall at the end
static void ConvertBytesToBits(UBYTE *pubBytesSrc, UBYTE *pubBitsDst, INDEX ctBytes)
{
// for each byte of bits
for (INDEX i=0; i<(ctBytes+7)/8; i++) {
// compose it from 8 bytes (note that bytes are either 0 or 255)
*pubBitsDst++ =
(pubBytesSrc[0]&0x01)|
(pubBytesSrc[1]&0x02)|
(pubBytesSrc[2]&0x04)|
(pubBytesSrc[3]&0x08)|
(pubBytesSrc[4]&0x10)|
(pubBytesSrc[5]&0x20)|
(pubBytesSrc[6]&0x40)|
(pubBytesSrc[7]&0x80);
pubBytesSrc+=8;
}
}
// convert bit packed array to bytes
// NOTE: needs +8 bytes safety wall at the end
static void ConvertBitsToBytes(UBYTE *pubBitsSrc, UBYTE *pubBytesDst, INDEX ctBytes)
{
// for each byte of bits
for (INDEX i=0; i<(ctBytes+7)/8; i++) {
// decompose it to 8 bytes
pubBytesDst[0] = (*pubBitsSrc)&0x01;
pubBytesDst[1] = (*pubBitsSrc)&0x02;
pubBytesDst[2] = (*pubBitsSrc)&0x04;
pubBytesDst[3] = (*pubBitsSrc)&0x08;
pubBytesDst[4] = (*pubBitsSrc)&0x10;
pubBytesDst[5] = (*pubBitsSrc)&0x20;
pubBytesDst[6] = (*pubBitsSrc)&0x40;
pubBytesDst[7] = (*pubBitsSrc)&0x80;
pubBitsSrc++;
pubBytesDst+=8;
}
}
// remember general data
void CLayerMaker::CalculateData(void)
{
lm_mexSizeU = lm_pbsmShadowMap->sm_mexWidth;
lm_mexSizeV = lm_pbsmShadowMap->sm_mexHeight;
lm_mexOffsetU = lm_pbsmShadowMap->sm_mexOffsetX;
lm_mexOffsetV = lm_pbsmShadowMap->sm_mexOffsetY;
lm_iMipLevel = lm_pbsmShadowMap->sm_iFirstMipLevel;
lm_pixSizeU = lm_mexSizeU>>lm_iMipLevel;
lm_pixSizeV = lm_mexSizeV>>lm_iMipLevel;
// find mip-mapping information for the polygon mask
MakeMipmapTable( lm_pixSizeU, lm_pixSizeV, lm_mmtPolygonMask);
CEntity *penWithPolygon = lm_pbpoPolygon->bpo_pbscSector->bsc_pbmBrushMip->bm_pbrBrush->br_penEntity;
ASSERT(penWithPolygon!=NULL);
const FLOATmatrix3D &mPolygonRotation = penWithPolygon->en_mRotation;
const FLOAT3D &vPolygonTranslation = penWithPolygon->GetPlacement().pl_PositionVector;
// get first pixel in texture in 3D
Vector<MEX, 2> vmex0;
vmex0(1) = -lm_mexOffsetU; //+(1<<(lm_iMipLevel-1));
vmex0(2) = -lm_mexOffsetV; //+(1<<(lm_iMipLevel-1));
lm_pbpoPolygon->bpo_mdShadow.GetSpaceCoordinates(
lm_pbpoPolygon->bpo_pbplPlane->bpl_pwplWorking->wpl_mvRelative,
vmex0, lm_vO);
lm_vO = lm_vO*mPolygonRotation+vPolygonTranslation;
// get steps for walking in texture in 3D
Vector<MEX, 2> vmexU, vmexV;
vmexU(1) = (1<<lm_iMipLevel)-lm_mexOffsetU; //+(1<<(lm_iMipLevel-1));
vmexU(2) = (0<<lm_iMipLevel)-lm_mexOffsetV; //+(1<<(lm_iMipLevel-1));
vmexV(1) = (0<<lm_iMipLevel)-lm_mexOffsetU; //+(1<<(lm_iMipLevel-1));
vmexV(2) = (1<<lm_iMipLevel)-lm_mexOffsetV; //+(1<<(lm_iMipLevel-1));
lm_pbpoPolygon->bpo_mdShadow.GetSpaceCoordinates(
lm_pbpoPolygon->bpo_pbplPlane->bpl_pwplWorking->wpl_mvRelative,
vmexU, lm_vStepU);
lm_vStepU = lm_vStepU*mPolygonRotation+vPolygonTranslation;
lm_pbpoPolygon->bpo_mdShadow.GetSpaceCoordinates(
lm_pbpoPolygon->bpo_pbplPlane->bpl_pwplWorking->wpl_mvRelative,
vmexV, lm_vStepV);
lm_vStepV = lm_vStepV*mPolygonRotation+vPolygonTranslation;
lm_vStepU-=lm_vO;
lm_vStepV-=lm_vO;
// make 3 orthogonal vectors that define mapping orientation
FLOAT3D vX = lm_vStepU;
FLOAT3D vY = -lm_vStepV;
FLOAT3D vZ = vX*vY;
// make a rotation matrix from those vectors
vX.Normalize();
vY.Normalize();
vZ.Normalize();
FLOATmatrix3D mOrientation;
mOrientation(1,1) = vX(1); mOrientation(1,2) = vY(1); mOrientation(1,3) = vZ(1);
mOrientation(2,1) = vX(2); mOrientation(2,2) = vY(2); mOrientation(2,3) = vZ(2);
mOrientation(3,1) = vX(3); mOrientation(3,2) = vY(3); mOrientation(3,3) = vZ(3);
FLOATmatrix3D mInvOrientation;
mInvOrientation(1,1) = -vX(1); mInvOrientation(1,2) = vY(1); mInvOrientation(1,3) = -vZ(1);
mInvOrientation(2,1) = -vX(2); mInvOrientation(2,2) = vY(2); mInvOrientation(2,3) = -vZ(2);
mInvOrientation(3,1) = -vX(3); mInvOrientation(3,2) = vY(3); mInvOrientation(3,3) = -vZ(3);
// make orientation angles from the matrix
DecomposeRotationMatrixNoSnap(lm_aMappingOrientation, mOrientation);
DecomposeRotationMatrixNoSnap(lm_aInverseMappingOrientation, mInvOrientation);
// remember matrix for parallel lights
lm_mToInverseMapping = !mInvOrientation;
}
// test if a point is inside a brush polygon
inline BOOL TestPointInPolygon(CBrushPolygon &bpo, const FLOAT3D &v)
{
// find major axes of the polygon plane
INDEX iMajorAxis1 = bpo.bpo_pbplPlane->bpl_iPlaneMajorAxis1;
INDEX iMajorAxis2 = bpo.bpo_pbplPlane->bpl_iPlaneMajorAxis2;
// if the point is not inside the bounding box of polygon (projected to the major plane)
if (v(iMajorAxis1)<bpo.bpo_boxBoundingBox.Min()(iMajorAxis1)
||v(iMajorAxis1)>bpo.bpo_boxBoundingBox.Max()(iMajorAxis1)
||v(iMajorAxis2)<bpo.bpo_boxBoundingBox.Min()(iMajorAxis2)
||v(iMajorAxis2)>bpo.bpo_boxBoundingBox.Max()(iMajorAxis2)
) {
// it is not inside the polygon
return FALSE;
}
// create an intersector
CIntersector isIntersector(v(iMajorAxis1), v(iMajorAxis2));
// for all edges in the polygon
FOREACHINSTATICARRAY(bpo.bpo_abpePolygonEdges, CBrushPolygonEdge, itbpe) {
// get edge vertices (edge direction is irrelevant here!)
const FLOAT3D &vVertex0 = itbpe->bpe_pbedEdge->bed_pbvxVertex0->bvx_vAbsolute;
const FLOAT3D &vVertex1 = itbpe->bpe_pbedEdge->bed_pbvxVertex1->bvx_vAbsolute;
// pass the edge to the intersector
isIntersector.AddEdge(
vVertex0(iMajorAxis1), vVertex0(iMajorAxis2),
vVertex1(iMajorAxis1), vVertex1(iMajorAxis2));
}
// ask the intersector if the point is inside the polygon
return isIntersector.IsIntersecting();
}
/////////////////////////////////////////////////////////////////////
// CLayerMaker
/*
* Constructor.
*/
CLayerMaker::CLayerMaker(void)
{
}
/* Spread the shadow towards pixels outside of polygon. */
void CLayerMaker::SpreadShadowMaskOutwards(void)
{
// for each mip map of the layer
for(INDEX iMipmap=0; iMipmap<lm_mmtLayer.mmt_ctMipmaps; iMipmap++) {
PIX pixLayerMinU = lm_pixLayerMinU>>iMipmap;
PIX pixLayerMinV = lm_pixLayerMinV>>iMipmap;
PIX pixLayerSizeU = lm_pixLayerSizeU>>iMipmap;
PIX pixLayerSizeV = lm_pixLayerSizeV>>iMipmap;
PIX pixSizeU = lm_pixSizeU>>iMipmap;
PIX pixSizeV = lm_pixSizeV>>iMipmap;
PIX pixSizeULog2 = FastLog2(lm_pixSizeU)-iMipmap;
UBYTE *pubLayer = lm_pubLayer+lm_mmtLayer.mmt_aslOffsets[iMipmap];
UBYTE *pubPolygonMask = lm_pubPolygonMask+lm_mmtPolygonMask.mmt_aslOffsets[iMipmap];
SLONG slOffsetLayer = 0;
// for each pixel in the layer shadow mask
for (PIX pixLayerV=0; pixLayerV<pixLayerSizeV; pixLayerV++) {
for (PIX pixLayerU=0; pixLayerU<pixLayerSizeU; pixLayerU++) {
PIX pixMapU = pixLayerU+pixLayerMinU;
PIX pixMapV = pixLayerV+pixLayerMinV;
PIX slOffsetMap = pixMapU+(pixMapV<<pixSizeULog2);
// if the pixel is not inside the polygon
if (!pubPolygonMask[slOffsetMap]) {
// find number of all of its neighbours that are in the polygon
// and number of all of them that are not in the shadow
INDEX ctInPolygon = 0;
INDEX ctLighted = 0;
#define ADDNEIGHBOUR(du, dv) \
if ((pixLayerU+(du)>=0) \
&&(pixLayerU+(du)<pixLayerSizeU) \
&&(pixLayerV+(dv)>=0) \
&&(pixLayerV+(dv)<pixLayerSizeV) \
&&(pubPolygonMask[slOffsetMap+(du)+((dv)<<pixSizeULog2)])) { \
ctInPolygon++; \
ctLighted+=pubLayer[slOffsetLayer+(du)+(dv)*pixLayerSizeU]&0x01; \
}
ADDNEIGHBOUR(-2, -2);
ADDNEIGHBOUR(-1, -2);
ADDNEIGHBOUR(+0, -2);
ADDNEIGHBOUR(+1, -2);
ADDNEIGHBOUR(+2, -2);
ADDNEIGHBOUR(-2, -1);
ADDNEIGHBOUR(-1, -1);
ADDNEIGHBOUR(+0, -1);
ADDNEIGHBOUR(+1, -1);
ADDNEIGHBOUR(+2, -1);
ADDNEIGHBOUR(-2, +0);
ADDNEIGHBOUR(-1, +0);
// ADDNEIGHBOUR(+0, +0);
ADDNEIGHBOUR(+1, +0);
ADDNEIGHBOUR(+2, +0);
ADDNEIGHBOUR(-2, +1);
ADDNEIGHBOUR(-1, +1);
ADDNEIGHBOUR(+0, +1);
ADDNEIGHBOUR(+1, +1);
ADDNEIGHBOUR(+2, +1);
ADDNEIGHBOUR(-2, +2);
ADDNEIGHBOUR(-1, +2);
ADDNEIGHBOUR(+0, +2);
ADDNEIGHBOUR(+1, +2);
ADDNEIGHBOUR(+2, +2);
// if there are some neighbours inside, and most of them are lighted
if ((ctInPolygon>0) && (ctLighted>ctInPolygon/2)) {
// make this one lighted
pubLayer[slOffsetLayer] = 255;
// otherwise
} else {
// make this one shadowed
pubLayer[slOffsetLayer] = 0;
}
// if the pixel is inside the polygon
} else {
NOTHING;
}
slOffsetLayer++;
}
}
}
}
/* Spread the shadow towards pixels inside of polygon. */
void CLayerMaker::SpreadShadowMaskInwards(void)
{
// for each mip map of the layer
for(INDEX iMipmap=0; iMipmap<lm_mmtLayer.mmt_ctMipmaps; iMipmap++) {
PIX pixLayerMinU = lm_pixLayerMinU>>iMipmap;
PIX pixLayerMinV = lm_pixLayerMinV>>iMipmap;
PIX pixLayerSizeU = lm_pixLayerSizeU>>iMipmap;
PIX pixLayerSizeV = lm_pixLayerSizeV>>iMipmap;
PIX pixSizeU = lm_pixSizeU>>iMipmap;
PIX pixSizeV = lm_pixSizeV>>iMipmap;
PIX pixSizeULog2 = FastLog2(lm_pixSizeU)-iMipmap;
UBYTE *pubLayer = lm_pubLayer+lm_mmtLayer.mmt_aslOffsets[iMipmap];
UBYTE *pubPolygonMask = lm_pubPolygonMask+lm_mmtPolygonMask.mmt_aslOffsets[iMipmap];
SLONG slOffsetLayer = 0;
// for each pixel in the layer shadow mask
for (PIX pixLayerV=0; pixLayerV<pixLayerSizeV; pixLayerV++) {
for (PIX pixLayerU=0; pixLayerU<pixLayerSizeU; pixLayerU++) {
PIX pixMapU = pixLayerU+pixLayerMinU;
PIX pixMapV = pixLayerV+pixLayerMinV;
PIX slOffsetMap = pixMapU+(pixMapV<<pixSizeULog2);
// if the pixel is inside the polygon
if (pubPolygonMask[slOffsetMap]) {
// find number of all of its neighbours that are out of the polygon
// and number of all of them that are not in the shadow
INDEX ctOutPolygon = 0;
INDEX ctLighted = 0;
#undef ADDNEIGHBOUR
#define ADDNEIGHBOUR(du, dv) \
if ((pixLayerU+(du)>=0) \
&&(pixLayerU+(du)<pixLayerSizeU) \
&&(pixLayerV+(dv)>=0) \
&&(pixLayerV+(dv)<pixLayerSizeV)) \
{\
if(!pubPolygonMask[slOffsetMap+(du)+((dv)<<pixSizeULog2)]) { \
ctOutPolygon++; \
ctLighted+=pubLayer[slOffsetLayer+(du)+(dv)*pixLayerSizeU]&0x01; \
}\
}
/*
ADDNEIGHBOUR(-2, -2);
ADDNEIGHBOUR(+2, -2);
ADDNEIGHBOUR(-2, +2);
ADDNEIGHBOUR(+2, +2);
*/
ADDNEIGHBOUR(-1, -2);
ADDNEIGHBOUR(+0, -2);
ADDNEIGHBOUR(+1, -2);
ADDNEIGHBOUR(-2, -1);
ADDNEIGHBOUR(+2, -1);
ADDNEIGHBOUR(-2, +0);
ADDNEIGHBOUR(+2, +0);
ADDNEIGHBOUR(-2, +1);
ADDNEIGHBOUR(+2, +1);
ADDNEIGHBOUR(-1, +2);
ADDNEIGHBOUR(+0, +2);
ADDNEIGHBOUR(+1, +2);
ADDNEIGHBOUR(-1, -1);
ADDNEIGHBOUR(+0, -1);
ADDNEIGHBOUR(+1, -1);
ADDNEIGHBOUR(-1, +0);
// ADDNEIGHBOUR(+0, +0);
ADDNEIGHBOUR(+1, +0);
ADDNEIGHBOUR(-1, +1);
ADDNEIGHBOUR(+0, +1);
ADDNEIGHBOUR(+1, +1);
// if there are some neighbours outside
if (ctOutPolygon>0) {
// if some are not lighted
if (ctLighted<ctOutPolygon) {
// make this one shadowed
pubLayer[slOffsetLayer] = 0;
// otherwise
} else {
// make this one lighted
// pubLayer[slOffsetLayer] = 255;
}
}
// if the pixel is not inside the polygon
} else {
NOTHING;
}
slOffsetLayer++;
}
}
}
}
// make bit-packed mask of where the polygon is in the shadow map
void CLayerMaker::MakePolygonMask(void)
{
// allocate memory for the mask
lm_pubPolygonMask = (UBYTE *)AllocMemory(lm_mmtPolygonMask.mmt_slTotalSize+8);
// if there is packed polygon mask remembered in the shadow map
if (lm_pbsmShadowMap->bsm_pubPolygonMask!=NULL) {
// convert it from bit-packed into byte-packed mask
ConvertBitsToBytes(
lm_pbsmShadowMap->bsm_pubPolygonMask,
lm_pubPolygonMask,
lm_mmtPolygonMask.mmt_slTotalSize);
} else {
UBYTE *pub = lm_pubPolygonMask;
// for each mip-map
for (INDEX iMipmap=0; iMipmap<lm_mmtPolygonMask.mmt_ctMipmaps; iMipmap++) {
UBYTE *pubForSaving = pub;
// start at the first pixel
FLOAT3D vRow = lm_vO+(lm_vStepU+lm_vStepV)*(FLOAT(1<<iMipmap)/2.0f);
// for each pixel in the shadow map
for (PIX pixV=0; pixV<lm_pixSizeV>>iMipmap; pixV++) {
FLOAT3D vPoint = vRow;
for (PIX pixU=0; pixU<lm_pixSizeU>>iMipmap; pixU++) {
// if the point is in the polygon
if (TestPointInPolygon(*lm_pbpoPolygon, vPoint)) {
// set the pixel
*pub = 255;
// if the point is not in the polygon
} else {
// clear the pixel
*pub = 0;
}
// go to the next pixel
pub++;
vPoint+=lm_vStepU*FLOAT(1<<iMipmap);
}
vRow+=lm_vStepV*FLOAT(1<<iMipmap);
}
}
// make mip maps of the polygon mask
// MakeMipmapsForMask(lm_pubPolygonMask, lm_pixSizeU, lm_pixSizeV,
// lm_mmtPolygonMask.mmt_slTotalSize);
// convert it from byte-packed into bit-packed mask
lm_pbsmShadowMap->bsm_pubPolygonMask = (UBYTE *)AllocMemory((lm_mmtPolygonMask.mmt_slTotalSize+7)/8);
ConvertBytesToBits(
lm_pubPolygonMask,
lm_pbsmShadowMap->bsm_pubPolygonMask,
lm_mmtPolygonMask.mmt_slTotalSize);
}
}
// flip shadow mask around V axis (for parallel lights)
void CLayerMaker::FlipShadowMask(INDEX iMip)
{
PIX pixLayerMinU = lm_pixLayerMinU>>iMip;
PIX pixLayerMinV = lm_pixLayerMinV>>iMip;
PIX pixLayerSizeU = lm_pixLayerSizeU>>iMip;
PIX pixLayerSizeV = lm_pixLayerSizeV>>iMip;
UBYTE *pubLayer = lm_pubLayer+lm_mmtLayer.mmt_aslOffsets[iMip];
UBYTE *pubRow = pubLayer;
// for each row
for (PIX pixV=0; pixV<pixLayerSizeV; pixV++) {
// flip the row
UBYTE *pubLt = pubRow;
UBYTE *pubRt = pubRow+pixLayerSizeU-1;
for (PIX pixU=0; pixU<pixLayerSizeU/2; pixU++) {
Swap(*pubLt, *pubRt);
pubLt++;
pubRt--;
}
pubRow+=pixLayerSizeU;
}
}
// make shadow mask for the light
ULONG CLayerMaker::MakeShadowMask(CBrushShadowLayer *pbsl)
{
// if the light doesn't cast shadows, or the polygon does not receive them
if (!(pbsl->bsl_plsLightSource->ls_ulFlags&LSF_CASTSHADOWS) ||
(lm_pbpoPolygon->bpo_ulFlags&BPOF_DOESNOTRECEIVESHADOW) ) {
// do nothing
return BSLF_ALLLIGHT;
}
// remember current layer and its light source
lm_plsLight = pbsl->bsl_plsLightSource;
lm_pbslLayer = pbsl;
lm_vLight = lm_plsLight->ls_penEntity->GetPlacement().pl_PositionVector;
// find the influenced rectangle
CLightRectangle lr;
lm_pbsmShadowMap->FindLightRectangle(*lm_plsLight, lr);
ASSERT(lr.lr_pixSizeU == lm_pbslLayer->bsl_pixSizeU);
ASSERT(lr.lr_pixSizeV == lm_pbslLayer->bsl_pixSizeV);
lm_fpixHotU = lr.lr_fpixHotU;
lm_fpixHotV = lr.lr_fpixHotV;
lm_fLightPlaneDistance = lr.lr_fLightPlaneDistance;
lm_pixLayerMinU = lr.lr_pixMinU;
lm_pixLayerMinV = lr.lr_pixMinV;
lm_pixLayerSizeU= lr.lr_pixSizeU;
lm_pixLayerSizeV= lr.lr_pixSizeV;
// find mip-mapping information for the rectangle
MakeMipmapTable(lm_pixLayerSizeU, lm_pixLayerSizeV, lm_mmtLayer);
ASSERT(lr.lr_pixSizeU == lm_pbslLayer->bsl_pixSizeU);
ASSERT(lr.lr_pixSizeV == lm_pbslLayer->bsl_pixSizeV);
ASSERT(lr.lr_pixSizeU <= lm_pixSizeU);
ASSERT(lr.lr_pixSizeV <= lm_pixSizeV);
// if there is no influence, do nothing
if ((lr.lr_pixSizeU==0) || (lr.lr_pixSizeV==0)) return BSLF_ALLDARK;
lm_pbslLayer->bsl_pixMinU = lr.lr_pixMinU;
lm_pbslLayer->bsl_pixMinV = lr.lr_pixMinV;
lm_pbslLayer->bsl_pixSizeU = lr.lr_pixSizeU;
lm_pbslLayer->bsl_pixSizeV = lr.lr_pixSizeV;
lm_pbslLayer->bsl_slSizeInPixels = lm_mmtLayer.mmt_slTotalSize;
// allocate shadow mask for the light (+8 is safety wall for fast conversions)
lm_pubLayer = (UBYTE *)AllocMemory(lm_mmtLayer.mmt_slTotalSize+8);
const FLOAT fEpsilon = (1<<lm_iMipLevel)/1024.0f;
ULONG ulLighted=BSLF_ALLLIGHT|BSLF_ALLDARK;
// if this polygon requires exact shadows
if (lm_pbpoPolygon->bpo_ulFlags & BPOF_ACCURATESHADOWS) {
// make each mip-map of mask for itself
for(INDEX iMip=0; iMip<lm_mmtLayer.mmt_ctMipmaps; iMip++) {
ulLighted&=MakeOneShadowMaskMip(iMip);
}
} else {
// make first mip-map of mask
ulLighted&=MakeOneShadowMaskMip(0);
// make other shadow mask mips from the first one
MakeMipmapsForMask( lm_pubLayer, lm_mmtLayer.mmt_pixU, lm_mmtLayer.mmt_pixV,
lm_mmtLayer.mmt_slTotalSize);
}
// spread the shadow mask towards pixels outside of polygon
if( !(lm_pbpoPolygon->bpo_ulFlags&BPOF_DARKCORNERS)) {
SpreadShadowMaskOutwards();
} else {
SpreadShadowMaskInwards();
SpreadShadowMaskOutwards();
}
// convert the shadow mask from byte-packed into bit-packed mask
ConvertBytesToBits(lm_pubLayer, lm_pubLayer, lm_mmtLayer.mmt_slTotalSize);
ShrinkMemory((void **)&lm_pubLayer, (lm_mmtLayer.mmt_slTotalSize+7)/8);
pbsl->bsl_pubLayer = lm_pubLayer;
// update statistics
_ctShadowLayers++;
_ctShadowClusters+=lm_mmtLayer.mmt_slTotalSize;
return ulLighted;
}
ULONG CLayerMaker::MakeOneShadowMaskMip(INDEX iMip)
{
ULONG ulLighted=BSLF_ALLLIGHT|BSLF_ALLDARK;
PIX pixLayerMinU = lm_pixLayerMinU>>iMip;
PIX pixLayerMinV = lm_pixLayerMinV>>iMip;
PIX pixLayerSizeU = lm_pixLayerSizeU>>iMip;
PIX pixLayerSizeV = lm_pixLayerSizeV>>iMip;
INDEX iMipLevel = lm_iMipLevel+iMip;
FLOAT3D vO = lm_vO+(lm_vStepU+lm_vStepV)*(FLOAT(1<<iMip)/2.0f);
FLOAT3D vStepU = lm_vStepU*FLOAT(1<<iMip);
FLOAT3D vStepV = lm_vStepV*FLOAT(1<<iMip);
FLOAT fpixHotU = lm_fpixHotU/FLOAT(1<<iMip);
FLOAT fpixHotV = lm_fpixHotV/FLOAT(1<<iMip);
UBYTE *pubLayer = lm_pubLayer+lm_mmtLayer.mmt_aslOffsets[iMip];
// if the light is directional
if (lm_plsLight->ls_ulFlags&LSF_DIRECTIONAL) {
// prepare parallel projection as if viewing from polygon and the shadow map is screen
CParallelProjection3D prProjection;
prProjection.ScreenBBoxL() = FLOATaabbox2D(
FLOAT2D(pixLayerMinU,
pixLayerMinV),
FLOAT2D(pixLayerMinU+pixLayerSizeU,
pixLayerMinV+pixLayerSizeV)
);
prProjection.AspectRatioL() = 1.0f;
prProjection.NearClipDistanceL() = 0.00f;
prProjection.pr_vZoomFactors(1) =
prProjection.pr_vZoomFactors(2) = 1024.0f/(1<<iMipLevel);
FLOAT3D vDirection;
AnglesToDirectionVector(
lm_plsLight->ls_penEntity->GetPlacement().pl_OrientationAngle,
vDirection);
// if polygon is turned away from the light
if ((vDirection%(const FLOAT3D &)lm_pbpoPolygon->bpo_pbplPlane->bpl_plAbsolute)>-0.001) {
// layer is all dark
return BSLF_ALLDARK;
}
vDirection = vDirection*lm_mToInverseMapping;
prProjection.pr_vStepFactors(1) = -vDirection(1)/vDirection(3);
prProjection.pr_vStepFactors(2) = -vDirection(2)/vDirection(3);
prProjection.pr_vStepFactors(1)*=prProjection.pr_vZoomFactors(1);
prProjection.pr_vStepFactors(2)*=prProjection.pr_vZoomFactors(2);
CPlacement3D plCenter;
plCenter.pl_OrientationAngle = lm_aInverseMappingOrientation;
plCenter.pl_PositionVector =
vO
+vStepU*(FLOAT(pixLayerSizeU)/2-0.5f) // !!!!
+vStepV*(FLOAT(pixLayerSizeV)/2);//+5.0f);
prProjection.ViewerPlacementL() = plCenter;
// render the view to the shadow layer (but ignore the target polygon)
CAnyProjection3D apr;
apr = prProjection;
ULONG ulFlagsBefore = lm_pbpoPolygon->bpo_ulFlags;
lm_pbpoPolygon->bpo_ulFlags |= BPOF_INVISIBLE;
ulLighted&=RenderShadows(*lm_pwoWorld, *(CEntity*)NULL, apr,
lm_pbpoPolygon->bpo_boxBoundingBox, pubLayer, pixLayerSizeU, pixLayerSizeV,
lm_plsLight->ls_ubPolygonalMask);
lm_pbpoPolygon->bpo_ulFlags = ulFlagsBefore;
// flip the shadow mask around v axis (left-right)
FlipShadowMask(iMip);
// if the light is point
} else {
// prepare perspective projection as if viewing from light and the shadow map is screen
CPerspectiveProjection3D prProjection;
if( !(lm_pbpoPolygon->bpo_ulFlags&BPOF_DARKCORNERS)) {
prProjection.ScreenBBoxL() = FLOATaabbox2D(
FLOAT2D(pixLayerMinU-fpixHotU+1,
pixLayerMinV-fpixHotV+1),
FLOAT2D(pixLayerMinU+pixLayerSizeU-fpixHotU+1,
pixLayerMinV+pixLayerSizeV-fpixHotV+1)
);
} else {
prProjection.ScreenBBoxL() = FLOATaabbox2D(
FLOAT2D(pixLayerMinU-fpixHotU,
pixLayerMinV-fpixHotV),
FLOAT2D(pixLayerMinU+pixLayerSizeU-fpixHotU,
pixLayerMinV+pixLayerSizeV-fpixHotV)
);
}
prProjection.AspectRatioL() = 1.0f;
prProjection.NearClipDistanceL() = lm_plsLight->ls_fNearClipDistance;
prProjection.FarClipDistanceL()
= lm_fLightPlaneDistance-lm_plsLight->ls_fFarClipDistance; //-fEpsilon/2; !!!! use minimal epsilon for polygon
prProjection.ppr_fMetersPerPixel = (1<<iMipLevel)/1024.0f;
prProjection.ppr_fViewerDistance = lm_fLightPlaneDistance;
CPlacement3D plLight;
plLight.pl_OrientationAngle = lm_aMappingOrientation;
plLight.pl_PositionVector = lm_vLight;
prProjection.ViewerPlacementL() = plLight;
CAnyProjection3D apr;
apr = prProjection;
// ignore the target polygon during rendering
ULONG ulFlagsBefore = lm_pbpoPolygon->bpo_ulFlags;
lm_pbpoPolygon->bpo_ulFlags |= BPOF_INVISIBLE;
// if light is not illumination light
if (lm_plsLight->ls_ubPolygonalMask==0) {
// just render starting at the light entity position
ulLighted&=RenderShadows(*lm_pwoWorld, *lm_plsLight->ls_penEntity,
apr, FLOATaabbox3D(),
pubLayer, pixLayerSizeU, pixLayerSizeV,
lm_plsLight->ls_ubPolygonalMask);
// if light is illumination light
} else {
// add entire box around target polygon and light position to rendering
FLOATaabbox3D box = lm_pbpoPolygon->bpo_boxBoundingBox;
box|=lm_plsLight->ls_penEntity->GetPlacement().pl_PositionVector;
ulLighted&=RenderShadows(*lm_pwoWorld, *(CEntity*)NULL, apr, box,
pubLayer, pixLayerSizeU, pixLayerSizeV,
lm_plsLight->ls_ubPolygonalMask);
}
lm_pbpoPolygon->bpo_ulFlags = ulFlagsBefore;
}
return ulLighted;
}
/*
* Create a shadow map for a given polygon.
*/
BOOL CLayerMaker::CreateLayers(CBrushPolygon &bpo, CWorld &woWorld, BOOL bDoDirectionalLights)
{
// __pfWorldEditingProfile.IncrementAveragingCounter();
// __pfWorldEditingProfile.StartTimer(CWorldEditingProfile::PTI_MAKESHADOWS);
BOOL bInitialized = FALSE;
BOOL bCalculatedSome = FALSE;
BOOL bSomeAreUncalculated = FALSE;
// remember the world
lm_pwoWorld = &woWorld;
lm_pbsmShadowMap = &bpo.bpo_smShadowMap;
lm_pbpoPolygon = &bpo;
// for each layer that should be calculated, but isn't
FORDELETELIST(CBrushShadowLayer, bsl_lnInShadowMap, lm_pbsmShadowMap->bsm_lhLayers, itbsl) {
// if already calculated, or dynamic
if (itbsl->bsl_ulFlags&BSLF_CALCULATED ||
itbsl->bsl_plsLightSource->ls_ulFlags&LSF_DYNAMIC) {
// skip it
continue;
}
// if we are not doing directional lights and it is directional
if (!bDoDirectionalLights
&& (itbsl->bsl_plsLightSource->ls_ulFlags&LSF_DIRECTIONAL)) {
// skip it
bSomeAreUncalculated = TRUE;
continue;
}
// if not yet initialized
if( !bInitialized) {
// remember general data
CalculateData();
// make bit-packed mask of where the polygon is in the shadow map
MakePolygonMask();
bInitialized = TRUE;
}
CBrushShadowLayer &bsl = *itbsl;
// mark the layer is calculated
bsl.bsl_ulFlags |= BSLF_CALCULATED;
// make shadow mask for the light
ULONG ulLighted=MakeShadowMask(itbsl);
ASSERT((ulLighted==0) || (ulLighted==BSLF_ALLLIGHT) || (ulLighted==BSLF_ALLDARK));
bsl.bsl_ulFlags &= ~(BSLF_ALLLIGHT|BSLF_ALLDARK);
bsl.bsl_ulFlags |= ulLighted;
// if the layer is not needed
if( ulLighted&(BSLF_ALLLIGHT|BSLF_ALLDARK)) {
// free it
if( bsl.bsl_pubLayer!=NULL) FreeMemory( bsl.bsl_pubLayer);
bsl.bsl_pubLayer = NULL;
}
bCalculatedSome = TRUE;
}
// if was intialized
if( bInitialized) {
// free bit-packed polygon mask
FreeMemory( lm_pubPolygonMask);
}
// if some new layers have been calculated
if( bCalculatedSome) {
// invalidate mixed layers
bpo.bpo_smShadowMap.Invalidate();
}
return bSomeAreUncalculated;
}
/*
* Create shadow map for the polygon.
*/
void CBrushPolygon::MakeShadowMap(CWorld *pwoWorld, BOOL bDoDirectionalLights)
{
_pfWorldEditingProfile.StartTimer(CWorldEditingProfile::PTI_MAKESHADOWMAP);
// create new shadow map
CLayerMaker lmMaker;
BOOL bSomeAreUncalculated = lmMaker.CreateLayers(*this, *pwoWorld, bDoDirectionalLights);
// unqueue the shadow map
if (!bSomeAreUncalculated && bpo_smShadowMap.bsm_lnInUncalculatedShadowMaps.IsLinked()) {
bpo_smShadowMap.bsm_lnInUncalculatedShadowMaps.Remove();
}
_pfWorldEditingProfile.StopTimer(CWorldEditingProfile::PTI_MAKESHADOWMAP);
}
Reference in New Issue View Git Blame Copy Permalink