khanat-opennel-code/code/nel/src/3d/transform_shape.cpp

360 lines
9.4 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/misc/hierarchical_timer.h"
#include "nel/misc/debug.h"
#include "nel/3d/driver.h"
#include "nel/3d/transform_shape.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/mesh_base_instance.h"
#include "nel/3d/clip_trav.h"
#include "nel/3d/render_trav.h"
#include "nel/3d/load_balancing_trav.h"
#include "nel/3d/quad_grid_clip_cluster.h"
#include "nel/3d/scene.h"
using namespace NLMISC;
namespace NL3D
{
// ***************************************************************************
void CTransformShape::registerBasic()
{
CScene::registerModel(TransformShapeId, TransformId, CTransformShape::creator);
}
// ***************************************************************************
CTransformShape::CTransformShape()
{
_NumTrianglesAfterLoadBalancing= 100;
_CurrentLightContribution= NULL;
_CurrentUseLocalAttenuation= false;
_DistMax = -1.f;
// By default all transformShape are LoadBalancable
CTransform::setIsLoadbalancable(true);
// The model is renderable
CTransform::setIsRenderable(true);
// I am a CTransformShape
CTransform::setIsTransformShape(true);
}
// ***************************************************************************
float CTransformShape::getNumTriangles (float distance)
{
// Call shape method
return Shape->getNumTriangles (distance);
}
// ***************************************************************************
void CTransformShape::getAABBox(NLMISC::CAABBox &bbox) const
{
if(Shape)
{
Shape->getAABBox(bbox);
}
else
{
bbox.setCenter(CVector::Null);
bbox.setHalfSize(CVector::Null);
}
}
// ***************************************************************************
void CTransformShape::setupCurrentLightContribution(CLightContribution *lightContrib, bool useLocalAtt)
{
_CurrentLightContribution= lightContrib;
_CurrentUseLocalAttenuation= useLocalAtt;
}
// ***************************************************************************
void CTransformShape::changeLightSetup(CRenderTrav *rdrTrav)
{
// setup the instance lighting.
rdrTrav->changeLightSetup(_CurrentLightContribution, _CurrentUseLocalAttenuation);
}
// ***************************************************************************
uint CTransformShape::getNumMaterial () const
{
return 0;
}
// ***************************************************************************
const CMaterial *CTransformShape::getMaterial (uint /* materialId */) const
{
return NULL;
}
// ***************************************************************************
CMaterial *CTransformShape::getMaterial (uint /* materialId */)
{
return NULL;
}
// ***************************************************************************
void CTransformShape::unlinkFromQuadCluster()
{
// if linked to a quadGridClipCluster, unlink it
_QuadClusterListNode.unlink();
}
// ***************************************************************************
bool CTransformShape::clip()
{
H_AUTO( NL3D_TrShape_Clip );
CClipTrav &clipTrav= getOwnerScene()->getClipTrav();
if(Shape)
{
// first test DistMax (faster).
float maxDist = getDistMax();
// if DistMax test enabled
if(maxDist!=-1)
{
// Calc the distance
float sqrDist = (clipTrav.CamPos - getWorldMatrix().getPos()).sqrnorm ();
maxDist*=maxDist;
// if dist > maxDist, skip
if (sqrDist > maxDist)
{
// Ok, not shown
return false;
}
}
// Else finer clip with pyramid, only if needed
if(clipTrav.ForceNoFrustumClip)
return true;
else
return Shape->clip(clipTrav.WorldPyramid, getWorldMatrix());
}
else
return false;
}
// ***************************************************************************
void CTransformShape::traverseRender()
{
H_AUTO( NL3D_TrShape_Render );
// Compute the current lighting setup for this instance
//===================
// if the transform is lightable (ie not a fully lightmaped model), setup lighting
if(isLightable())
{
// useLocalAttenuation for this shape ??
if(Shape)
_CurrentUseLocalAttenuation= Shape->useLightingLocalAttenuation ();
else
_CurrentUseLocalAttenuation= false;
// the std case is to take my model lightContribution
if(_AncestorSkeletonModel==NULL)
_CurrentLightContribution= &getLightContribution();
// but if skinned/sticked (directly or not) to a skeleton, take its.
else
_CurrentLightContribution= &((CTransformShape*)_AncestorSkeletonModel)->getLightContribution();
}
// else must disable the lightSetup
else
{
// setting NULL will disable all lights
_CurrentLightContribution= NULL;
_CurrentUseLocalAttenuation= false;
}
// render the shape.
//=================
if(Shape)
{
CRenderTrav &rdrTrav= getOwnerScene()->getRenderTrav();
bool currentPassOpaque= rdrTrav.isCurrentPassOpaque();
// shape must be rendered in a CMeshBlockManager ??
float polygonCount = 0.f;
IMeshGeom *meshGeom= NULL;
// true only if in pass opaque
if( currentPassOpaque )
meshGeom= Shape->supportMeshBlockRendering(this, polygonCount);
// if ok, add the meshgeom to the block manager.
if(meshGeom)
{
CMeshBaseInstance *inst= safe_cast<CMeshBaseInstance*>(this);
rdrTrav.MeshBlockManager.addInstance(meshGeom, inst, polygonCount);
}
// else render it.
else
{
// setup the lighting
changeLightSetup( &rdrTrav );
// render the shape.
IDriver *drv= rdrTrav.getDriver();
Shape->render( drv, this, currentPassOpaque );
}
}
}
// ***************************************************************************
void CTransformShape::profileRender()
{
// profile the shape.
if(Shape)
{
CRenderTrav &rdrTrav= getOwnerScene()->getRenderTrav();
bool currentPassOpaque= rdrTrav.isCurrentPassOpaque();
Shape->profileSceneRender( &rdrTrav, this, currentPassOpaque );
}
}
// ***************************************************************************
void CTransformShape::traverseLoadBalancing()
{
CLoadBalancingTrav &loadTrav= getOwnerScene()->getLoadBalancingTrav();
if(loadTrav.getLoadPass()==0)
traverseLoadBalancingPass0();
else
traverseLoadBalancingPass1();
}
// ***************************************************************************
void CTransformShape::traverseLoadBalancingPass0()
{
CLoadBalancingTrav &loadTrav= getOwnerScene()->getLoadBalancingTrav();
CSkeletonModel *skeleton= getSkeletonModel();
// World Model position
const CVector *modelPos;
// If this isntance is binded or skinned to a skeleton, take the world matrix of this one as
// center for LoadBalancing Resolution.
if(skeleton)
{
// Take the root bone of the skeleton as reference (bone 0)
// And so get our position.
modelPos= &skeleton->Bones[0].getWorldMatrix().getPos();
}
else
{
// get our position from
modelPos= &getWorldMatrix().getPos();
}
// Then compute distance from camera.
float modelDist= ( loadTrav.CamPos - *modelPos).norm();
// Get the number of triangles this model use now.
_FaceCount= getNumTriangles(modelDist);
_LoadBalancingGroup->addNbFacesPass0(_FaceCount);
}
// ***************************************************************************
void CTransformShape::traverseLoadBalancingPass1()
{
// Show more polygons for upscaled shapes to preserve visual quality
float factor = 1.0f;
if (getTransformMode() == RotEuler || getTransformMode() == RotQuat)
{
factor = std::max(1.0f, std::max(getScale().x, std::max(getScale().y, getScale().z)));
if (factor > 1)
{
_FaceCount = factor * std::max(_FaceCount, factor * 200.0f);
}
}
// Set the result into the instance.
_NumTrianglesAfterLoadBalancing= _LoadBalancingGroup->computeModelNbFace(_FaceCount);
}
// ***************************************************************************
void CTransformShape::getLightHotSpotInWorld(CVector &modelPos, float &modelRadius) const
{
/*
// get the untransformed bbox from the model.
CAABBox bbox;
getAABBox(bbox);
// get transformed center pos of bbox
modelPos= getWorldMatrix() * bbox.getCenter();
// If the model is a big lightable, must take radius from aabbox, else suppose 0 radius.
if(isBigLightable())
{
// get size of the bbox (bounding sphere)
modelRadius= bbox.getRadius();
}
else
{
// Assume 0 radius => faster computeLinearAttenuation()
modelRadius= 0;
}
*/
// This method works well for Big Trees.
// TODO: generalize, saving a LightHotSpot per shape.
// get pos of object. Ie the hotSpot is the pivot.
modelPos= getWorldMatrix().getPos();
// If the model is a big lightable, must take radius from aabbox, else suppose 0 radius.
if(isBigLightable())
{
// get the untransformed bbox from the model.
CAABBox bbox;
getAABBox(bbox);
// get size of the bbox (bounding sphere)
modelRadius= bbox.getRadius();
}
else
{
// Assume 0 radius => faster computeLinearAttenuation()
modelRadius= 0;
}
}
} // NL3D