// ***************************************************************************
void CScene::renderOcclusionTestMeshs()
{
nlassert(RenderTrav.getDriver());
RenderTrav.getDriver()->setupViewport(RenderTrav.getViewport());
RenderTrav.getDriver()->activeVertexProgram(NULL);
RenderTrav.getDriver()->activePixelProgram(NULL);
RenderTrav.getDriver()->activeGeometryProgram(NULL);
IDriver::TPolygonMode oldPolygonMode = RenderTrav.getDriver()->getPolygonMode();
CMaterial m;
m.initUnlit();
m.setColor(CRGBA(255, 255, 255, 127));
m.setBlend(true);
m.setDstBlend(CMaterial::invsrcalpha);
m.setSrcBlend(CMaterial::srcalpha);
m.setZWrite(false);
RenderTrav.getDriver()->setupMaterial(m);
getDriver()->setPolygonMode(IDriver::Filled);
renderOcclusionTestMeshsWithCurrMaterial();
m.setColor(CRGBA::Black);
RenderTrav.getDriver()->setupMaterial(m);
getDriver()->setPolygonMode(IDriver::Line);
renderOcclusionTestMeshsWithCurrMaterial();
getDriver()->setPolygonMode(oldPolygonMode);
}
// *************************************************************************************************
void makeInstanceTransparent(UInstance &inst, uint8 opacity, bool disableZWrite)
{
UShape shape= inst.getShape();
if(shape.empty())
return;
uint numMats= shape.getNumMaterials();
if(numMats==0)
return;
if(numMats!=inst.getNumMaterials())
return;
// instance transparent or not?
if (opacity == 255)
{
// reset default shape opacity / transparency
inst.setOpacity(shape.getDefaultOpacity());
inst.setTransparency(shape.getDefaultTransparency());
inst.setBypassLODOpacityFlag(false);
}
else
{
// Will have some blend material => sure not to be rendered in Opaque pass
inst.setOpacity(false);
inst.setTransparency(true);
inst.setBypassLODOpacityFlag(true); // these flags prevails over the current lods flags for multi-lod objects
}
// set all materials
for (uint32 j = 0; j < numMats; ++j)
{
NL3D::UInstanceMaterial matInst = inst.getMaterial(j);
NL3D::UMaterial matShape= shape.getMaterial(j);
// disalbe zwrite?
if(disableZWrite)
matInst.setZWrite(false);
else
matInst.setZWrite(matShape.getZWrite());
// if no more transparent
if (opacity == 255)
{
// reset to default
matInst.setBlend(matShape.getBlend());
matInst.setBlendFunc((NL3D::UInstanceMaterial::TBlend)matShape.getSrcBlend(),
(NL3D::UInstanceMaterial::TBlend)matShape.getDstBlend());
// if orginal material is opaque or additif and has no alpha test, then ensure restore last tex env if needed
CMaterial *destInternalMat = matInst.getObjectPtr();
if (!matShape.getBlend() && !matShape.getAlphaTest())
{
if (destInternalMat->getShader() == CMaterial::Normal)
{
CMaterial *srcInternalMat = matShape.getObjectPtr();
uint numTex = 0;
for (;numTex < 4 && srcInternalMat->getTexture(numTex) != NULL; ++numTex) {}
if (numTex > 0)
{
if (srcInternalMat->getTexEnvMode(numTex - 1) != destInternalMat->getTexEnvMode(numTex - 1))
{
destInternalMat->setTexEnvMode(numTex - 1, srcInternalMat->getTexEnvMode(numTex - 1));
}
}
}
}
if (destInternalMat->getShader() == CMaterial::Normal)
{
// if !lighted, restore color
if (!destInternalMat->isLighted())
{
CMaterial *srcInternalMat = matShape.getObjectPtr();
// restore alpha in color
CRGBA color = destInternalMat->getColor();
color.A = srcInternalMat->getColor().A;
destInternalMat->setColor(color);
}
}
}
else
{
// Enable blend
matInst.setBlend(true);
// If default is ???/one or , then use a srcalpha/one (eg: for Diamond-like weapons)
if(matShape.getBlend() && (sint32)matShape.getDstBlend()==(sint32)NL3D::UInstanceMaterial::one)
matInst.setBlendFunc(NL3D::UInstanceMaterial::srcalpha, NL3D::UInstanceMaterial::one);
// else use a standard srcalpha/invsrcalpha
else
matInst.setBlendFunc(NL3D::UInstanceMaterial::srcalpha, NL3D::UInstanceMaterial::invsrcalpha);
// if orginal material is opaque or additif and has no alpha test, then ensure that the alpha output is 'diffuse'
CMaterial *internalMat = matInst.getObjectPtr();
if (!matShape.getBlend() && !matShape.getAlphaTest())
{
if (internalMat->getShader() == CMaterial::Normal)
{
uint numTex = 0;
for (;numTex < 4 && internalMat->getTexture(numTex) != NULL; ++numTex) {}
if (numTex > 0)
{
internalMat->texEnvOpAlpha(numTex - 1, CMaterial::Replace);
// if material is unlighted, then use the constant at this stage to set the alpha
internalMat->texEnvArg0Alpha(numTex - 1, CMaterial::Diffuse, CMaterial::SrcAlpha);
}
}
}
if (internalMat->getShader() == CMaterial::Normal)
{
if (!internalMat->isLighted())
{
// replace alpha in color
CRGBA color = internalMat->getColor();
color.A = opacity;
internalMat->setColor(color);
}
}
}
// suppose that default opacity is always 255
if (matInst.isLighted())
{
matInst.setOpacity(opacity);
}
matInst.setAlphaTestThreshold(matShape.getAlphaTestThreshold()*((float)opacity)/255.0f);
}
}
// TMP TMP
void tempDumpColPolys()
{
CPackedWorld *pw = R2::getEditor().getIslandCollision().getPackedIsland();
if (pw)
{
static CMaterial material;
static CMaterial wiredMaterial;
static CMaterial texturedMaterial;
static CVertexBuffer vb;
static bool initDone = false;
if (!initDone)
{
vb.setVertexFormat(CVertexBuffer::PositionFlag);
vb.setPreferredMemory(CVertexBuffer::AGPVolatile, false);
material.initUnlit();
material.setDoubleSided(true);
material.setZFunc(CMaterial::lessequal);
wiredMaterial.initUnlit();
wiredMaterial.setDoubleSided(true);
wiredMaterial.setZFunc(CMaterial::lessequal);
wiredMaterial.setColor(CRGBA(255, 255, 255, 250));
wiredMaterial.texEnvOpAlpha(0, CMaterial::Replace);
wiredMaterial.texEnvArg0Alpha(0, CMaterial::Diffuse, CMaterial::SrcAlpha);
wiredMaterial.setBlend(true);
wiredMaterial.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
texturedMaterial.initUnlit();
texturedMaterial.setDoubleSided(true);
texturedMaterial.setZFunc(CMaterial::lessequal);
initDone = true;
}
// just add a projected texture
R2::getEditor().getIslandCollision().loadEntryPoints();
R2::CScenarioEntryPoints &sep = R2::CScenarioEntryPoints::getInstance();
CVectorD playerPos = UserEntity->pos();
R2::CScenarioEntryPoints::CCompleteIsland *island = sep.getCompleteIslandFromCoords(CVector2f((float) playerPos.x, (float) playerPos.y));
static CSString currIsland;
if (island && island->Island != currIsland)
{
currIsland = island->Island;
CTextureFile *newTex = new CTextureFile(currIsland + "_sp.tga");
newTex->setWrapS(ITexture::Clamp);
newTex->setWrapT(ITexture::Clamp);
texturedMaterial.setTexture(0, newTex);
texturedMaterial.texEnvOpRGB(0, CMaterial::Replace);
texturedMaterial.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
texturedMaterial.setTexCoordGen(0, true);
texturedMaterial.setTexCoordGenMode(0, CMaterial::TexCoordGenObjectSpace);
CMatrix mat;
CVector scale((float) (island->XMax - island->XMin),
(float) (island->YMax - island->YMin), 0.f);
scale.x = 1.f / favoid0(scale.x);
scale.y = 1.f / favoid0(scale.y);
scale.z = 0.f;
mat.setScale(scale);
mat.setPos(CVector(- island->XMin * scale.x, - island->YMin * scale.y, 0.f));
//
CMatrix uvScaleMat;
//
uint texWidth = (uint) (island->XMax - island->XMin);
uint texHeight = (uint) (island->YMax - island->YMin);
float UScale = (float) texWidth / raiseToNextPowerOf2(texWidth);
float VScale = (float) texHeight / raiseToNextPowerOf2(texHeight);
//
uvScaleMat.setScale(CVector(UScale, - VScale, 0.f));
uvScaleMat.setPos(CVector(0.f, VScale, 0.f));
//
texturedMaterial.enableUserTexMat(0, true);
texturedMaterial.setUserTexMat(0, uvScaleMat * mat);
}
const CFrustum &frust = MainCam.getFrustum();
//
IDriver *driver = ((CDriverUser *) Driver)->getDriver();
driver->enableFog(true);
const CRGBA clearColor = CRGBA(0, 0, 127, 0);
driver->setupFog(frust.Far * 0.8f, frust.Far, clearColor);
CViewport vp;
vp.init(0.f, 0.f, 1.f, 1.f);
driver->setupViewport(vp);
CScissor scissor;
viewportToScissor(vp, scissor);
driver->setupScissor(scissor);
//
driver->setFrustum(frust.Left, frust.Right, frust.Bottom, frust.Top, frust.Near, frust.Far, frust.Perspective);
driver->setupViewMatrix(MainCam.getMatrix().inverted());
driver->setupModelMatrix(CMatrix::Identity);
//
//
const CVector localFrustCorners[8] =
{
CVector(frust.Left, frust.Near, frust.Top),
CVector(frust.Right, frust.Near, frust.Top),
CVector(frust.Right, frust.Near, frust.Bottom),
CVector(frust.Left, frust.Near, frust.Bottom),
CVector(frust.Left * frust.Far / frust.Near, frust.Far, frust.Top * frust.Far / frust.Near),
CVector(frust.Right * frust.Far / frust.Near, frust.Far, frust.Top * frust.Far / frust.Near),
CVector(frust.Right * frust.Far / frust.Near, frust.Far, frust.Bottom * frust.Far / frust.Near),
CVector(frust.Left * frust.Far / frust.Near, frust.Far, frust.Bottom * frust.Far / frust.Near)
};
// roughly compute covered zones
//
/*
sint frustZoneMinX = INT_MAX;
sint frustZoneMaxX = INT_MIN;
sint frustZoneMinY = INT_MAX;
sint frustZoneMaxY = INT_MIN;
for(uint k = 0; k < sizeofarray(localFrustCorners); ++k)
{
CVector corner = camMat * localFrustCorners[k];
sint zoneX = (sint) (corner.x / 160.f) - zoneMinX;
sint zoneY = (sint) floorf(corner.y / 160.f) - zoneMinY;
frustZoneMinX = std::min(frustZoneMinX, zoneX);
frustZoneMinY = std::min(frustZoneMinY, zoneY);
frustZoneMaxX = std::max(frustZoneMaxX, zoneX);
frustZoneMaxY = std::max(frustZoneMaxY, zoneY);
}
*/
const uint TRI_BATCH_SIZE = 10000; // batch size for rendering
static std::vector<TPackedZoneBaseSPtr> zones;
zones.clear();
pw->getZones(zones);
for(uint k = 0; k < zones.size(); ++k)
{
zones[k]->render(vb, *driver, texturedMaterial, wiredMaterial, MainCam.getMatrix(), TRI_BATCH_SIZE, localFrustCorners);
}
}
}
/*********************************************************\
displayOrientation()
\*********************************************************/
void displayOrientation()
{
float x = 0.9f*4.f/3.f;
float y = 0.1f;
float radius = 0.015f;
// Triangle
CMaterial mat;
mat.initUnlit();
mat.setSrcBlend(CMaterial::srcalpha);
mat.setDstBlend(CMaterial::invsrcalpha);
mat.setBlend(true);
CVertexBuffer vb;
vb.setVertexFormat (CVertexBuffer::PositionFlag);
vb.setNumVertices (7);
{
CVertexBufferReadWrite vba;
vb.lock(vba);
// tri
vba.setVertexCoord (0, CVector (-radius, 0, 0));
vba.setVertexCoord (1, CVector (radius, 0, 0));
vba.setVertexCoord (2, CVector (0, 0, 3*radius));
// quad
vba.setVertexCoord (3, CVector (-radius, 0, -radius));
vba.setVertexCoord (4, CVector (radius, 0, -radius));
vba.setVertexCoord (5, CVector (radius, 0, radius));
vba.setVertexCoord (6, CVector (-radius, 0, radius));
}
CNELU::Driver->activeVertexBuffer(vb);
CIndexBuffer pbTri;
pbTri.setNumIndexes (3);
{
CIndexBufferReadWrite iba;
pbTri.lock (iba);
iba.setTri (0, 0, 1, 2);
}
CIndexBuffer pbQuad;
pbQuad.setNumIndexes (6);
{
CIndexBufferReadWrite iba;
pbQuad.lock(iba);
iba.setTri (0, 3, 4, 5);
iba.setTri (3, 5, 6, 3);
}
CNELU::Driver->setFrustum (0.f, 4.f/3.f, 0.f, 1.f, -1.f, 1.f, false);
CMatrix mtx;
mtx.identity();
CNELU::Driver->setupViewMatrix (mtx);
mat.setColor(CRGBA(50,255,255,150));
// up
mtx.identity();
mtx.translate(CVector(x,0,y));
mtx.rotateY(MoveListener.getRotZ() );
mtx.translate(CVector(0,0,radius));
CNELU::Driver->setupModelMatrix (mtx);
CNELU::Driver->activeVertexBuffer(vb);
CNELU::Driver->activeIndexBuffer(pbTri);
CNELU::Driver->renderTriangles(mat, 0, pbTri.getNumIndexes()/3);
mat.setColor(CRGBA(50,50,255,150));
// down
mtx.identity();
mtx.translate(CVector(x,0,y));
mtx.rotateY(MoveListener.getRotZ() + (float)Pi);
mtx.translate(CVector(0,0,radius));
CNELU::Driver->setupModelMatrix (mtx);
CNELU::Driver->renderTriangles(mat, 0, pbTri.getNumIndexes()/3);
// left
mtx.identity();
mtx.translate(CVector(x,0,y));
mtx.rotateY(MoveListener.getRotZ() - (float)Pi/2);
mtx.translate(CVector(0,0,radius));
CNELU::Driver->setupModelMatrix (mtx);
CNELU::Driver->renderTriangles(mat, 0, pbTri.getNumIndexes()/3);
// right
mtx.identity();
mtx.translate(CVector(x,0,y));
mtx.rotateY(MoveListener.getRotZ() + (float)Pi/2);
mtx.translate(CVector(0,0,radius));
CNELU::Driver->setupModelMatrix (mtx);
CNELU::Driver->renderTriangles(mat, 0, pbTri.getNumIndexes()/3);
// center
mtx.identity();
mtx.translate(CVector(x,0,y));
mtx.rotateY(MoveListener.getRotZ());
CNELU::Driver->setupModelMatrix (mtx);
CNELU::Driver->activeIndexBuffer(pbQuad);
CNELU::Driver->renderTriangles(mat, 0, pbQuad.getNumIndexes()/3);
}