mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-11-30 07:35:59 +00:00
220 lines
8.7 KiB
C++
220 lines
8.7 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/>.
|
|
|
|
#ifndef NL_U_INSTANCE_H
|
|
#define NL_U_INSTANCE_H
|
|
|
|
#include "nel/misc/types_nl.h"
|
|
#include "u_transform.h"
|
|
#include "u_instance_material.h"
|
|
#include "u_shape.h"
|
|
#include "nel/misc/aabbox.h"
|
|
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
class UInstanceMaterial;
|
|
|
|
|
|
// ***************************************************************************
|
|
/**
|
|
* Game interface for manipulating Objects, animations etc...
|
|
* \author Lionel Berenguier
|
|
* \author Nevrax France
|
|
* \date 2001
|
|
*/
|
|
class UInstance : public UTransform
|
|
{
|
|
public:
|
|
|
|
|
|
/** Get the untransformed AABBox of the mesh. NULL (gtSize()==0) if no mesh.
|
|
*/
|
|
void getShapeAABBox(NLMISC::CAABBox &bbox) const;
|
|
|
|
/**
|
|
* Set the blend shape factor for this instance
|
|
* blendShapeName is the name of the blendshape we want to set
|
|
* factor the blendshape percentage from -100.0 to 100.0
|
|
* dynamic tells the optimizer if the blendshape have to change in real time
|
|
*/
|
|
void setBlendShapeFactor (const std::string &blendShapeName, float factor, bool dynamic);
|
|
|
|
/// \name Material access.
|
|
// @{
|
|
/// return number of materials this mesh instance use.
|
|
uint getNumMaterials() const;
|
|
/// return a local access on a material, to change its values. (NB: overwrite, if animated).
|
|
UInstanceMaterial getMaterial(uint materialId);
|
|
/** Select textures of material among several sets (if available)
|
|
* NB: if success and if getAsyncTextureMode()==true, then setAsyncTextureDirty(true) is called
|
|
*/
|
|
void selectTextureSet(uint id);
|
|
// @}
|
|
|
|
/** Change MRM Distance setup. Only for mesh which support MRM. NB MeshMultiLod apply it only on Lod0
|
|
* (if Lod0 is a MRM).
|
|
* NB: This apply to the shape directly!! ie All instances using same shape will be affected
|
|
* NB: no-op if distanceFinest<0, distanceMiddle<=distanceFinest or if distanceCoarsest<=distanceMiddle.
|
|
* \param distanceFinest The MRM has its max faces when dist<=distanceFinest.
|
|
* \param distanceMiddle The MRM has 50% of its faces at dist==distanceMiddle.
|
|
* \param distanceCoarsest The MRM has faces/Divisor (ie near 0) when dist>=distanceCoarsest.
|
|
*/
|
|
void changeMRMDistanceSetup(float distanceFinest, float distanceMiddle, float distanceCoarsest);
|
|
|
|
|
|
/** Change Max Display distance. After this distance the shape won't be displayed.
|
|
* setting <0 means -1 and so means DistMax = infinite (default in meshs but multilod meshes).
|
|
* NB: This apply to the shape directly!! ie All instances using same shape will be affected
|
|
*
|
|
* Note: If the instance is skinned/sticked to a skeleton, this setup is not taken into account. But you can
|
|
* call USkeleton::setShapeDistMax() to have same effect.
|
|
*
|
|
* Note (complex): All instances of the same shape which are freezeHRC()-ed and are linked to the
|
|
* QuadGridClipManager (ie not linked to a cluster) may not be updated correctly.
|
|
* In other words, you should setup this value only at beginning of program, just after creating your
|
|
* instance (more exactly before UScene::render()), and all instances of the same shape should be setuped
|
|
* with same value (or don't call setShapeDistMax() for subsequent instances).
|
|
* If you don't do this, QuadGridClipManager may clip such instances nearer than they should
|
|
*/
|
|
void setShapeDistMax(float distMax);
|
|
|
|
/// see setShapeDistMax()
|
|
float getShapeDistMax() const;
|
|
|
|
/// Test if there is a start/stop caps in the objects (some fxs such as remanence)
|
|
bool canStartStop();
|
|
// For instance that have a start/stop caps
|
|
void start();
|
|
// For instance that have a start/stop caps
|
|
void stop() ;
|
|
// For instance that have a start/stop caps
|
|
bool isStarted() const;
|
|
|
|
// Get the model distmax.
|
|
float getDistMax() const;
|
|
// Set the model distmax.
|
|
void setDistMax(float distMax);
|
|
// If the model has a coarse mesh, it set its dist. Set to -1 to keep default
|
|
void setCoarseMeshDist(float dist);
|
|
// If the model has a coarse mesh, it returns its distance if it has been set, or -1 if default is used (or if no coarse mesh present)
|
|
float getCoarseMeshDist() const;
|
|
|
|
|
|
/// \name Async Texture Loading
|
|
/** All those methods no-op or return 0/false if the instance is not a CMeshBaseInstance.
|
|
* isAsyncTextyreReady() return true if the instance is not a CMeshBaseInstance.
|
|
*/
|
|
// @{
|
|
/** if true, the instance is said in "AsyncTextureMode". Ie user must fill AsyncTextures field with name of the
|
|
* textures to load. At each startAsyncTextureLoading(), the system start to load async them.
|
|
* Then, isAsyncTextureReady() should be test each frame, to know if loading has completed.
|
|
* By default, AsyncTextureMode=false.
|
|
* When it swap from false to true, each texture file in Materials are replaced with
|
|
* "blank.tga", and true fileNames are copied into AsyncTextures.
|
|
* When it swap from true to false, the inverse is applied.
|
|
* NB: calling enableAsyncTextureMode(true) calls setAsyncTextureDirty(true)
|
|
*/
|
|
void enableAsyncTextureMode(bool enable);
|
|
bool getAsyncTextureMode() const;
|
|
/** Start to load all textures in AsyncTextures array (if needed)
|
|
* NB: old setup is kept in Material => instance is still rendered with "coherent" textures, until new textures
|
|
* are ready
|
|
* no op if not in async texture mode.
|
|
*/
|
|
void startAsyncTextureLoading();
|
|
/** return true if all the async textures of the instances are uploaded.
|
|
* if was not ready before, this swap the upload textures into the rendered ones so they are rendered
|
|
* return always true if not in async texture mode, or if startAsyncTextureLoading() has not been called
|
|
* since last enableAsyncTextureMode(true)
|
|
*/
|
|
bool isAsyncTextureReady();
|
|
|
|
/** For Lod of texture, and load balancing, set the approximate distance of the instance to the camera.
|
|
*/
|
|
void setAsyncTextureDistance(float dist);
|
|
/** \see setAsyncTextureDistance()
|
|
*/
|
|
float getAsyncTextureDistance() const;
|
|
|
|
/** User is free to flag this state, to know if startAsyncTextureLoading() should be called.
|
|
* Internal system don't use this flag.
|
|
* Default is false
|
|
*/
|
|
void setAsyncTextureDirty(bool flag);
|
|
/// see dirtAsyncTextureState()
|
|
bool isAsyncTextureDirty() const;
|
|
|
|
// @}
|
|
|
|
/** Trails specific. Set the slice time (period used to sample the trail pos)
|
|
* If the object is not a trail, this has no effect
|
|
*/
|
|
// @{
|
|
void setSliceTime(float duration);
|
|
float getSliceTime() const;
|
|
// @}
|
|
|
|
/** Test if driver support rendering of all material of that shape.
|
|
* \param forceBaseCaps When true, the driver is considered to have the most basic required caps (2 stages hardwares, no pixelShader), so that any fancy material will fail the test.
|
|
*/
|
|
bool supportMaterialRendering(UDriver &drv, bool forceBaseCaps);
|
|
|
|
/// get the shape. NULL if no instance bound
|
|
UShape getShape() const;
|
|
|
|
// get the shape name. empty if no instance bound
|
|
const std::string &getShapeName() const;
|
|
|
|
// dynamic cast from a transform. empty if cast fail
|
|
void cast(UTransform object);
|
|
|
|
/// \name access default position. Valid only for CMeshBaseInstance
|
|
/// NB: return false if the instance is not a CMeshBaseInstance (value not modified)
|
|
// @{
|
|
bool getDefaultPos (CVector &) const;
|
|
bool getDefaultRotQuat (CQuat &) const;
|
|
bool getDefaultScale (CVector &) const;
|
|
/** Set a scale relative to the default exported matrix
|
|
* NB: really useful for instance if you want to scale an instance relatively to the scale
|
|
* exported from the artist (if he had not set a "reset XForm")
|
|
* NB: no op if the object is not a CMeshBaseInstance
|
|
*/
|
|
void setRelativeScale (const CVector &rs);
|
|
// @}
|
|
|
|
/// Proxy interface
|
|
|
|
/// Constructors
|
|
UInstance() { _Object = NULL; };
|
|
UInstance(class CTransformShape *object) { _Object = (ITransformable*)object; };
|
|
/// Attach an object to this proxy
|
|
void attach(class CTransformShape *object) { _Object = (ITransformable*)object; }
|
|
/// Detach the object
|
|
void detach() { _Object = NULL; }
|
|
/// Return true if the proxy is empty() (not attached)
|
|
bool empty() const {return _Object==NULL;}
|
|
/// For advanced usage, get the internal object ptr
|
|
class CTransformShape *getObjectPtr() const {return (CTransformShape*)_Object;}
|
|
};
|
|
|
|
} // NL3D
|
|
|
|
#endif // NL_U_INSTANCE_H
|
|
|
|
/* End of u_instance.h */
|