#include <StdMesh.h>

Collaboration diagram for StdMeshInstance:

Classes
class	AttachedMesh

class	SerializableValueProvider

Public Types
enum	AttachMeshFlags { AM_None = 0 , AM_DrawBefore = 1 << 0 , AM_MatchSkeleton = 1 << 1 }

typedef StdMeshInstanceAnimationNode	AnimationNode

typedef StdSubMeshInstance::FaceOrdering	FaceOrdering

typedef StdMeshInstanceValueProvider	ValueProvider

typedef std::vector< AttachedMesh * >	AttachedMeshList

typedef AttachedMeshList::const_iterator	AttachedMeshIter

Public Member Functions
	StdMeshInstance (const StdMesh &mesh, float completion=1.0f)

	~StdMeshInstance ()

void	SetFaceOrdering (FaceOrdering ordering)

void	SetFaceOrderingForClrModulation (uint32_t clrmod)

const std::vector< StdMeshVertex > &	GetSharedVertices () const

size_t	GetNumSharedVertices () const

void	SetCompletion (float completion)

float	GetCompletion () const

AnimationNode *	PlayAnimation (const StdStrBuf &animation_name, int slot, AnimationNode sibling, ValueProvider position, ValueProvider *weight, bool stop_previous_animation)

AnimationNode *	PlayAnimation (const StdMeshAnimation &animation, int slot, AnimationNode sibling, ValueProvider position, ValueProvider *weight, bool stop_previous_animation)

AnimationNode *	PlayAnimation (const StdMeshBone bone, const StdMeshTransformation &trans, int slot, AnimationNode sibling, ValueProvider *weight, bool stop_previous_animation)

void	StopAnimation (AnimationNode *node)

AnimationNode *	GetAnimationNodeByNumber (unsigned int number)

AnimationNode *	GetRootAnimationForSlot (int slot)

void	SetAnimationPosition (AnimationNode node, ValueProvider position)

void	SetAnimationBoneTransform (AnimationNode *node, const StdMeshTransformation &trans)

void	SetAnimationWeight (AnimationNode node, ValueProvider weight)

void	ExecuteAnimation (float dt)

AttachedMesh *	AttachMesh (const StdMesh &mesh, AttachedMesh::Denumerator *denumerator, const StdStrBuf &parent_bone, const StdStrBuf &child_bone, const StdMeshMatrix &transformation=StdMeshMatrix::Identity(), uint32_t flags=AM_None, unsigned int attach_number=0)

AttachedMesh *	AttachMesh (StdMeshInstance &instance, AttachedMesh::Denumerator *denumerator, const StdStrBuf &parent_bone, const StdStrBuf &child_bone, const StdMeshMatrix &transformation=StdMeshMatrix::Identity(), uint32_t flags=AM_None, bool own_child=false, unsigned int attach_number=0)

bool	DetachMesh (unsigned int number)

AttachedMesh *	GetAttachedMeshByNumber (unsigned int number) const

AttachedMeshIter	AttachedMeshesBegin () const

AttachedMeshIter	AttachedMeshesEnd () const

AttachedMesh *	GetAttachParent () const

size_t	GetNumSubMeshes () const

StdSubMeshInstance &	GetSubMesh (size_t i)

const StdSubMeshInstance &	GetSubMesh (size_t i) const

const StdSubMeshInstance &	GetSubMeshOrdered (size_t i) const

void	SetMaterial (size_t i, const StdMeshMaterial &material)

const StdMeshMatrix &	GetBoneTransform (size_t i) const

size_t	GetBoneCount () const

bool	UpdateBoneTransforms ()

void	ReorderFaces (StdMeshMatrix *global_trans)

void	CompileFunc (StdCompiler *pComp, AttachedMesh::DenumeratorFactoryFunc Factory)

void	DenumeratePointers ()

void	ClearPointers (class C4Object *pObj)

const StdMesh &	GetMesh () const

GLuint	GetIBO () const

unsigned int	GetVAOID () const

Protected Types
typedef std::vector< AnimationNode * >	AnimationNodeList

Protected Member Functions
void	UpdateIBO ()

AttachedMesh *	AttachMeshImpl (StdMeshInstance &instance, AttachedMesh::Denumerator *denumerator, const StdStrBuf &parent_bone, const StdStrBuf &child_bone, const StdMeshMatrix &transformation, uint32_t flags, bool own_child, unsigned int new_attach_number)

AnimationNodeList::iterator	GetStackIterForSlot (int slot, bool create)

void	InsertAnimationNode (AnimationNode node, int slot, AnimationNode sibling, ValueProvider *weight, bool stop_previous_animation)

bool	ExecuteAnimationNode (AnimationNode *node)

void	ApplyBoneTransformToVertices (const std::vector< StdSubMesh::Vertex > &mesh_vertices, std::vector< StdMeshVertex > &instance_vertices)

void	SetBoneTransformsDirty (bool value)

Static Protected Member Functions
template<typename IteratorType , typename FuncObj >
static bool	ScanAttachTree (IteratorType begin, IteratorType end, const FuncObj &obj)

Protected Attributes
const StdMesh *	Mesh

float	Completion

AnimationNodeList	AnimationNodes

AnimationNodeList	AnimationStack

std::vector< StdMeshMatrix >	BoneTransforms

std::vector< StdSubMeshInstance * >	SubMeshInstances

std::vector< StdSubMeshInstance * >	SubMeshInstancesOrdered

std::vector< AttachedMesh * >	AttachChildren

AttachedMesh *	AttachParent

bool	BoneTransformsDirty

GLuint	ibo

unsigned int	vaoid

Friends
class	StdMeshMaterialUpdate

class	StdMeshAnimationUpdate

class	StdMeshUpdate

Detailed Description

Definition at line 393 of file StdMesh.h.

Member Typedef Documentation

◆ AnimationNode

typedef StdMeshInstanceAnimationNode StdMeshInstance::AnimationNode

Definition at line 399 of file StdMesh.h.

◆ AnimationNodeList

typedef std::vector<AnimationNode*> StdMeshInstance::AnimationNodeList

protected

Definition at line 639 of file StdMesh.h.

◆ AttachedMeshIter

typedef AttachedMeshList::const_iterator StdMeshInstance::AttachedMeshIter

Definition at line 544 of file StdMesh.h.

◆ AttachedMeshList

typedef std::vector<AttachedMesh*> StdMeshInstance::AttachedMeshList

Definition at line 543 of file StdMesh.h.

◆ FaceOrdering

typedef StdSubMeshInstance::FaceOrdering StdMeshInstance::FaceOrdering

Definition at line 403 of file StdMesh.h.

◆ ValueProvider

typedef StdMeshInstanceValueProvider StdMeshInstance::ValueProvider

Definition at line 411 of file StdMesh.h.

Member Enumeration Documentation

◆ AttachMeshFlags

enum StdMeshInstance::AttachMeshFlags

Enumerator
AM_None
AM_DrawBefore
AM_MatchSkeleton

Definition at line 405 of file StdMesh.h.

                          {
         AM_None          = 0,
         AM_DrawBefore    = 1 << 0,
         AM_MatchSkeleton = 1 << 1
     };

Constructor & Destructor Documentation

◆ StdMeshInstance()

StdMeshInstance::StdMeshInstance	(	const StdMesh &	mesh,
		float	completion = `1.0f`
	)

Definition at line 1072 of file StdMesh.cpp.

                                                                      :
         Mesh(&mesh), Completion(completion),
         BoneTransforms(Mesh->GetSkeleton().GetNumBones(), StdMeshMatrix::Identity()),
         SubMeshInstances(Mesh->GetNumSubMeshes()), AttachParent(nullptr),
         BoneTransformsDirty(false)
 #ifndef USE_CONSOLE
         , ibo(0), vaoid(0)
 #endif
 {
     // Create submesh instances
     for (unsigned int i = 0; i < Mesh->GetNumSubMeshes(); ++i)
     {
         const StdSubMesh& submesh = Mesh->GetSubMesh(i);
         SubMeshInstances[i] = new StdSubMeshInstance(*this, submesh, completion);
     }
  
     // copy, order is fine at the moment since only default materials are used.
     SubMeshInstancesOrdered = SubMeshInstances;
 }

References StdMesh::GetNumSubMeshes(), StdMesh::GetSubMesh(), Mesh, SubMeshInstances, and SubMeshInstancesOrdered.

Referenced by AttachMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~StdMeshInstance()

StdMeshInstance::~StdMeshInstance ( )

Definition at line 1092 of file StdMesh.cpp.

 {
 #ifndef USE_CONSOLE
     if (ibo) glDeleteBuffers(1, &ibo);
     if (vaoid) pGL->FreeVAOID(vaoid);
 #endif
  
     // If we are attached then detach from parent
     if (AttachParent)
         AttachParent->Parent->DetachMesh(AttachParent->Number);
  
     // Remove all attach children
     while (!AttachChildren.empty())
         DetachMesh(AttachChildren.back()->Number);
  
     while (!AnimationStack.empty())
         StopAnimation(AnimationStack.front());
     assert(AnimationNodes.empty());
  
     // Delete submeshes
     for (auto & SubMeshInstance : SubMeshInstances)
     {
         delete SubMeshInstance;
     }
 }

References AnimationNodes, AnimationStack, AttachChildren, AttachParent, DetachMesh(), CStdGL::FreeVAOID(), ibo, StdMeshInstance::AttachedMesh::Number, StdMeshInstance::AttachedMesh::Parent, pGL, StopAnimation(), SubMeshInstances, and vaoid.

Here is the call graph for this function:

Member Function Documentation

◆ ApplyBoneTransformToVertices()

void StdMeshInstance::ApplyBoneTransformToVertices	(	const std::vector< StdSubMesh::Vertex > &	mesh_vertices,
		std::vector< StdMeshVertex > &	instance_vertices
	)

protected

◆ AttachedMeshesBegin()

AttachedMeshIter StdMeshInstance::AttachedMeshesBegin ( ) const

inline

Definition at line 584 of file StdMesh.h.

584 { return AttachChildren.begin(); }

References AttachChildren.

Referenced by StdMeshUpdate::Update().

Here is the caller graph for this function:

◆ AttachedMeshesEnd()

AttachedMeshIter StdMeshInstance::AttachedMeshesEnd ( ) const

inline

Definition at line 585 of file StdMesh.h.

585 { return AttachChildren.end(); }

References AttachChildren.

Referenced by StdMeshUpdate::Update().

Here is the caller graph for this function:

◆ AttachMesh() [1/2]

StdMeshInstance::AttachedMesh * StdMeshInstance::AttachMesh	(	const StdMesh &	mesh,
		AttachedMesh::Denumerator *	denumerator,
		const StdStrBuf &	parent_bone,
		const StdStrBuf &	child_bone,
		const StdMeshMatrix &	transformation = `StdMeshMatrix::Identity()`,
		uint32_t	flags = `AM_None`,
		unsigned int	attach_number = `0`
	)

Definition at line 1333 of file StdMesh.cpp.

 {
     std::unique_ptr<AttachedMesh::Denumerator> auto_denumerator(denumerator);
  
     StdMeshInstance* instance = new StdMeshInstance(mesh, 1.0f);
     AttachedMesh* attach = AttachMesh(*instance, auto_denumerator.release(), parent_bone, child_bone, transformation, flags, true, attach_number);
     if (!attach) { delete instance; return nullptr; }
     return attach;
 }

References StdMeshInstance().

Here is the call graph for this function:

◆ AttachMesh() [2/2]

StdMeshInstance::AttachedMesh * StdMeshInstance::AttachMesh	(	StdMeshInstance &	instance,
		AttachedMesh::Denumerator *	denumerator,
		const StdStrBuf &	parent_bone,
		const StdStrBuf &	child_bone,
		const StdMeshMatrix &	transformation = `StdMeshMatrix::Identity()`,
		uint32_t	flags = `AM_None`,
		bool	own_child = `false`,
		unsigned int	attach_number = `0`
	)

Definition at line 1343 of file StdMesh.cpp.

 {
     std::unique_ptr<AttachedMesh::Denumerator> auto_denumerator(denumerator);
  
     // Owned attach children must be set via the topmost instance, to ensure
     // attach number uniqueness.
     if (AttachParent && AttachParent->OwnChild) return nullptr;
  
     // Find free index.
     unsigned int number = 0;
     ScanAttachTree(AttachChildren.begin(), AttachChildren.end(), [&number](AttachedMeshList::const_iterator iter) { number = std::max(number, (*iter)->Number); return true; });
     number += 1; // One above highest
  
     StdMeshInstance* direct_parent = this;
     if (attach_number != 0)
     {
         AttachedMesh* attach = GetAttachedMeshByNumber(attach_number);
         if (attach == nullptr) return nullptr;
         direct_parent = attach->Child;
     }
  
     return direct_parent->AttachMeshImpl(instance, auto_denumerator.release(), parent_bone, child_bone, transformation, flags, own_child, number);
 }

References AttachChildren, AttachMeshImpl(), AttachParent, StdMeshInstance::AttachedMesh::Child, GetAttachedMeshByNumber(), StdMeshInstance::AttachedMesh::OwnChild, and ScanAttachTree().

Here is the call graph for this function:

◆ AttachMeshImpl()

StdMeshInstance::AttachedMesh * StdMeshInstance::AttachMeshImpl	(	StdMeshInstance &	instance,
		AttachedMesh::Denumerator *	denumerator,
		const StdStrBuf &	parent_bone,
		const StdStrBuf &	child_bone,
		const StdMeshMatrix &	transformation,
		uint32_t	flags,
		bool	own_child,
		unsigned int	new_attach_number
	)

protected

Definition at line 1367 of file StdMesh.cpp.

 {
     std::unique_ptr<AttachedMesh::Denumerator> auto_denumerator(denumerator);
  
     // We don't allow an instance to be attached to multiple parent instances for now
     if (instance.AttachParent) return nullptr;
  
     // Make sure there are no cyclic attachments
     for (StdMeshInstance* Parent = this; Parent->AttachParent != nullptr; Parent = Parent->AttachParent->Parent)
         if (Parent == &instance)
             return nullptr;
  
     const StdMeshBone* parent_bone_obj = Mesh->GetSkeleton().GetBoneByName(parent_bone);
     const StdMeshBone* child_bone_obj = instance.Mesh->GetSkeleton().GetBoneByName(child_bone);
     if (!parent_bone_obj || !child_bone_obj) return nullptr;
  
     AttachedMesh* attach = new AttachedMesh(new_attach_number, this, &instance, own_child, auto_denumerator.release(), parent_bone_obj->Index, child_bone_obj->Index, transformation, flags);
     instance.AttachParent = attach;
  
     // If DrawInFront is set then sort before others so that drawing order is easy
     if(flags & AM_DrawBefore)
         AttachChildren.insert(AttachChildren.begin(), attach);
     else
         AttachChildren.insert(AttachChildren.end(), attach);
  
     return attach;
 }

References AM_DrawBefore, AttachChildren, AttachParent, StdMeshSkeleton::GetBoneByName(), StdMesh::GetSkeleton(), StdMeshBone::Index, Mesh, and StdMeshInstance::AttachedMesh::Parent.

Referenced by AttachMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearPointers()

void StdMeshInstance::ClearPointers ( class C4Object * pObj )

Definition at line 1686 of file StdMesh.cpp.

 {
     for(auto & AnimationNode : AnimationNodes)
         if(AnimationNode)
             AnimationNode->ClearPointers(pObj);
  
     std::vector<unsigned int> Removal;
     for(auto & i : AttachChildren)
         if(!i->ClearPointers(pObj))
             Removal.push_back(i->Number);
  
     for(unsigned int i : Removal)
         DetachMesh(i);
 }

References AnimationNodes, AttachChildren, StdMeshInstanceAnimationNode::ClearPointers(), and DetachMesh().

Referenced by C4Object::ClearPointers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CompileFunc()

void StdMeshInstance::CompileFunc	(	StdCompiler *	pComp,
		AttachedMesh::DenumeratorFactoryFunc	Factory
	)

Definition at line 1578 of file StdMesh.cpp.

 {
     if(pComp->isDeserializer())
     {
         // Only initially created instances can be compiled
         assert(!AttachParent);
         assert(AttachChildren.empty());
         assert(AnimationStack.empty());
         SetBoneTransformsDirty(true);
  
         bool valid;
         pComp->Value(mkNamingAdapt(valid, "Valid"));
         if(!valid) pComp->excCorrupt("Mesh instance is invalid");
  
         int32_t iSubMeshCnt;
         pComp->Value(mkNamingCountAdapt(iSubMeshCnt, "SubMesh"));
         if(static_cast<uint32_t>(iSubMeshCnt) != SubMeshInstances.size())
             pComp->excCorrupt("Invalid number of submeshes");
         for(int32_t i = 0; i < iSubMeshCnt; ++i)
             pComp->Value(mkNamingAdapt(*SubMeshInstances[i], "SubMesh"));
 #ifndef USE_CONSOLE
         // The sorting predicate depends on having a gfx implementation.
         std::stable_sort(SubMeshInstancesOrdered.begin(), SubMeshInstancesOrdered.end(), StdMeshSubMeshInstanceVisibilityCmpPred());
 #endif
  
         int32_t iAnimCnt = AnimationStack.size();
         pComp->Value(mkNamingCountAdapt(iAnimCnt, "AnimationNode"));
  
         for(int32_t i = 0; i < iAnimCnt; ++i)
         {
             AnimationNode* node = nullptr;
             pComp->Value(mkParAdapt(mkNamingPtrAdapt(node, "AnimationNode"), Mesh));
             AnimationNodeList::iterator iter = GetStackIterForSlot(node->Slot, true);
             if(*iter != nullptr) { delete node; pComp->excCorrupt("Duplicate animation slot index"); }
             *iter = node;
  
             // Add nodes into lookup table
             std::vector<AnimationNode*> nodes(1, node);
             while(!nodes.empty())
             {
                 node = nodes.back();
                 nodes.erase(nodes.end()-1);
  
                 if (AnimationNodes.size() <= node->Number)
                     AnimationNodes.resize(node->Number+1);
                 if(AnimationNodes[node->Number] != nullptr) pComp->excCorrupt("Duplicate animation node number");
                 AnimationNodes[node->Number] = node;
  
                 if(node->Type == AnimationNode::LinearInterpolationNode)
                 {
                     nodes.push_back(node->LinearInterpolation.ChildLeft);
                     nodes.push_back(node->LinearInterpolation.ChildRight);
                 }
             }
         }
  
         int32_t iAttachedCnt;
         pComp->Value(mkNamingCountAdapt(iAttachedCnt, "Attached"));
  
         for(int32_t i = 0; i < iAttachedCnt; ++i)
         {
             AttachChildren.push_back(new AttachedMesh);
             AttachedMesh* attach = AttachChildren.back();
  
             attach->Parent = this;
             pComp->Value(mkNamingAdapt(mkParAdapt(*attach, Factory), "Attached"));
         }
     }
     else
     {
         // Write something to make sure that the parent
         // named section ([Mesh] or [ChildInstance]) is written.
         // StdCompilerIni does not make a difference between
         // non-existing and empty named sections.
         bool valid = true;
         pComp->Value(mkNamingAdapt(valid, "Valid"));
  
         int32_t iSubMeshCnt = SubMeshInstances.size();
         pComp->Value(mkNamingCountAdapt(iSubMeshCnt, "SubMesh"));
         for(int32_t i = 0; i < iSubMeshCnt; ++i)
             pComp->Value(mkNamingAdapt(*SubMeshInstances[i], "SubMesh"));
  
         int32_t iAnimCnt = AnimationStack.size();
         pComp->Value(mkNamingCountAdapt(iAnimCnt, "AnimationNode"));
  
         for(auto & iter : AnimationStack)
             pComp->Value(mkParAdapt(mkNamingPtrAdapt(iter, "AnimationNode"), Mesh));
  
         int32_t iAttachedCnt = AttachChildren.size();
         pComp->Value(mkNamingCountAdapt(iAttachedCnt, "Attached"));
         
         for(auto & i : AttachChildren)
             pComp->Value(mkNamingAdapt(mkParAdapt(*i, Factory), "Attached"));
     }
 }

References AnimationNodes, AnimationStack, AttachChildren, AttachParent, StdCompiler::excCorrupt(), GetStackIterForSlot(), StdCompiler::isDeserializer(), StdMeshInstanceAnimationNode::LinearInterpolationNode, Mesh, mkNamingAdapt(), mkNamingCountAdapt(), mkNamingPtrAdapt(), mkParAdapt(), StdMeshInstanceAnimationNode::Number, StdMeshInstance::AttachedMesh::Parent, SetBoneTransformsDirty(), StdMeshInstanceAnimationNode::Slot, SubMeshInstances, SubMeshInstancesOrdered, StdMeshInstanceAnimationNode::Type, and StdCompiler::Value().

Here is the call graph for this function:

◆ DenumeratePointers()

void StdMeshInstance::DenumeratePointers ( )

Definition at line 1674 of file StdMesh.cpp.

 {
     for(auto & AnimationNode : AnimationNodes)
         if(AnimationNode)
             AnimationNode->DenumeratePointers();
  
     for(auto & i : AttachChildren)
     {
         i->DenumeratePointers();
     }
 }

References AnimationNodes, AttachChildren, and StdMeshInstanceAnimationNode::DenumeratePointers().

Referenced by C4Object::Denumerate().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DetachMesh()

bool StdMeshInstance::DetachMesh ( unsigned int number )

Definition at line 1395 of file StdMesh.cpp.

 {
     return !ScanAttachTree(AttachChildren.begin(), AttachChildren.end(), [number](AttachedMeshList::iterator iter)
     {
         if ((*iter)->Number == number)
         {
             AttachedMesh* attached = *iter;
  
             // Reset attach parent of child so it does not try
             // to detach itself on destruction.
             attached->Child->AttachParent = nullptr;
             attached->Parent->AttachChildren.erase(iter);
  
             delete attached;
  
             // Finish scan
             return false;
         }
  
         // Continue scan
         return true;
     });
 }

References AttachChildren, and ScanAttachTree().

Referenced by ClearPointers(), StdMeshUpdate::Update(), C4Object::UpdateGraphics(), and ~StdMeshInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExecuteAnimation()

void StdMeshInstance::ExecuteAnimation ( float dt )

Definition at line 1288 of file StdMesh.cpp.

 {
     // Iterate from the back since slots might be removed
     for (unsigned int i = AnimationStack.size(); i > 0; --i)
         if(!ExecuteAnimationNode(AnimationStack[i-1]))
             StopAnimation(AnimationStack[i-1]);
  
 #ifndef USE_CONSOLE
     // Update animated textures
     for (auto & SubMeshInstance : SubMeshInstances)
     {
         StdSubMeshInstance& submesh = *SubMeshInstance;
         const StdMeshMaterial& material = submesh.GetMaterial();
         const StdMeshMaterialTechnique& technique = material.Techniques[material.BestTechniqueIndex];
         for (unsigned int j = 0; j < submesh.PassData.size(); ++j)
         {
             StdSubMeshInstance::Pass& pass = submesh.PassData[j];
             for (unsigned int k = 0; k < pass.TexUnits.size(); ++k)
             {
                 const StdMeshMaterialTextureUnit& texunit = technique.Passes[j].TextureUnits[k];
                 StdSubMeshInstance::TexUnit& texunit_instance = submesh.PassData[j].TexUnits[k];
                 if (texunit.HasFrameAnimation())
                 {
                     const unsigned int NumPhases = texunit.GetNumTextures();
                     const float PhaseDuration = texunit.Duration / NumPhases;
  
                     const float Position = texunit_instance.PhaseDelay + dt;
                     const unsigned int AddPhases = static_cast<unsigned int>(Position / PhaseDuration);
  
                     texunit_instance.Phase = (texunit_instance.Phase + AddPhases) % NumPhases;
                     texunit_instance.PhaseDelay = Position - AddPhases * PhaseDuration;
                 }
  
                 if (texunit.HasTexCoordAnimation())
                     texunit_instance.Position += dt;
             }
         }
     }
 #endif
  
     // Update animation for attached meshes
     for (auto & iter : AttachChildren)
         iter->Child->ExecuteAnimation(dt);
 }

References AnimationStack, AttachChildren, StdMeshMaterial::BestTechniqueIndex, StdMeshMaterialTextureUnit::Duration, ExecuteAnimationNode(), StdSubMeshInstance::GetMaterial(), StdMeshMaterialTextureUnit::GetNumTextures(), StdMeshMaterialTextureUnit::HasFrameAnimation(), StdMeshMaterialTextureUnit::HasTexCoordAnimation(), StdSubMeshInstance::PassData, StdMeshMaterialTechnique::Passes, StdSubMeshInstance::TexUnit::Phase, StdSubMeshInstance::TexUnit::PhaseDelay, StdSubMeshInstance::TexUnit::Position, StopAnimation(), SubMeshInstances, StdMeshMaterial::Techniques, and StdSubMeshInstance::Pass::TexUnits.

Referenced by C4Object::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExecuteAnimationNode()

bool StdMeshInstance::ExecuteAnimationNode ( AnimationNode * node )

protected

Definition at line 1816 of file StdMesh.cpp.

 {
     ValueProvider* provider = nullptr;
     C4Real min;
     C4Real max;
  
     switch (node->GetType())
     {
     case AnimationNode::LeafNode:
         provider = node->GetPositionProvider();
         min = Fix0;
         max = ftofix(node->GetAnimation()->Length);
         break;
     case AnimationNode::CustomNode:
         // No execution necessary
         return true;
     case AnimationNode::LinearInterpolationNode:
         provider = node->GetWeightProvider();
         min = Fix0;
         max = itofix(1);
         break;
     default:
         assert(false);
         break;
     }
  
     assert(provider);
     const C4Real old_value = provider->Value;
  
     if (!provider->Execute())
     {
         if (node->GetType() == AnimationNode::LeafNode) return false;
  
         // Remove the child with less weight (normally weight reaches 0.0 or 1.0)
         if (node->GetWeight() > itofix(1, 2))
         {
             // Remove both children (by parent) if other wants to be deleted as well
             if (!ExecuteAnimationNode(node->GetRightChild())) return false;
             // Remove left child as it has less weight
             StopAnimation(node->LinearInterpolation.ChildLeft);
         }
         else
         {
             // Remove both children (by parent) if other wants to be deleted as well
             if (!ExecuteAnimationNode(node->GetLeftChild())) return false;
             // Remove right child as it has less weight
             StopAnimation(node->LinearInterpolation.ChildRight);
         }
     }
     else
     {
         if (provider->Value != old_value)
         {
             provider->Value = Clamp(provider->Value, min, max);
             SetBoneTransformsDirty(true);
         }
  
         if (node->GetType() == AnimationNode::LinearInterpolationNode)
         {
             const bool left_result = ExecuteAnimationNode(node->GetLeftChild());
             const bool right_result = ExecuteAnimationNode(node->GetRightChild());
  
             // Remove this node completely
             if (!left_result && !right_result)
                 return false;
  
             // Note that either of this also removes node
             if (!left_result)
                 StopAnimation(node->GetLeftChild());
             if (!right_result)
                 StopAnimation(node->GetRightChild());
         }
     }
  
     return true;
 }

Referenced by ExecuteAnimation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAnimationNodeByNumber()

StdMeshInstance::AnimationNode * StdMeshInstance::GetAnimationNodeByNumber ( unsigned int number )

Definition at line 1247 of file StdMesh.cpp.

 {
     if (number >= AnimationNodes.size()) return nullptr;
     return AnimationNodes[number];
 }

References AnimationNodes.

◆ GetAttachedMeshByNumber()

StdMeshInstance::AttachedMesh * StdMeshInstance::GetAttachedMeshByNumber ( unsigned int number ) const

Definition at line 1419 of file StdMesh.cpp.

 {
     StdMeshInstance::AttachedMesh* result = nullptr;
  
     ScanAttachTree(AttachChildren.begin(), AttachChildren.end(), [number, &result](AttachedMeshList::const_iterator iter)
     {
         if ((*iter)->Number == number)
         {
             result = *iter;
             return false;
         }
  
         return true;
     });
  
     return result;
 }

References AttachChildren, and ScanAttachTree().

Referenced by AttachMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetAttachParent()

AttachedMesh* StdMeshInstance::GetAttachParent ( ) const

inline

Definition at line 586 of file StdMesh.h.

586 { return AttachParent; }

References AttachParent.

Referenced by C4Object::Execute(), and C4Object::UpdateGraphics().

Here is the caller graph for this function:

◆ GetBoneCount()

size_t StdMeshInstance::GetBoneCount ( ) const

Definition at line 1463 of file StdMesh.cpp.

 {
     if ((AttachParent != nullptr) && (AttachParent->GetFlags() & AM_MatchSkeleton))
         return AttachParent->MatchedBoneInParentSkeleton.size();
     else
         return BoneTransforms.size();
 }

References AM_MatchSkeleton, AttachParent, BoneTransforms, and StdMeshInstance::AttachedMesh::GetFlags().

Here is the call graph for this function:

◆ GetBoneTransform()

const StdMeshMatrix & StdMeshInstance::GetBoneTransform ( size_t i ) const

Definition at line 1446 of file StdMesh.cpp.

 {
     if ((AttachParent != nullptr) && (AttachParent->GetFlags() & AM_MatchSkeleton))
     {
         assert(i < AttachParent->MatchedBoneInParentSkeleton.size());
  
         int parent_bone_index = AttachParent->MatchedBoneInParentSkeleton[i];
  
         if (parent_bone_index > -1)
         {
             return AttachParent->Parent->BoneTransforms[i];
         }
     }
  
     return BoneTransforms[i];
 }

References AM_MatchSkeleton, AttachParent, BoneTransforms, StdMeshInstance::AttachedMesh::GetFlags(), and StdMeshInstance::AttachedMesh::Parent.

Referenced by UpdateBoneTransforms().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetCompletion()

float StdMeshInstance::GetCompletion ( ) const

inline

Definition at line 554 of file StdMesh.h.

554 { return Completion; }

References Completion.

Referenced by StdSubMeshInstance::SetFaceOrdering(), and StdMeshUpdate::Update().

Here is the caller graph for this function:

◆ GetIBO()

GLuint StdMeshInstance::GetIBO ( ) const

inline

Definition at line 625 of file StdMesh.h.

625 { return ibo ? ibo : Mesh->GetIBO(); }

StdMesh::GetIBO

GLuint GetIBO() const

Definition: StdMesh.h:213

References StdMesh::GetIBO(), ibo, and Mesh.

Here is the call graph for this function:

◆ GetMesh()

const StdMesh& StdMeshInstance::GetMesh ( ) const

inline

Definition at line 622 of file StdMesh.h.

622 { return *Mesh; }

References Mesh.

Referenced by StdMeshInstance::AttachedMesh::AttachedMesh(), C4Object::DrawFaceImpl(), CStdGL::PerformMesh(), StdMeshMaterialUpdate::Update(), StdMeshUpdate::Update(), and C4Object::UpdateGraphics().

Here is the caller graph for this function:

◆ GetNumSharedVertices()

size_t StdMeshInstance::GetNumSharedVertices ( ) const

inline

Definition at line 550 of file StdMesh.h.

550 { return GetSharedVertices().size(); }

StdMeshInstance::GetSharedVertices

const std::vector< StdMeshVertex > & GetSharedVertices() const

Definition: StdMesh.h:549

References GetSharedVertices().

Here is the call graph for this function:

◆ GetNumSubMeshes()

size_t StdMeshInstance::GetNumSubMeshes ( ) const

inline

Definition at line 588 of file StdMesh.h.

588 { return SubMeshInstances.size(); }

References SubMeshInstances.

◆ GetRootAnimationForSlot()

StdMeshInstance::AnimationNode * StdMeshInstance::GetRootAnimationForSlot ( int slot )

Definition at line 1253 of file StdMesh.cpp.

 {
     AnimationNodeList::iterator iter = GetStackIterForSlot(slot, false);
     if (iter == AnimationStack.end()) return nullptr;
     return *iter;
 }

References AnimationStack, and GetStackIterForSlot().

Referenced by C4Object::CompileFunc(), and InsertAnimationNode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSharedVertices()

const std::vector<StdMeshVertex>& StdMeshInstance::GetSharedVertices ( ) const

inline

Definition at line 549 of file StdMesh.h.

549 { return Mesh->GetSharedVertices(); }

StdMesh::GetSharedVertices

const std::vector< Vertex > & GetSharedVertices() const

Definition: StdMesh.h:201

References StdMesh::GetSharedVertices(), and Mesh.

Referenced by GetNumSharedVertices(), StdSubMeshInstance::LoadFacesForCompletion(), and ReorderFaces().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStackIterForSlot()

StdMeshInstance::AnimationNodeList::iterator StdMeshInstance::GetStackIterForSlot	(	int	slot,
		bool	create
	)

protected

Definition at line 1718 of file StdMesh.cpp.

 {
     // TODO: bsearch
     for (AnimationNodeList::iterator iter = AnimationStack.begin(); iter != AnimationStack.end(); ++iter)
     {
         if ((*iter)->Slot == slot)
         {
             return iter;
         }
         else if ((*iter)->Slot > slot)
         {
             if (!create)
                 return AnimationStack.end();
             else
                 return AnimationStack.insert(iter, nullptr);
         }
     }
  
     if (!create)
         return AnimationStack.end();
     else
         return AnimationStack.insert(AnimationStack.end(), nullptr);
 }

References AnimationStack.

Referenced by CompileFunc(), GetRootAnimationForSlot(), InsertAnimationNode(), and StopAnimation().

Here is the caller graph for this function:

◆ GetSubMesh() [1/2]

StdSubMeshInstance& StdMeshInstance::GetSubMesh ( size_t i )

inline

Definition at line 589 of file StdMesh.h.

589 { return *SubMeshInstances[i]; }

References SubMeshInstances.

◆ GetSubMesh() [2/2]

const StdSubMeshInstance& StdMeshInstance::GetSubMesh ( size_t i ) const

inline

Definition at line 590 of file StdMesh.h.

590 { return *SubMeshInstances[i]; }

References SubMeshInstances.

◆ GetSubMeshOrdered()

const StdSubMeshInstance& StdMeshInstance::GetSubMeshOrdered ( size_t i ) const

inline

Definition at line 591 of file StdMesh.h.

591 { return *SubMeshInstancesOrdered[i]; }

References SubMeshInstancesOrdered.

◆ GetVAOID()

unsigned int StdMeshInstance::GetVAOID ( ) const

inline

Definition at line 626 of file StdMesh.h.

626 { return vaoid ? vaoid : Mesh->GetVAOID(); }

StdMesh::GetVAOID

unsigned int GetVAOID() const

Definition: StdMesh.h:214

References StdMesh::GetVAOID(), Mesh, and vaoid.

Here is the call graph for this function:

◆ InsertAnimationNode()

void StdMeshInstance::InsertAnimationNode	(	AnimationNode *	node,
		int	slot,
		AnimationNode *	sibling,
		ValueProvider *	weight,
		bool	stop_previous_animation
	)

protected

Definition at line 1742 of file StdMesh.cpp.

 {
     assert(!sibling || !stop_previous_animation);
     // Default
     if (!sibling) sibling = GetRootAnimationForSlot(slot);
     assert(!sibling || sibling->Slot == slot);
     
     // Stop any animation already running in this slot?
     if (sibling && stop_previous_animation)
     {
         StopAnimation(sibling);
         sibling = nullptr;
     }
  
     // Find two subsequent numbers in case we need to create two nodes, so
     // script can deduce the second node.
     unsigned int Number1, Number2;
     for (Number1 = 0; Number1 < AnimationNodes.size(); ++Number1)
         if (AnimationNodes[Number1] == nullptr && (!sibling || Number1+1 == AnimationNodes.size() || AnimationNodes[Number1+1] == nullptr))
             break;
     /*  for(Number2 = Number1+1; Number2 < AnimationNodes.size(); ++Number2)
         if(AnimationNodes[Number2] == nullptr)
           break;*/
     Number2 = Number1 + 1;
  
     weight->Value = Clamp(weight->Value, Fix0, itofix(1));
  
     if (Number1 == AnimationNodes.size()) AnimationNodes.push_back( (StdMeshInstance::AnimationNode*) nullptr);
     if (sibling && Number2 == AnimationNodes.size()) AnimationNodes.push_back( (StdMeshInstance::AnimationNode*) nullptr);
  
     AnimationNodes[Number1] = node;
     node->Number = Number1;
     node->Slot = slot;
  
     if (sibling)
     {
         AnimationNode* parent = new AnimationNode(node, sibling, weight);
         AnimationNodes[Number2] = parent;
         parent->Number = Number2;
         parent->Slot = slot;
  
         node->Parent = parent;
         parent->Parent = sibling->Parent;
         parent->LinearInterpolation.ChildLeft = sibling;
         parent->LinearInterpolation.ChildRight = node;
         if (sibling->Parent)
         {
             if (sibling->Parent->LinearInterpolation.ChildLeft == sibling)
                 sibling->Parent->LinearInterpolation.ChildLeft = parent;
             else
                 sibling->Parent->LinearInterpolation.ChildRight = parent;
         }
         else
         {
             // set new parent
             AnimationNodeList::iterator iter = GetStackIterForSlot(slot, false);
             // slot must not be empty, since sibling uses same slot
             assert(iter != AnimationStack.end() && *iter != nullptr);
             *iter = parent;
         }
  
         sibling->Parent = parent;
     }
     else
     {
         delete weight;
         AnimationNodeList::iterator iter = GetStackIterForSlot(slot, true);
         assert(!*iter); // we have a sibling if slot is not empty
         *iter = node;
     }
  
     SetBoneTransformsDirty(true);
 }

References AnimationNodes, AnimationStack, Clamp(), Fix0, GetRootAnimationForSlot(), GetStackIterForSlot(), itofix(), StdMeshInstanceAnimationNode::Number, StdMeshInstanceAnimationNode::Parent, SetBoneTransformsDirty(), StdMeshInstanceAnimationNode::Slot, StopAnimation(), and StdMeshInstanceValueProvider::Value.

Referenced by PlayAnimation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PlayAnimation() [1/3]

StdMeshInstance::AnimationNode * StdMeshInstance::PlayAnimation	(	const StdMeshAnimation &	animation,
		int	slot,
		AnimationNode *	sibling,
		ValueProvider *	position,
		ValueProvider *	weight,
		bool	stop_previous_animation
	)

Definition at line 1175 of file StdMesh.cpp.

 {
     position->Value = Clamp(position->Value, Fix0, ftofix(animation.Length));
     AnimationNode* child = new AnimationNode(&animation, position);
     InsertAnimationNode(child, slot, sibling, weight, stop_previous_animation);
     return child;
 }

References Clamp(), Fix0, ftofix(), InsertAnimationNode(), StdMeshAnimation::Length, and StdMeshInstanceValueProvider::Value.

Here is the call graph for this function:

◆ PlayAnimation() [2/3]

StdMeshInstance::AnimationNode * StdMeshInstance::PlayAnimation	(	const StdMeshBone *	bone,
		const StdMeshTransformation &	trans,
		int	slot,
		AnimationNode *	sibling,
		ValueProvider *	weight,
		bool	stop_previous_animation
	)

Definition at line 1183 of file StdMesh.cpp.

 {
     AnimationNode* child = new AnimationNode(bone, trans);
     InsertAnimationNode(child, slot, sibling, weight, stop_previous_animation);
     return child;
 }

References InsertAnimationNode().

Here is the call graph for this function:

◆ PlayAnimation() [3/3]

StdMeshInstance::AnimationNode * StdMeshInstance::PlayAnimation	(	const StdStrBuf &	animation_name,
		int	slot,
		AnimationNode *	sibling,
		ValueProvider *	position,
		ValueProvider *	weight,
		bool	stop_previous_animation
	)

Definition at line 1167 of file StdMesh.cpp.

 {
     const StdMeshAnimation* animation = Mesh->GetSkeleton().GetAnimationByName(animation_name);
     if (!animation) { delete position; delete weight; return nullptr; }
  
     return PlayAnimation(*animation, slot, sibling, position, weight, stop_previous_animation);
 }

References StdMeshSkeleton::GetAnimationByName(), StdMesh::GetSkeleton(), and Mesh.

Referenced by C4Object::SetAction(), and C4GraphicsOverlay::UpdateFacet().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReorderFaces()

void StdMeshInstance::ReorderFaces ( StdMeshMatrix * global_trans )

Definition at line 1552 of file StdMesh.cpp.

 {
 #ifndef USE_CONSOLE
     for (auto & SubMeshInstance : SubMeshInstances)
     {
         StdSubMeshInstance& inst = *SubMeshInstance;
         assert((inst.Faces.size() > 0) && "StdMeshInstance sub-mesh instance has zero faces");
  
         if(inst.Faces.size() > 0 && inst.CurrentFaceOrdering != StdSubMeshInstance::FO_Fixed)
         {
             const StdMeshVertex* vertices;
             if(inst.GetSubMesh().GetNumVertices() > 0)
                 vertices = &inst.GetSubMesh().GetVertices()[0];
             else
                 vertices = &GetSharedVertices()[0];
             SortFacesArray(vertices, inst.Faces, inst.CurrentFaceOrdering, global_trans ? *global_trans : StdMeshMatrix::Identity());
         }
     }
  
     // TODO: Also reorder submeshes, attached meshes and include AttachTransformation for attached meshes...
  
     // Faces have been reordered: upload new order to GPU
     UpdateIBO();
 #endif
 }

References StdSubMeshInstance::CurrentFaceOrdering, StdSubMeshInstance::Faces, StdSubMeshInstance::FO_Fixed, StdSubMesh::GetNumVertices(), GetSharedVertices(), StdSubMeshInstance::GetSubMesh(), StdSubMesh::GetVertices(), StdMeshMatrix::Identity(), SubMeshInstances, and UpdateIBO().

Referenced by C4Draw::RenderMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ScanAttachTree()

template<typename IteratorType , typename FuncObj >

bool StdMeshInstance::ScanAttachTree	(	IteratorType	begin,
		IteratorType	end,
		const FuncObj &	obj
	)

staticprotected

Definition at line 1702 of file StdMesh.cpp.

 {
     for (IteratorType iter = begin; iter != end; ++iter)
     {
         if (!obj(iter)) return false;
  
         // Scan attached tree of own children. For non-owned children,
         // we can't guarantee unique attach numbers.
         if( (*iter)->OwnChild)
             if (!ScanAttachTree((*iter)->Child->AttachChildren.begin(), (*iter)->Child->AttachChildren.end(), obj))
                 return false;
     }
  
     return true;
 }

Referenced by AttachMesh(), DetachMesh(), and GetAttachedMeshByNumber().

Here is the caller graph for this function:

◆ SetAnimationBoneTransform()

void StdMeshInstance::SetAnimationBoneTransform	(	AnimationNode *	node,
		const StdMeshTransformation &	trans
	)

Definition at line 1271 of file StdMesh.cpp.

 {
     assert(node->GetType() == AnimationNode::CustomNode);
     *node->Custom.Transformation = trans;
     SetBoneTransformsDirty(true);
 }

References StdMeshInstanceAnimationNode::CustomNode, StdMeshInstanceAnimationNode::GetType(), and SetBoneTransformsDirty().

Here is the call graph for this function:

◆ SetAnimationPosition()

void StdMeshInstance::SetAnimationPosition	(	AnimationNode *	node,
		ValueProvider *	position
	)

Definition at line 1260 of file StdMesh.cpp.

 {
     assert(node->GetType() == AnimationNode::LeafNode);
     delete node->Leaf.Position;
     node->Leaf.Position = position;
  
     position->Value = Clamp(position->Value, Fix0, ftofix(node->Leaf.Animation->Length));
  
     SetBoneTransformsDirty(true);
 }

References Clamp(), Fix0, ftofix(), StdMeshInstanceAnimationNode::GetType(), StdMeshInstanceAnimationNode::LeafNode, SetBoneTransformsDirty(), and StdMeshInstanceValueProvider::Value.

Here is the call graph for this function:

◆ SetAnimationWeight()

void StdMeshInstance::SetAnimationWeight	(	AnimationNode *	node,
		ValueProvider *	weight
	)

Definition at line 1278 of file StdMesh.cpp.

 {
     assert(node->GetType() == AnimationNode::LinearInterpolationNode);
     delete node->LinearInterpolation.Weight; node->LinearInterpolation.Weight = weight;
  
     weight->Value = Clamp(weight->Value, Fix0, itofix(1));
  
     SetBoneTransformsDirty(true);
 }

References Clamp(), Fix0, StdMeshInstanceAnimationNode::GetType(), itofix(), StdMeshInstanceAnimationNode::LinearInterpolationNode, SetBoneTransformsDirty(), and StdMeshInstanceValueProvider::Value.

Here is the call graph for this function:

◆ SetBoneTransformsDirty()

void StdMeshInstance::SetBoneTransformsDirty ( bool value )

protected

Definition at line 1893 of file StdMesh.cpp.

 {
     BoneTransformsDirty = value;
  
     // only if the value is true, so that updates happen
     if (value)
     {
         // Update attachment's attach transformations. Note this is done recursively.
         for (auto attach : AttachChildren)
         {
             if (attach->GetFlags() & AM_MatchSkeleton)
             {
                 attach->Child->SetBoneTransformsDirty(value);
             }
         }
     }
 }

References AM_MatchSkeleton, AttachChildren, and BoneTransformsDirty.

Referenced by CompileFunc(), ExecuteAnimationNode(), InsertAnimationNode(), SetAnimationBoneTransform(), SetAnimationPosition(), SetAnimationWeight(), StopAnimation(), and UpdateBoneTransforms().

Here is the caller graph for this function:

◆ SetCompletion()

void StdMeshInstance::SetCompletion ( float completion )

Definition at line 1152 of file StdMesh.cpp.

 {
     Completion = completion;
  
 #ifndef USE_CONSOLE
     // TODO: Load all submesh faces and then determine the ones to use from the
     // full pool.
     for(unsigned int i = 0; i < Mesh->GetNumSubMeshes(); ++i)
         SubMeshInstances[i]->LoadFacesForCompletion(*this, Mesh->GetSubMesh(i), completion);
  
     // Faces have been reordered: upload new order to GPU
     UpdateIBO();
 #endif
 }

References Completion, StdMesh::GetNumSubMeshes(), StdMesh::GetSubMesh(), Mesh, SubMeshInstances, and UpdateIBO().

Referenced by C4Object::DoCon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFaceOrdering()

void StdMeshInstance::SetFaceOrdering ( FaceOrdering ordering )

Definition at line 1118 of file StdMesh.cpp.

 {
 #ifndef USE_CONSOLE
     for (unsigned int i = 0; i < Mesh->GetNumSubMeshes(); ++i)
         SubMeshInstances[i]->SetFaceOrdering(*this, Mesh->GetSubMesh(i), ordering);
  
     // Faces have been reordered: upload new order to GPU
     UpdateIBO();
  
     // Update attachments (only own meshes for now... others might be displayed both attached and non-attached...)
     // still not optimal.
     for (AttachedMeshIter iter = AttachChildren.begin(); iter != AttachChildren.end(); ++iter)
         if ((*iter)->OwnChild)
             (*iter)->Child->SetFaceOrdering(ordering);
 #endif
 }

References AttachChildren, StdMesh::GetNumSubMeshes(), StdMesh::GetSubMesh(), Mesh, SubMeshInstances, and UpdateIBO().

Referenced by C4EditCursor::DrawObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFaceOrderingForClrModulation()

void StdMeshInstance::SetFaceOrderingForClrModulation ( uint32_t clrmod )

Definition at line 1135 of file StdMesh.cpp.

 {
 #ifndef USE_CONSOLE
     for (unsigned int i = 0; i < Mesh->GetNumSubMeshes(); ++i)
         SubMeshInstances[i]->SetFaceOrderingForClrModulation(*this, Mesh->GetSubMesh(i), clrmod);
  
     // Faces have been reordered: upload new order to GPU
     UpdateIBO();
  
     // Update attachments (only own meshes for now... others might be displayed both attached and non-attached...)
     // still not optimal.
     for (AttachedMeshIter iter = AttachChildren.begin(); iter != AttachChildren.end(); ++iter)
         if ((*iter)->OwnChild)
             (*iter)->Child->SetFaceOrderingForClrModulation(clrmod);
 #endif
 }

References AttachChildren, StdMesh::GetNumSubMeshes(), StdMesh::GetSubMesh(), Mesh, SubMeshInstances, and UpdateIBO().

Referenced by C4Object::CompileFunc(), C4GraphicsOverlay::Draw(), C4EditCursor::DrawObject(), C4GraphicsOverlay::DrawPicture(), C4Object::Init(), and C4Object::UpdateGraphics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMaterial()

void StdMeshInstance::SetMaterial	(	size_t	i,
		const StdMeshMaterial &	material
	)

Definition at line 1437 of file StdMesh.cpp.

 {
     assert(i < SubMeshInstances.size());
     SubMeshInstances[i]->SetMaterial(material);
 #ifndef USE_CONSOLE
     std::stable_sort(SubMeshInstancesOrdered.begin(), SubMeshInstancesOrdered.end(), StdMeshSubMeshInstanceVisibilityCmpPred());
 #endif
 }

References SubMeshInstances, and SubMeshInstancesOrdered.

◆ StopAnimation()

void StdMeshInstance::StopAnimation ( AnimationNode * node )

Definition at line 1190 of file StdMesh.cpp.

 {
     ClearAnimationListRecursively(AnimationNodes, node);
  
     AnimationNode* parent = node->Parent;
     if (parent == nullptr)
     {
         AnimationNodeList::iterator iter = GetStackIterForSlot(node->Slot, false);
         assert(iter != AnimationStack.end() && *iter == node);
         AnimationStack.erase(iter);
         delete node;
     }
     else
     {
         assert(parent->Type == AnimationNode::LinearInterpolationNode);
  
         // Remove parent interpolation node and re-link
         AnimationNode* other_child;
         if (parent->LinearInterpolation.ChildLeft == node)
         {
             other_child = parent->LinearInterpolation.ChildRight;
             parent->LinearInterpolation.ChildRight = nullptr;
         }
         else
         {
             other_child = parent->LinearInterpolation.ChildLeft;
             parent->LinearInterpolation.ChildLeft = nullptr;
         }
  
         if (parent->Parent)
         {
             assert(parent->Parent->Type == AnimationNode::LinearInterpolationNode);
             if (parent->Parent->LinearInterpolation.ChildLeft == parent)
                 parent->Parent->LinearInterpolation.ChildLeft = other_child;
             else
                 parent->Parent->LinearInterpolation.ChildRight = other_child;
             other_child->Parent = parent->Parent;
         }
         else
         {
             AnimationNodeList::iterator iter = GetStackIterForSlot(node->Slot, false);
             assert(iter != AnimationStack.end() && *iter == parent);
             *iter = other_child;
  
             other_child->Parent = nullptr;
         }
  
         AnimationNodes[parent->Number] = nullptr;
         // Recursively deletes parent and its descendants
         delete parent;
     }
  
     while (!AnimationNodes.empty() && AnimationNodes.back() == nullptr)
         AnimationNodes.erase(AnimationNodes.end()-1);
     SetBoneTransformsDirty(true);
 }

References AnimationNodes, AnimationStack, GetStackIterForSlot(), StdMeshInstanceAnimationNode::LinearInterpolationNode, StdMeshInstanceAnimationNode::Number, StdMeshInstanceAnimationNode::Parent, SetBoneTransformsDirty(), StdMeshInstanceAnimationNode::Slot, and StdMeshInstanceAnimationNode::Type.

Referenced by ExecuteAnimation(), ExecuteAnimationNode(), InsertAnimationNode(), C4Object::SetAction(), StdMeshAnimationUpdate::Update(), StdMeshUpdate::Update(), and ~StdMeshInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateBoneTransforms()

bool StdMeshInstance::UpdateBoneTransforms ( )

Definition at line 1471 of file StdMesh.cpp.

 {
     bool was_dirty = BoneTransformsDirty;
  
     // Nothing changed since last time
     if (BoneTransformsDirty)
     {
         // Compute transformation matrix for each bone.
         for (unsigned int i = 0; i < BoneTransforms.size(); ++i)
         {
             StdMeshTransformation Transformation;
  
             const StdMeshBone& bone = Mesh->GetSkeleton().GetBone(i);
             const StdMeshBone* parent = bone.GetParent();
             assert(!parent || parent->Index < i);
  
             bool have_transform = false;
             for (auto & j : AnimationStack)
             {
                 if (have_transform)
                 {
                     StdMeshTransformation other;
                     if (j->GetBoneTransform(i, other))
                         Transformation = StdMeshTransformation::Nlerp(Transformation, other, 1.0f); // TODO: Allow custom weighing for slot combination
                 }
                 else
                 {
                     have_transform = j->GetBoneTransform(i, Transformation);
                 }
             }
  
             if (!have_transform)
             {
                 if (parent)
                     BoneTransforms[i] = BoneTransforms[parent->Index];
                 else
                     BoneTransforms[i] = StdMeshMatrix::Identity();
             }
             else
             {
                 BoneTransforms[i] = StdMeshMatrix::Transform(bone.Transformation * Transformation * bone.InverseTransformation);
                 if (parent) BoneTransforms[i] = BoneTransforms[parent->Index] * BoneTransforms[i];
             }
         }
     }
  
     // Update attachment's attach transformations. Note this is done recursively.
     for (auto attach : AttachChildren)
     {
         const bool ChildBoneTransformsDirty = attach->Child->BoneTransformsDirty;
         attach->Child->UpdateBoneTransforms();
  
         if (BoneTransformsDirty || ChildBoneTransformsDirty || attach->FinalTransformDirty)
         {
             was_dirty = true;
  
             // Compute matrix to change the coordinate system to the one of the attached bone:
             // The idea is that a vertex at the child bone's position transforms to the parent bone's position.
             // Therefore (read from right to left) we first apply the inverse of the child bone transformation,
             // then an optional scaling matrix, and finally the parent bone transformation
  
             // TODO: we can cache the three matrices in the middle since they don't change over time,
             // reducing this to two matrix multiplications instead of four each frame.
             // Might even be worth to compute the complete transformation directly when rendering then
             // (saves per-instance memory, but requires recomputation if the animation does not change).
             // TODO: We might also be able to cache child inverse, and only recomupte it if
             // child bone transforms are dirty (saves matrix inversion for unanimated attach children).
             attach->FinalTrans = GetBoneTransform(attach->ParentBone)
                 * StdMeshMatrix::Transform(Mesh->GetSkeleton().GetBone(attach->ParentBone).Transformation)
                 * attach->AttachTrans
                 * StdMeshMatrix::Transform(attach->Child->Mesh->GetSkeleton().GetBone(attach->ChildBone).InverseTransformation)
                 * StdMeshMatrix::Inverse(attach->Child->GetBoneTransform(attach->ChildBone));
  
             attach->FinalTransformDirty = false;
         }
     }
  
     SetBoneTransformsDirty(false);
     return was_dirty;
 }

References AnimationStack, AttachChildren, BoneTransforms, BoneTransformsDirty, StdMeshSkeleton::GetBone(), GetBoneTransform(), StdMeshBone::GetParent(), StdMesh::GetSkeleton(), StdMeshMatrix::Identity(), StdMeshBone::Index, StdMeshMatrix::Inverse(), StdMeshBone::InverseTransformation, Mesh, StdMeshTransformation::Nlerp(), SetBoneTransformsDirty(), StdMeshMatrix::Transform(), and StdMeshBone::Transformation.

Referenced by C4Draw::RenderMesh().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateIBO()

void StdMeshInstance::UpdateIBO ( )

protected

Definition at line 1912 of file StdMesh.cpp.

 {
     // First, find out whether we have fixed face ordering or not
     bool all_submeshes_fixed = true;
     for (StdSubMeshInstance* inst : SubMeshInstances)
     {
         all_submeshes_fixed = (inst->GetFaceOrdering() == StdSubMeshInstance::FO_Fixed);
         if (!all_submeshes_fixed) break;
  
         // If true, submesh is 100% complete
         all_submeshes_fixed = inst->GetNumFaces() == inst->GetSubMesh().GetNumFaces();
         if (!all_submeshes_fixed) break;
     }
  
     // If the face ordering is fixed, then we don't need a custom
     // IBO. This is typically the case for all meshes without transparency
     // and 100% completion.
     if (all_submeshes_fixed)
     {
         if (ibo) glDeleteBuffers(1, &ibo);
         if (vaoid) pGL->FreeVAOID(vaoid);
         ibo = 0; vaoid = 0;
     }
     else
     {
         // We have a custom face ordering, or we render only a subset
         // of our faces. Create a custom IBO and upload the index
         // data.
         if (ibo == 0)
         {
             // This is required, because the IBO binding is part
             // of the VAO state. If we create a new IBO we cannot
             // keep using any old VAO. But we always create and 
             // destroy them together, so we can assert here.
             assert(vaoid == 0);
  
             size_t total_faces = 0;
             for (unsigned int i = 0; i < Mesh->GetNumSubMeshes(); ++i)
                 total_faces += Mesh->GetSubMesh(i).GetNumFaces();
  
             glGenBuffers(1, &ibo);
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
  
             // TODO: Optimize mode. In many cases this is still fairly static.
             glBufferData(GL_ELEMENT_ARRAY_BUFFER, total_faces * 3 * sizeof(GLuint), nullptr, GL_STREAM_DRAW);
         }
         else
         {
             glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
         }
  
         for (StdSubMeshInstance* inst : SubMeshInstances)
         {
             assert(inst->GetNumFaces() <= inst->GetSubMesh().GetNumFaces());
             glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, inst->GetSubMesh().GetOffsetInIBO(), inst->GetNumFaces() * 3 * sizeof(GLuint), &inst->Faces[0]);
         }
  
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  
         if (vaoid == 0)
             vaoid = pGL->GenVAOID();
     }
 }

References StdSubMeshInstance::FO_Fixed, CStdGL::FreeVAOID(), CStdGL::GenVAOID(), StdSubMesh::GetNumFaces(), StdMesh::GetNumSubMeshes(), StdMesh::GetSubMesh(), ibo, Mesh, pGL, SubMeshInstances, and vaoid.

Referenced by ReorderFaces(), SetCompletion(), SetFaceOrdering(), and SetFaceOrderingForClrModulation().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ StdMeshAnimationUpdate

friend class StdMeshAnimationUpdate

friend

Definition at line 396 of file StdMesh.h.

◆ StdMeshMaterialUpdate

friend class StdMeshMaterialUpdate

friend

Definition at line 395 of file StdMesh.h.

◆ StdMeshUpdate

friend class StdMeshUpdate

friend

Definition at line 397 of file StdMesh.h.

Member Data Documentation

◆ AnimationNodes

AnimationNodeList StdMeshInstance::AnimationNodes

protected

Definition at line 651 of file StdMesh.h.

Referenced by ClearPointers(), CompileFunc(), DenumeratePointers(), GetAnimationNodeByNumber(), InsertAnimationNode(), StopAnimation(), and ~StdMeshInstance().

◆ AnimationStack

AnimationNodeList StdMeshInstance::AnimationStack

protected

Definition at line 652 of file StdMesh.h.

Referenced by CompileFunc(), ExecuteAnimation(), GetRootAnimationForSlot(), GetStackIterForSlot(), InsertAnimationNode(), StopAnimation(), StdMeshAnimationUpdate::Update(), StdMeshUpdate::Update(), UpdateBoneTransforms(), and ~StdMeshInstance().

◆ AttachChildren

std::vector<AttachedMesh*> StdMeshInstance::AttachChildren

protected

Definition at line 660 of file StdMesh.h.

Referenced by AttachedMeshesBegin(), AttachedMeshesEnd(), AttachMesh(), AttachMeshImpl(), ClearPointers(), CompileFunc(), DenumeratePointers(), DetachMesh(), ExecuteAnimation(), GetAttachedMeshByNumber(), SetBoneTransformsDirty(), SetFaceOrdering(), SetFaceOrderingForClrModulation(), UpdateBoneTransforms(), and ~StdMeshInstance().

◆ AttachParent

AttachedMesh* StdMeshInstance::AttachParent

protected

Definition at line 661 of file StdMesh.h.

Referenced by AttachMesh(), AttachMeshImpl(), CompileFunc(), GetAttachParent(), GetBoneCount(), GetBoneTransform(), StdMeshUpdate::Update(), and ~StdMeshInstance().

◆ BoneTransforms

std::vector<StdMeshMatrix> StdMeshInstance::BoneTransforms

protected

Definition at line 653 of file StdMesh.h.

Referenced by GetBoneCount(), GetBoneTransform(), StdMeshUpdate::Update(), and UpdateBoneTransforms().

◆ BoneTransformsDirty

bool StdMeshInstance::BoneTransformsDirty

protected

Definition at line 663 of file StdMesh.h.

Referenced by SetBoneTransformsDirty(), StdMeshUpdate::Update(), and UpdateBoneTransforms().

◆ Completion

float StdMeshInstance::Completion

protected

Definition at line 649 of file StdMesh.h.

Referenced by GetCompletion(), and SetCompletion().

◆ ibo

GLuint StdMeshInstance::ibo

protected

Definition at line 670 of file StdMesh.h.

Referenced by GetIBO(), UpdateIBO(), and ~StdMeshInstance().

◆ Mesh

const StdMesh* StdMeshInstance::Mesh

protected

Definition at line 647 of file StdMesh.h.

Referenced by AttachMeshImpl(), CompileFunc(), GetIBO(), GetMesh(), GetSharedVertices(), GetVAOID(), PlayAnimation(), SetCompletion(), SetFaceOrdering(), SetFaceOrderingForClrModulation(), StdMeshInstance(), StdMeshUpdate::Update(), UpdateBoneTransforms(), and UpdateIBO().

◆ SubMeshInstances

std::vector<StdSubMeshInstance*> StdMeshInstance::SubMeshInstances

protected

Definition at line 655 of file StdMesh.h.

Referenced by CompileFunc(), ExecuteAnimation(), GetNumSubMeshes(), GetSubMesh(), ReorderFaces(), SetCompletion(), SetFaceOrdering(), SetFaceOrderingForClrModulation(), SetMaterial(), StdMeshInstance(), StdMeshMaterialUpdate::Update(), StdMeshUpdate::Update(), UpdateIBO(), and ~StdMeshInstance().

◆ SubMeshInstancesOrdered

std::vector<StdSubMeshInstance*> StdMeshInstance::SubMeshInstancesOrdered

protected

Definition at line 656 of file StdMesh.h.

Referenced by CompileFunc(), GetSubMeshOrdered(), SetMaterial(), StdMeshInstance(), and StdMeshUpdate::Update().

◆ vaoid

unsigned int StdMeshInstance::vaoid

protected

Definition at line 671 of file StdMesh.h.

Referenced by GetVAOID(), UpdateIBO(), and ~StdMeshInstance().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ AnimationNode

◆ AnimationNodeList

◆ AttachedMeshIter

◆ AttachedMeshList

◆ FaceOrdering

◆ ValueProvider

Member Enumeration Documentation

◆ AttachMeshFlags

Constructor & Destructor Documentation

◆ StdMeshInstance()

◆ ~StdMeshInstance()

Member Function Documentation

◆ ApplyBoneTransformToVertices()

◆ AttachedMeshesBegin()

◆ AttachedMeshesEnd()

◆ AttachMesh() [1/2]

◆ AttachMesh() [2/2]

◆ AttachMeshImpl()

◆ ClearPointers()

◆ CompileFunc()

◆ DenumeratePointers()

◆ DetachMesh()

◆ ExecuteAnimation()

◆ ExecuteAnimationNode()

◆ GetAnimationNodeByNumber()

◆ GetAttachedMeshByNumber()

◆ GetAttachParent()

◆ GetBoneCount()

◆ GetBoneTransform()

◆ GetCompletion()

◆ GetIBO()

◆ GetMesh()

◆ GetNumSharedVertices()

◆ GetNumSubMeshes()

◆ GetRootAnimationForSlot()

◆ GetSharedVertices()

◆ GetStackIterForSlot()

◆ GetSubMesh() [1/2]

◆ GetSubMesh() [2/2]

◆ GetSubMeshOrdered()

◆ GetVAOID()

◆ InsertAnimationNode()

◆ PlayAnimation() [1/3]

◆ PlayAnimation() [2/3]

◆ PlayAnimation() [3/3]

◆ ReorderFaces()

◆ ScanAttachTree()

◆ SetAnimationBoneTransform()

◆ SetAnimationPosition()

◆ SetAnimationWeight()

◆ SetBoneTransformsDirty()

◆ SetCompletion()

◆ SetFaceOrdering()

◆ SetFaceOrderingForClrModulation()

◆ SetMaterial()

◆ StopAnimation()

◆ UpdateBoneTransforms()

◆ UpdateIBO()

Friends And Related Function Documentation

◆ StdMeshAnimationUpdate

◆ StdMeshMaterialUpdate

◆ StdMeshUpdate

Member Data Documentation

◆ AnimationNodes

◆ AnimationStack

◆ AttachChildren

◆ AttachParent

◆ BoneTransforms

◆ BoneTransformsDirty

◆ Completion