model.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "ids/id.h"
#include "ids/idallocator.h"
#include "util/stringatom.h"
#include "resources/resourceid.h"
#include "core/rttimacros.h"
#include "memory/rangeallocator.h"
#include "coreanimation/infinitytype.h"
#include <functional>
namespace Models
{
 
class ModelNode;
 
RESOURCE_ID_TYPE(ModelId);
 
enum NodeType
{
    CharacterNodeType,
    TransformNodeType,
    ShaderStateNodeType,
    PrimitiveNodeType,
    ParticleSystemNodeType,
    CharacterSkinNodeType,
 
    NumNodeTypes
};
 
enum NodeBits
{
    NoBits = N_BIT(0),
    HasTransformBit = N_BIT(1),
    HasStateBit = N_BIT(2)
};
__ImplementEnumBitOperators(NodeBits);
 
enum class LoadBits
{
    NoBits = N_BIT(0),
    MeshBit = N_BIT(1),
    AnimBit = N_BIT(2),
    MaterialBit = N_BIT(3)
};
__ImplementEnumBitOperators(LoadBits);
 
struct ModelStreamingData
{
    LoadBits requiredBits;
    LoadBits loadedBits;
};
 
struct NodeInstanceRange
{
    Memory::RangeAllocation allocation;
    SizeT begin, end;
};
 
struct JointMask
{
    Util::StringAtom name;
    Util::FixedArray<float> weights;
};
 
struct Take
{
    struct Clip
    {
        Util::StringAtom name;
        float start, end;
        CoreAnimation::InfinityType::Code preInfinity, postInfinity;
 
        struct Event
        {
            Util::StringAtom name;
            float time;
        };
 
        Util::FixedArray<Event> events;
    };
 
    Util::FixedArray<Clip> clips;
};
 
struct ModelCreateInfo
{
    Util::Array<Models::ModelNode*> nodes;
    Util::FixedArray<JointMask> jointMasks;
    Util::FixedArray<Take> takes;
#if WITH_NEBULA_EDITOR
    Util::Dictionary<Util::StringAtom, Models::ModelNode*> nodeLookup;
#endif
};

const ModelId CreateModel(const ModelCreateInfo& info);
void DestroyModel(const ModelId id);

const Util::Array<Models::ModelNode*>& ModelGetNodes(const ModelId id);
const Math::bbox& ModelGetBoundingBox(const ModelId id);
 
#if WITH_NEBULA_EDITOR
const Util::Dictionary<Util::StringAtom, Models::ModelNode*>& GetModelNodeTable(const ModelId id);
#endif

void ModelSetNodes(const ModelId id, Util::Array<Models::ModelNode*>& nodes);
void ModelSetJointMasks(const ModelId id, const Util::FixedArray<JointMask>& masks);
void ModelSetTakes(const ModelId id, const Util::FixedArray<Take>& takes);
 
#if WITH_NEBULA_EDITOR
void ModelSetLookup(const ModelId id, const Util::Dictionary<Util::StringAtom, Models::ModelNode*>& lookup);
#endif
 
enum
{
    Model_Nodes,
    Model_JointMasks,
    Model_Takes,
#if WITH_NEBULA_EDITOR
    Model_NodeLookup
#endif
};
 
typedef Ids::IdAllocator<
    Util::Array<Models::ModelNode*>,
    Util::FixedArray<JointMask>,
    Util::FixedArray<Take>
#if WITH_NEBULA_EDITOR
    , Util::Dictionary<Util::StringAtom, Models::ModelNode*>
#endif
> ModelAllocator;
extern ModelAllocator modelAllocator;
} // namespace Models