mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-12-22 08:58:43 +00:00
724 lines
23 KiB
C++
724 lines
23 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/flare_model.h"
|
|
#include "nel/3d/flare_shape.h"
|
|
#include "nel/3d/driver.h"
|
|
#include "nel/3d/material.h"
|
|
#include "nel/3d/dru.h"
|
|
#include "nel/3d/scene.h"
|
|
#include "nel/3d/render_trav.h"
|
|
#include "nel/3d/occlusion_query.h"
|
|
#include "nel/3d/mesh.h"
|
|
#include "nel/3d/viewport.h"
|
|
#include "nel/misc/common.h"
|
|
|
|
|
|
|
|
namespace NL3D {
|
|
|
|
CMaterial CFlareModel::_OcclusionQueryMaterial;
|
|
CMaterial CFlareModel::_DrawQueryMaterial;
|
|
bool CFlareModel::_OcclusionQuerySettuped = false;
|
|
CVertexBuffer CFlareModel::_OcclusionQueryVB;
|
|
|
|
|
|
using NLMISC::CVector;
|
|
|
|
|
|
// ********************************************************************************************************************
|
|
CFlareModel::CFlareModel()
|
|
{
|
|
std::fill(_Intensity, _Intensity + MaxNumContext, 0.f);
|
|
setTransparency(true);
|
|
setOpacity(false);
|
|
// RenderFilter: We are a flare
|
|
_RenderFilterType= UScene::FilterFlare;
|
|
resetOcclusionQuerries();
|
|
std::fill(_LastRenderIntervalBegin, _LastRenderIntervalBegin + MaxNumContext, (uint64) -2);
|
|
std::fill(_LastRenderIntervalEnd, _LastRenderIntervalEnd + MaxNumContext, (uint64) -2);
|
|
std::fill(_NumFrameForOcclusionQuery, _NumFrameForOcclusionQuery + MaxNumContext, 1);
|
|
Next = NULL;
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::resetOcclusionQuerries()
|
|
{
|
|
for(uint k = 0; k < MaxNumContext; ++k)
|
|
{
|
|
for(uint l = 0; l < OcclusionTestFrameDelay; ++l)
|
|
{
|
|
_OcclusionQuery[k][l] = NULL;
|
|
_DrawQuery[k][l] = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
CFlareModel::~CFlareModel()
|
|
{
|
|
// if driver hasn't changed, delete all querries
|
|
if (_LastDrv)
|
|
{
|
|
for(uint k = 0; k < MaxNumContext; ++k)
|
|
{
|
|
for(uint l = 0; l < OcclusionTestFrameDelay; ++l)
|
|
{
|
|
if (_OcclusionQuery[k][l])
|
|
{
|
|
_LastDrv->deleteOcclusionQuery(_OcclusionQuery[k][l]);
|
|
}
|
|
if (_DrawQuery[k][l])
|
|
{
|
|
_LastDrv->deleteOcclusionQuery(_DrawQuery[k][l]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::registerBasic()
|
|
{
|
|
// register the model
|
|
CScene::registerModel(FlareModelClassId, TransformShapeId, CFlareModel::creator);
|
|
}
|
|
|
|
|
|
// write a vector in a vertex buffer
|
|
static inline void vbWrite(uint8 *&dest, const CVector &v)
|
|
{
|
|
((float *) dest)[0] = v.x;
|
|
((float *) dest)[1] = v.y;
|
|
((float *) dest)[2] = v.z;
|
|
dest += 3 * sizeof(float);
|
|
}
|
|
|
|
// write uvs in a vertex buffer
|
|
static inline void vbWrite(uint8 *&dest, float uCoord, float vCoord)
|
|
{
|
|
((float *) dest)[0] = uCoord;
|
|
((float *) dest)[1] = vCoord;
|
|
dest += 2 * sizeof(float);
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::traverseRender()
|
|
{
|
|
CRenderTrav &renderTrav = getOwnerScene()->getRenderTrav();
|
|
if (renderTrav.isCurrentPassOpaque()) return;
|
|
IDriver *drv = renderTrav.getDriver();
|
|
nlassert(drv);
|
|
// For now, don't render flare if occlusion query is not supported (direct read of z-buffer is far too slow)
|
|
if (!drv->supportOcclusionQuery()) return;
|
|
if (drv != _LastDrv)
|
|
{
|
|
// occlusion queries have been deleted by the driver
|
|
resetOcclusionQuerries();
|
|
_LastDrv = drv;
|
|
}
|
|
uint flareContext = _Scene ? _Scene->getFlareContext() : 0;
|
|
// transform the flare on screen
|
|
const CVector upt = getWorldMatrix().getPos(); // untransformed pos
|
|
const CVector pt = renderTrav.ViewMatrix * upt;
|
|
if (pt.y <= renderTrav.Near)
|
|
{
|
|
return; // flare behind us
|
|
}
|
|
nlassert(Shape);
|
|
CFlareShape *fs = NLMISC::safe_cast<CFlareShape *>((IShape *) Shape);
|
|
if (pt.y > fs->getMaxViewDist())
|
|
{
|
|
return; // flare too far away
|
|
}
|
|
float distIntensity;
|
|
if (fs->getFlareAtInfiniteDist())
|
|
{
|
|
distIntensity = 1.f;
|
|
}
|
|
else
|
|
{
|
|
// compute a color ratio for attenuation with distance
|
|
const float distRatio = pt.y / fs->getMaxViewDist();
|
|
distIntensity = distRatio > fs->getMaxViewDistRatio() ? 1.f - (distRatio - fs->getMaxViewDistRatio()) / (1.f - fs->getMaxViewDistRatio()) : 1.f;
|
|
}
|
|
//
|
|
uint32 width, height;
|
|
drv->getWindowSize(width, height);
|
|
// Compute position on screen
|
|
const float middleX = .5f * (renderTrav.Left + renderTrav.Right);
|
|
const float middleZ = .5f * (renderTrav.Bottom + renderTrav.Top);
|
|
const sint xPos = (width>>1) + (sint) (width * (((renderTrav.Near * pt.x) / pt.y) - middleX) / (renderTrav.Right - renderTrav.Left));
|
|
const sint yPos = (height>>1) - (sint) (height * (((renderTrav.Near * pt.z) / pt.y) - middleZ) / (renderTrav.Top - renderTrav.Bottom));
|
|
// See if the flare was inside the frustum during the last frame
|
|
// We can't use the scene frame counter because a flare can be rendered in several viewport during the same frame
|
|
// The swapBuffer counter is called only once per frame
|
|
uint64 currFrame = drv->getSwapBufferCounter();
|
|
//
|
|
bool visibilityRetrieved = false;
|
|
float visibilityRatio = 0.f;
|
|
// if driver support occlusion query mechanism, use it
|
|
CMesh *occlusionTestMesh = NULL;
|
|
if (_Scene->getShapeBank())
|
|
{
|
|
occlusionTestMesh = fs->getOcclusionTestMesh(*_Scene->getShapeBank());
|
|
}
|
|
if (drv->supportOcclusionQuery())
|
|
{
|
|
bool issueNewQuery = true;
|
|
IOcclusionQuery *lastOQ = _OcclusionQuery[flareContext][OcclusionTestFrameDelay - 1];
|
|
IOcclusionQuery *lastDQ = _DrawQuery[flareContext][OcclusionTestFrameDelay - 1];
|
|
if (_LastRenderIntervalEnd[flareContext] + 1 == currFrame)
|
|
{
|
|
if (_LastRenderIntervalEnd[flareContext] - _LastRenderIntervalBegin[flareContext] >= OcclusionTestFrameDelay - 1)
|
|
{
|
|
// occlusion test are possibles if at least OcclusionTestFrameDelay frames have ellapsed
|
|
if (lastOQ)
|
|
{
|
|
switch(lastOQ->getOcclusionType())
|
|
{
|
|
case IOcclusionQuery::NotAvailable:
|
|
issueNewQuery = false;
|
|
++ _NumFrameForOcclusionQuery[flareContext];
|
|
break;
|
|
case IOcclusionQuery::Occluded:
|
|
visibilityRetrieved = true;
|
|
visibilityRatio = 0.f;
|
|
break;
|
|
case IOcclusionQuery::NotOccluded:
|
|
if (occlusionTestMesh)
|
|
{
|
|
if (lastDQ)
|
|
{
|
|
if (lastDQ->getOcclusionType() != IOcclusionQuery::NotAvailable)
|
|
{
|
|
visibilityRetrieved = true;
|
|
// eval the percentage of samples that are visible
|
|
//nlinfo("%d / %d", lastOQ->getVisibleCount(), lastDQ->getVisibleCount());
|
|
visibilityRatio = (float) lastOQ->getVisibleCount() / (float) lastDQ->getVisibleCount();
|
|
NLMISC::clamp(visibilityRatio, 0.f, 1.f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
visibilityRetrieved = true;
|
|
visibilityRatio = 1.f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// visibility test is done on a single point
|
|
visibilityRetrieved = true;
|
|
visibilityRatio = 1.f;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (issueNewQuery)
|
|
{
|
|
// shift the queries list
|
|
for(uint k = OcclusionTestFrameDelay - 1; k > 0; --k)
|
|
{
|
|
_OcclusionQuery[flareContext][k] = _OcclusionQuery[flareContext][k - 1];
|
|
_DrawQuery[flareContext][k] = _DrawQuery[flareContext][k - 1];
|
|
}
|
|
_OcclusionQuery[flareContext][0] = lastOQ;
|
|
_DrawQuery[flareContext][0] = lastDQ;
|
|
if (occlusionTestMesh)
|
|
{
|
|
occlusionTest(*occlusionTestMesh, *drv);
|
|
}
|
|
else
|
|
{
|
|
// Insert in list of waiting flare. Don't do it now to avoid repeated setup of test material (a material that don't write to color/zbuffer,
|
|
// and that is used for the sole purpose of the occlusion query)
|
|
_Scene->insertInOcclusionQueryList(this);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_NumFrameForOcclusionQuery[flareContext] = 1;
|
|
visibilityRetrieved = true;
|
|
// The device doesn't support asynchronous query -> must read the z-buffer directly in a slow fashion
|
|
CViewport vp;
|
|
drv->getViewport(vp);
|
|
// Read z-buffer value at the pos we are
|
|
static std::vector<float> v(1);
|
|
NLMISC::CRect rect((sint32) (vp.getX() * width + vp.getWidth() * xPos),
|
|
(sint32) (vp.getY() * height + vp.getHeight() * (height - yPos)), 1, 1);
|
|
drv->getZBufferPart(v, rect);
|
|
// Project in screen space
|
|
float z = (float) (1.0 - (1.0 / pt.y - 1.0 / renderTrav.Far) / (1.0 /renderTrav.Near - 1.0 / renderTrav.Far));
|
|
//
|
|
float depthRangeNear, depthRangeFar;
|
|
drv->getDepthRange(depthRangeNear, depthRangeFar);
|
|
z = (depthRangeFar - depthRangeNear) * z + depthRangeNear;
|
|
if (!v.size() || z > v[0]) // test against z-buffer
|
|
{
|
|
visibilityRatio = 0.f;
|
|
}
|
|
else
|
|
{
|
|
visibilityRatio = 1.f;
|
|
}
|
|
}
|
|
// Update render interval
|
|
// nlwarning("frame = %d, last frame = %d", (int) currFrame, (int) _LastRenderIntervalEnd[flareContext]);
|
|
if (_LastRenderIntervalEnd[flareContext] + 1 != currFrame)
|
|
{
|
|
//nlwarning("*");
|
|
_Intensity[flareContext] = 0.f;
|
|
_LastRenderIntervalBegin[flareContext] = currFrame;
|
|
}
|
|
_LastRenderIntervalEnd[flareContext] = currFrame;
|
|
// Update intensity depending on visibility
|
|
if (visibilityRetrieved)
|
|
{
|
|
nlassert(visibilityRatio >= 0.f);
|
|
nlassert(visibilityRatio <= 1.f);
|
|
_NumFrameForOcclusionQuery[flareContext] = 1; // reset number of frame needed to do the occlusion query
|
|
if (visibilityRatio < _Intensity[flareContext])
|
|
{
|
|
float p = fs->getPersistence();
|
|
if (p == 0.f)
|
|
{
|
|
_Intensity[flareContext] = visibilityRatio; // instant update
|
|
}
|
|
else
|
|
{
|
|
_Intensity[flareContext] -= 1.f / p * (float)_Scene->getEllapsedTime() * (float) _NumFrameForOcclusionQuery[flareContext];
|
|
if (_Intensity[flareContext] < visibilityRatio)
|
|
{
|
|
_Intensity[flareContext] = visibilityRatio;
|
|
}
|
|
}
|
|
//nlwarning("intensity update < of %x : %f", (int) this, _Intensity[flareContext]);
|
|
}
|
|
else if (visibilityRatio > _Intensity[flareContext])
|
|
{
|
|
float p = fs->getPersistence();
|
|
if (p == 0.f)
|
|
{
|
|
_Intensity[flareContext] = visibilityRatio; // instant update
|
|
}
|
|
else
|
|
{
|
|
//nlwarning("num frame = %d, currFrame = %d, ", (int) _NumFrameForOcclusionQuery[flareContext], (int) currFrame);
|
|
_Intensity[flareContext] += 1.f / p * (float)_Scene->getEllapsedTime() * (float) _NumFrameForOcclusionQuery[flareContext];
|
|
if (_Intensity[flareContext] > visibilityRatio)
|
|
{
|
|
_Intensity[flareContext] = visibilityRatio;
|
|
}
|
|
}
|
|
//nlwarning("intensity update > of %x : %f", (int) this, _Intensity[flareContext]);
|
|
}
|
|
}
|
|
if (_Intensity[flareContext] == 0.f) return;
|
|
//
|
|
static CMaterial material;
|
|
static CVertexBuffer vb;
|
|
static bool setupDone = false;
|
|
if (!setupDone)
|
|
{
|
|
material.setBlend(true);
|
|
material.setBlendFunc(CMaterial::one, CMaterial::one);
|
|
material.setZWrite(false);
|
|
material.setZFunc(CMaterial::always);
|
|
material.setLighting(false);
|
|
material.setDoubleSided(true);
|
|
|
|
// setup vertex buffer
|
|
vb.setVertexFormat(CVertexBuffer::PositionFlag | CVertexBuffer::TexCoord0Flag);
|
|
vb.setPreferredMemory(CVertexBuffer::RAMVolatile, false);
|
|
vb.setNumVertices(4);
|
|
vb.setName("CFlareModel");
|
|
{
|
|
CVertexBufferReadWrite vba;
|
|
vb.lock (vba);
|
|
|
|
vba.setTexCoord(0, 0, NLMISC::CUV(1, 0));
|
|
vba.setTexCoord(1, 0, NLMISC::CUV(1, 1));
|
|
vba.setTexCoord(2, 0, NLMISC::CUV(0, 1));
|
|
vba.setTexCoord(3, 0, NLMISC::CUV(0, 0));
|
|
}
|
|
setupDone = true;
|
|
}
|
|
// setup driver
|
|
drv->activeVertexProgram(NULL);
|
|
drv->activePixelProgram(NULL);
|
|
drv->activeGeometryProgram(NULL);
|
|
drv->setupModelMatrix(fs->getLookAtMode() ? CMatrix::Identity : getWorldMatrix());
|
|
// we don't change the fustrum to draw 2d shapes : it is costly, and we need to restore it after the drawing has been done
|
|
// we setup Z to be (near + far) / 2, and setup x and y to get the screen coordinates we want
|
|
const float zPos = 0.5f * (renderTrav.Near + renderTrav.Far);
|
|
const float zPosDivNear = zPos / renderTrav.Near;
|
|
// compute the coeff so that x = ax * px + bx; y = ax * py + by
|
|
const float aX = ( (renderTrav.Right - renderTrav.Left) / (float) width) * zPosDivNear;
|
|
const float bX = zPosDivNear * (middleX - 0.5f * (renderTrav.Right - renderTrav.Left));
|
|
//
|
|
const float aY = - ( (renderTrav.Top - renderTrav.Bottom) / (float) height) * zPosDivNear;
|
|
const float bY = zPosDivNear * (middleZ + 0.5f * (renderTrav.Top - renderTrav.Bottom));
|
|
const CVector I = renderTrav.CamMatrix.getI();
|
|
const CVector J = renderTrav.CamMatrix.getJ();
|
|
const CVector K = renderTrav.CamMatrix.getK();
|
|
//
|
|
CRGBA col;
|
|
CRGBA flareColor = fs->getColor();
|
|
const float norm = sqrtf((float) (((xPos - (width>>1)) * (xPos - (width>>1)) + (yPos - (height>>1))*(yPos - (height>>1)))))
|
|
/ (float) (width>>1);
|
|
// check for dazzle and draw it
|
|
/*if (fs->hasDazzle())
|
|
{
|
|
if (norm < fs->getDazzleAttenuationRange())
|
|
{
|
|
float dazzleIntensity = 1.f - norm / fs->getDazzleAttenuationRange();
|
|
CRGBA dazzleColor = fs->getDazzleColor();
|
|
col.modulateFromui(dazzleColor, (uint) (255.f * _Intensity * dazzleIntensity));
|
|
material.setColor(col);
|
|
material.setTexture(0, NULL);
|
|
|
|
const CVector dazzleCenter = renderTrav.CamPos + zPos * J;
|
|
const CVector dI = (width>>1) * aX * I;
|
|
const CVector dK = (height>>1) * bX * K;
|
|
|
|
vb.setVertexCoord(0, dazzleCenter + dI + dK);
|
|
vb.setVertexCoord(1, dazzleCenter + dI - dK);
|
|
vb.setVertexCoord(2, dazzleCenter - dI - dK);
|
|
vb.setVertexCoord(3, dazzleCenter - dI + dK);
|
|
|
|
drv->renderRawQuads(material, 0, 1);
|
|
}
|
|
} */
|
|
if (!fs->getAttenuable() )
|
|
{
|
|
col.modulateFromui(flareColor, (uint) (255.f * distIntensity * _Intensity[flareContext]));
|
|
}
|
|
else
|
|
{
|
|
if (norm > fs->getAttenuationRange() || fs->getAttenuationRange() == 0.f)
|
|
{
|
|
return; // nothing to draw;
|
|
}
|
|
col.modulateFromui(flareColor, (uint) (255.f * distIntensity * _Intensity[flareContext] * (1.f - norm / fs->getAttenuationRange() )));
|
|
}
|
|
col.modulateFromColor(col, getMeanColor());
|
|
if (col == CRGBA::Black) return; // not visible
|
|
material.setColor(col);
|
|
CVector scrPos; // vector that will map to the center of the flare on screen
|
|
// process each flare
|
|
// delta for each new Pos
|
|
const float dX = fs->getFlareSpacing() * ((sint) (width >> 1) - xPos);
|
|
const float dY = fs->getFlareSpacing() * ((sint) (height >> 1) - yPos);
|
|
ITexture *tex;
|
|
// special case for first flare
|
|
tex = fs->getTexture(0);
|
|
if (tex)
|
|
{
|
|
{
|
|
CVertexBufferReadWrite vba;
|
|
vb.lock (vba);
|
|
float size;
|
|
if (fs->getScaleWhenDisappear())
|
|
{
|
|
size = _Intensity[flareContext] * fs->getSize(0) + (1.f - _Intensity[flareContext]) * fs->getSizeDisappear();
|
|
}
|
|
else
|
|
{
|
|
size = fs->getSize(0);
|
|
}
|
|
CVector rI, rK;
|
|
if (fs->getFirstFlareKeepSize())
|
|
{
|
|
size *= renderTrav.Near * (getWorldMatrix().getPos() - renderTrav.CamMatrix.getPos()) * J;
|
|
}
|
|
if (fs->getAngleDisappear() == 0.f)
|
|
{
|
|
if (fs->getLookAtMode())
|
|
{
|
|
rI = I;
|
|
rK = K;
|
|
}
|
|
else
|
|
{
|
|
rI = NLMISC::CVector::I;
|
|
rK = NLMISC::CVector::K;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
float angle = (1.f - _Intensity[flareContext]) * fs->getAngleDisappear() * (float) (NLMISC::Pi / 180);
|
|
float cosTheta = cosf(angle);
|
|
float sinTheta = sinf(angle);
|
|
if (fs->getLookAtMode())
|
|
{
|
|
rI = cosTheta * I + sinTheta * K;
|
|
rK = -sinTheta * I + cosTheta * K;
|
|
}
|
|
else
|
|
{
|
|
rI.set(cosTheta, 0.f, sinTheta);
|
|
rK.set(-sinTheta, 0.f, cosTheta);
|
|
}
|
|
}
|
|
uint8 *vbPtr = (uint8 *) vba.getVertexCoordPointer();
|
|
CHECK_VBA_RANGE(vba, vbPtr, vb.getVertexSize());
|
|
if (fs->getLookAtMode())
|
|
{
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, upt + size * (rI + rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 1.f, 0.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, upt + size * (rI - rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 1.f, 1.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, upt + size * (-rI - rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 0.f, 1.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, upt + size * (-rI + rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 0.f, 0.f); // uvs
|
|
}
|
|
else
|
|
{
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, size * (rI + rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 1.f, 0.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, size * (rI - rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 1.f, 1.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, size * (-rI - rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 0.f, 1.f); // uvs
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, size * (-rI + rK));
|
|
CHECK_VBA(vba, vbPtr); vbWrite(vbPtr, 0.f, 0.f); // uvs
|
|
}
|
|
}
|
|
material.setTexture(0, tex);
|
|
drv->activeVertexBuffer(vb);
|
|
drv->renderRawQuads(material, 0, 1);
|
|
}
|
|
if (fs->_LookAtMode)
|
|
{
|
|
drv->setupModelMatrix(CMatrix::Identity); // look at mode is applied only to first flare
|
|
}
|
|
for (uint k = 1; k < MaxFlareNum; ++k)
|
|
{
|
|
tex = fs->getTexture(k);
|
|
if (tex)
|
|
{
|
|
// compute vector that map to the center of the flare
|
|
scrPos = (aX * (xPos + dX * fs->getRelativePos(k)) + bX) * I
|
|
+ zPos * J + (aY * (yPos + dY * fs->getRelativePos(k)) + bY) * K + renderTrav.CamMatrix.getPos();
|
|
|
|
{
|
|
CVertexBufferReadWrite vba;
|
|
vb.lock (vba);
|
|
uint8 *vbPtr = (uint8 *) vba.getVertexCoordPointer();
|
|
float size = fs->getSize(k) * zPos * renderTrav.Near;
|
|
vbWrite(vbPtr, scrPos + size * (I + K));
|
|
vbWrite(vbPtr, 1.f, 0.f); // uvs
|
|
vbWrite(vbPtr, scrPos + size * (I - K));
|
|
vbWrite(vbPtr, 1.f, 1.f); // uvs
|
|
vbWrite(vbPtr, scrPos + size * (-I - K));
|
|
vbWrite(vbPtr, 0.f, 1.f); // uvs
|
|
vbWrite(vbPtr, scrPos + size * (-I + K));
|
|
vbWrite(vbPtr, 0.f, 0.f); // uvs
|
|
}
|
|
material.setTexture(0, tex);
|
|
drv->activeVertexBuffer(vb);
|
|
drv->renderRawQuads(material, 0, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::initStatics()
|
|
{
|
|
if (!_OcclusionQuerySettuped)
|
|
{
|
|
// setup materials
|
|
_OcclusionQueryMaterial.initUnlit();
|
|
_OcclusionQueryMaterial.setZWrite(false);
|
|
_DrawQueryMaterial.initUnlit();
|
|
_DrawQueryMaterial.setZWrite(false);
|
|
_DrawQueryMaterial.setZFunc(CMaterial::always);
|
|
// setup vbs
|
|
_OcclusionQueryVB.setVertexFormat(CVertexBuffer::PositionFlag);
|
|
_OcclusionQueryVB.setName("CFlareModel::_OcclusionQueryVB");
|
|
_OcclusionQueryVB.setPreferredMemory(CVertexBuffer::RAMVolatile, false); // use ram to avoid stall, and don't want to setup a VB per flare!
|
|
_OcclusionQueryVB.setNumVertices(1);
|
|
_OcclusionQuerySettuped = true;
|
|
}
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::updateOcclusionQueryBegin(IDriver *drv)
|
|
{
|
|
nlassert(drv);
|
|
drv->activeVertexProgram(NULL);
|
|
drv->activePixelProgram(NULL);
|
|
drv->activeGeometryProgram(NULL);
|
|
drv->setupModelMatrix(CMatrix::Identity);
|
|
initStatics();
|
|
drv->setColorMask(false, false, false, false); // don't write any pixel during the test
|
|
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::updateOcclusionQueryEnd(IDriver *drv)
|
|
{
|
|
drv->setColorMask(true, true, true, true);
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::updateOcclusionQuery(IDriver *drv)
|
|
{
|
|
nlassert(drv);
|
|
nlassert(drv == _LastDrv); // driver shouldn't change during CScene::render
|
|
// allocate a new occlusion if nit already done
|
|
nlassert(_Scene);
|
|
IOcclusionQuery *oq = _OcclusionQuery[_Scene->getFlareContext()][0];
|
|
if (!oq)
|
|
{
|
|
nlassert(drv->supportOcclusionQuery());
|
|
oq = drv->createOcclusionQuery();
|
|
if (!oq) return;
|
|
_OcclusionQuery[_Scene->getFlareContext()][0] = oq;
|
|
}
|
|
{
|
|
CVertexBufferReadWrite vbrw;
|
|
_OcclusionQueryVB.lock(vbrw);
|
|
*vbrw.getVertexCoordPointer(0) = getWorldMatrix().getPos();
|
|
}
|
|
drv->activeVertexBuffer(_OcclusionQueryVB);
|
|
oq->begin();
|
|
// draw a single point
|
|
drv->renderRawPoints(_OcclusionQueryMaterial, 0, 1);
|
|
oq->end();
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::renderOcclusionMeshPrimitives(CMesh &mesh, IDriver &drv)
|
|
{
|
|
uint numMatrixBlock = mesh.getNbMatrixBlock();
|
|
for(uint k = 0; k < numMatrixBlock; ++k)
|
|
{
|
|
uint numRdrPass = mesh.getNbRdrPass(k);
|
|
for(uint l = 0; l < numRdrPass; ++l)
|
|
{
|
|
CIndexBuffer &ib = const_cast<CIndexBuffer &>(mesh.getRdrPassPrimitiveBlock(k, l));
|
|
drv.activeIndexBuffer(ib);
|
|
drv.renderSimpleTriangles(0, ib.getNumIndexes() / 3);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::setupOcclusionMeshMatrix(IDriver &drv, CScene &scene) const
|
|
{
|
|
nlassert(Shape);
|
|
CFlareShape *fs = NLMISC::safe_cast<CFlareShape *>((IShape *) Shape);
|
|
if (fs->getOcclusionTestMeshInheritScaleRot())
|
|
{
|
|
drv.setupModelMatrix(getWorldMatrix());
|
|
}
|
|
else
|
|
{
|
|
nlassert(scene.getCam());
|
|
CMatrix m = scene.getCam()->getWorldMatrix();
|
|
m.setPos(getWorldMatrix().getPos());
|
|
drv.setupModelMatrix(m);
|
|
}
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::occlusionTest(CMesh &mesh, IDriver &drv)
|
|
{
|
|
nlassert(_Scene);
|
|
initStatics();
|
|
IOcclusionQuery *oq = _OcclusionQuery[_Scene->getFlareContext()][0];
|
|
if (!oq)
|
|
{
|
|
nlassert(drv.supportOcclusionQuery());
|
|
oq = drv.createOcclusionQuery();
|
|
if (!oq) return;
|
|
_OcclusionQuery[_Scene->getFlareContext()][0] = oq;
|
|
}
|
|
IOcclusionQuery *dq = _DrawQuery[_Scene->getFlareContext()][0];
|
|
if (!dq)
|
|
{
|
|
nlassert(drv.supportOcclusionQuery());
|
|
dq = drv.createOcclusionQuery();
|
|
if (!dq) return;
|
|
_DrawQuery[_Scene->getFlareContext()][0] = dq;
|
|
}
|
|
drv.setColorMask(false, false, false, false); // don't write any pixel during the test
|
|
drv.activeVertexProgram(NULL);
|
|
drv.activePixelProgram(NULL);
|
|
drv.activeGeometryProgram(NULL);
|
|
setupOcclusionMeshMatrix(drv, *_Scene);
|
|
drv.activeVertexBuffer(const_cast<CVertexBuffer &>(mesh.getVertexBuffer()));
|
|
// query drawn count
|
|
drv.setupMaterial(_OcclusionQueryMaterial);
|
|
oq->begin();
|
|
renderOcclusionMeshPrimitives(mesh, drv);
|
|
oq->end();
|
|
// query total count
|
|
drv.setupMaterial(_DrawQueryMaterial);
|
|
dq->begin();
|
|
renderOcclusionMeshPrimitives(mesh, drv);
|
|
dq->end();
|
|
drv.setColorMask(true, true, true, true); // restore pixel writes
|
|
}
|
|
|
|
// ********************************************************************************************************************
|
|
void CFlareModel::renderOcclusionTestMesh(IDriver &drv)
|
|
{
|
|
nlassert(_Scene);
|
|
if (!_Scene->getShapeBank()) return;
|
|
nlassert(Shape);
|
|
CFlareShape *fs = NLMISC::safe_cast<CFlareShape *>((IShape *) Shape);
|
|
CMesh *occlusionTestMesh = fs->getOcclusionTestMesh(*_Scene->getShapeBank());
|
|
if (!occlusionTestMesh) return;
|
|
setupOcclusionMeshMatrix(drv, *_Scene);
|
|
drv.activeVertexBuffer(const_cast<CVertexBuffer &>(occlusionTestMesh->getVertexBuffer()));
|
|
renderOcclusionMeshPrimitives(*occlusionTestMesh, drv);
|
|
}
|
|
|
|
|
|
|
|
|
|
} // NL3D
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|