legopathcontroller.h

Go to the documentation of this file.

#ifndef LEGOPATHCONTROLLER_H
#define LEGOPATHCONTROLLER_H
 
#include "decomp.h"
#include "geom/legounkown100db7f4.h"
#include "legopathactor.h"
#include "legopathboundary.h"
#include "legopathstruct.h"
#include "mxstl/stlcompat.h"
 
struct LegoPathCtrlEdge : public LegoUnknown100db7f4 {};
 
struct LegoPathCtrlEdgeCompare {
    MxU32 operator()(const LegoPathCtrlEdge* p_lhs, const LegoPathCtrlEdge* p_rhs) const
    {
        return (COMPARE_POINTER_TYPE) p_lhs < (COMPARE_POINTER_TYPE) p_rhs;
    }
};
 
typedef set<LegoPathCtrlEdge*, LegoPathCtrlEdgeCompare> LegoPathCtrlEdgeSet;
 
class LegoAnimPresenter;
class LegoWorld;
class MxAtomId;
class Vector3;
 
class LegoPathController : public MxCore {
public:
    struct CtrlBoundary {
        CtrlBoundary()
        {
            m_controller = NULL;
            m_boundary = NULL;
        }
 
        LegoPathController* m_controller; 
        LegoPathBoundary* m_boundary;     
    };
 
    struct CtrlEdge {
        CtrlEdge()
        {
            m_controller = NULL;
            m_edge = NULL;
        }
 
        LegoPathController* m_controller;  
        LegoUnknown100db7f4* m_edge;       
    };
 
    LegoPathController();
 
    ~LegoPathController() override { Destroy(); }
 
    MxResult Tickle() override;
 
    const char* ClassName() const override;
 
    MxBool IsA(const char* p_name) const override;
 
    virtual MxResult Create(MxU8* p_data, const Vector3& p_location, const MxAtomId& p_trigger);
 
    virtual void Destroy();
 
    MxResult PlaceActor(
        LegoPathActor* p_actor,
        const char* p_name,
        MxS32 p_src,
        float p_srcScale,
        MxS32 p_dest,
        float p_destScale
    );
 
    MxResult PlaceActor(
        LegoPathActor* p_actor,
        LegoAnimPresenter* p_presenter,
        Vector3& p_position,
        Vector3& p_direction
    );
 
    MxResult PlaceActor(LegoPathActor* p_actor);
 
    MxResult RemoveActor(LegoPathActor* p_actor);
 
    void FUN_100468f0(LegoAnimPresenter* p_presenter);
 
    void FUN_10046930(LegoAnimPresenter* p_presenter);
 
    MxResult FUN_10046b30(LegoPathBoundary*& p_boundaries, MxS32& p_numL);
 
    LegoPathBoundary* GetPathBoundary(const char* p_name);
 
    void Enable(MxBool p_enable);
 
    void FUN_10046bb0(LegoWorld* p_world);
 
    MxResult FUN_10048310(
        LegoPathEdgeContainer* p_grec,
        const Vector3& p_oldPosition,
        const Vector3& p_oldDirection,
        LegoPathBoundary* p_oldBoundary,
        const Vector3& p_newPosition,
        const Vector3& p_newDirection,
        LegoPathBoundary* p_newBoundary,
        LegoU8 p_mask,
        MxFloat* p_param9
    );
 
    MxS32 FUN_1004a240(
        LegoPathEdgeContainer& p_grec,
        Vector3& p_v1,
        Vector3& p_v2,
        float p_f1,
        LegoUnknown100db7f4*& p_edge,
        LegoPathBoundary*& p_boundary
    );
 
    MxResult FUN_1004a380(
        Vector3& p_param1,
        Vector3& p_param2,
        Mx3DPointFloat* p_param3,
        LegoPathBoundary*& p_boundary,
        MxFloat& p_param5
    );
 
    MxBool ActorExists(LegoPathActor* p_actor) { return m_actors.find(p_actor) == m_actors.end() ? FALSE : TRUE; }
 
    static MxResult Init();
 
    static MxResult Reset();
 
    static LegoUnknown100db7f4* GetControlEdgeA(MxS32 p_index) { return g_ctrlEdgesA[p_index].m_edge; }
 
    static LegoPathBoundary* GetControlBoundaryA(MxS32 p_index) { return g_ctrlBoundariesA[p_index].m_boundary; }
 
    static LegoUnknown100db7f4* GetControlEdgeB(MxS32 p_index) { return g_ctrlEdgesB[p_index].m_edge; }
 
    static LegoPathBoundary* GetControlBoundaryB(MxS32 p_index) { return g_ctrlBoundariesB[p_index].m_boundary; }
 
private:
    void FUN_10046970();
 
    MxResult Read(LegoStorage* p_storage);
 
    MxResult ReadStructs(LegoStorage* p_storage);
 
    MxResult ReadEdges(LegoStorage* p_storage);
 
    MxResult ReadBoundaries(LegoStorage* p_storage);
 
    static MxResult ReadVector(LegoStorage* p_storage, Mx3DPointFloat& p_vec);
 
    static MxResult ReadVector(LegoStorage* p_storage, Mx4DPointFloat& p_vec);
 
    static MxU32 IsBetween(MxFloat p_v, MxFloat p_a, MxFloat p_b);
 
    static MxU32 FUN_100c17a0(MxFloat p_v1, MxFloat p_v2, MxFloat p_a, MxFloat p_b);
 
    LegoPathBoundary* m_boundaries; 
    LegoPathCtrlEdge* m_edges;      
    Mx3DPointFloat* m_unk0x10;      
    LegoPathStruct* m_structs;      
    MxU16 m_numL;                   
    MxU16 m_numE;                   
    MxU16 m_numN;                   
    MxU16 m_numT;                   
    LegoPathCtrlEdgeSet m_pfsE;     
    LegoPathActorSet m_actors;      
 
    // Names verified by BETA10
 
    static CtrlBoundary* g_ctrlBoundariesA; 
    static CtrlEdge* g_ctrlEdgesA;          
    static const char* g_unk0x100f42f0[];   
    static const char* g_unk0x100f4330[];   
    static CtrlBoundary* g_ctrlBoundariesB; 
    static CtrlEdge* g_ctrlEdgesB;          
};
 
#endif // LEGOPATHCONTROLLER_H