docs/html/KartObjectProxy_8hh_source.html

#pragma once


#include "game/kart/KartParam.hh"

#include "game/kart/Status.hh"


#include "game/field/KCollisionTypes.hh"


#include "game/system/KPadController.hh"


#include <egg/core/Allocator.hh>

#include <egg/math/Matrix.hh>


#include <list>

#include <vector>


namespace Kinoko {


namespace Field {


class BoxColUnit;

class ObjectCollisionKart;


} // namespace Field


namespace Render {


class KartModel;


} // namespace Render


namespace Kart {


class CollisionGroup;

struct CollisionData;

class KartAction;

class KartBody;

class KartCollide;

class KartDynamics;

class KartHalfPipe;

class KartJump;

class KartMove;

class KartParam;

struct BSP;

class KartPhysics;

class KartScale;

class KartState;

class KartSub;

class KartSuspension;

class KartSuspensionPhysics;

class KartTire;

class WheelPhysics;


struct KartAccessor {

    KartParam *param;

    KartBody *body;

    Render::KartModel *model;

    KartSub *sub;

    KartMove *move;

    KartAction *action;

    KartCollide *collide;

    Field::ObjectCollisionKart *objectCollisionKart;

    KartState *state;


    std::vector<KartSuspension *, EGG::Allocator<KartSuspension *>> suspensions;

    std::vector<KartTire *, EGG::Allocator<KartTire *>> tires;


    Field::BoxColUnit *boxColUnit;

};


class KartObjectProxy {

    friend class KartObject;


public:

    KartObjectProxy();

    ~KartObjectProxy();


    void setPos(const EGG::Vector3f &pos);

    void setRot(const EGG::Quatf &q);

    void setInertiaScale(const EGG::Vector3f &scale);


    [[nodiscard]] KartAction *action();

    [[nodiscard]] const KartAction *action() const;

    [[nodiscard]] KartBody *body();

    [[nodiscard]] const KartBody *body() const;

    [[nodiscard]] KartCollide *collide();

    [[nodiscard]] const KartCollide *collide() const;

    [[nodiscard]] CollisionGroup *collisionGroup();

    [[nodiscard]] const CollisionGroup *collisionGroup() const;

    [[nodiscard]] KartMove *move();

    [[nodiscard]] const KartMove *move() const;

    [[nodiscard]] KartHalfPipe *halfPipe();

    [[nodiscard]] const KartHalfPipe *halfPipe() const;

    [[nodiscard]] KartScale *kartScale();

    [[nodiscard]] const KartScale *kartScale() const;

    [[nodiscard]] KartJump *jump();

    [[nodiscard]] const KartJump *jump() const;

    [[nodiscard]] KartParam *param();

    [[nodiscard]] const KartParam *param() const;

    [[nodiscard]] const BSP &bsp() const;

    [[nodiscard]] KartPhysics *physics();

    [[nodiscard]] const KartPhysics *physics() const;

    [[nodiscard]] KartDynamics *dynamics();

    [[nodiscard]] const KartDynamics *dynamics() const;

    [[nodiscard]] KartState *state();

    [[nodiscard]] const KartState *state() const;

    [[nodiscard]] KartSub *sub();

    [[nodiscard]] const KartSub *sub() const;

    [[nodiscard]] KartSuspension *suspension(u16 suspIdx);

    [[nodiscard]] const KartSuspension *suspension(u16 suspIdx) const;

    [[nodiscard]] KartSuspensionPhysics *suspensionPhysics(u16 suspIdx);

    [[nodiscard]] const KartSuspensionPhysics *suspensionPhysics(u16 suspIdx) const;

    [[nodiscard]] KartTire *tire(u16 tireIdx);

    [[nodiscard]] const KartTire *tire(u16 tireIdx) const;

    [[nodiscard]] WheelPhysics *tirePhysics(u16 tireIdx);

    [[nodiscard]] const WheelPhysics *tirePhysics(u16 tireIdx) const;

    [[nodiscard]] CollisionData &collisionData();

    [[nodiscard]] const CollisionData &collisionData() const;

    [[nodiscard]] CollisionData &collisionData(u16 tireIdx);

    [[nodiscard]] const CollisionData &collisionData(u16 tireIdx) const;

    [[nodiscard]] const System::KPad *inputs() const;

    [[nodiscard]] Render::KartModel *model();

    [[nodiscard]] const Render::KartModel *model() const;

    [[nodiscard]] Field::ObjectCollisionKart *objectCollisionKart();

    [[nodiscard]] const Field::ObjectCollisionKart *objectCollisionKart() const;

    [[nodiscard]] Field::BoxColUnit *boxColUnit();

    [[nodiscard]] const Field::BoxColUnit *boxColUnit() const;


    [[nodiscard]] const EGG::Vector3f &scale() const;

    [[nodiscard]] const EGG::Matrix34f &pose() const;

    [[nodiscard]] EGG::Vector3f bodyFront() const;

    [[nodiscard]] EGG::Vector3f bodyForward() const;

    [[nodiscard]] EGG::Vector3f bodyUp() const;


    [[nodiscard]] const EGG::Vector3f &componentXAxis() const;

    [[nodiscard]] const EGG::Vector3f &componentYAxis() const;

    [[nodiscard]] const EGG::Vector3f &componentZAxis() const;


    [[nodiscard]] const EGG::Vector3f &pos() const;

    [[nodiscard]] const EGG::Vector3f &prevPos() const;

    [[nodiscard]] const EGG::Quatf &fullRot() const;

    [[nodiscard]] const EGG::Vector3f &extVel() const;

    [[nodiscard]] const EGG::Vector3f &intVel() const;

    [[nodiscard]] const EGG::Vector3f &velocity() const;

    [[nodiscard]] f32 speed() const;

    [[nodiscard]] f32 acceleration() const;

    [[nodiscard]] f32 softSpeedLimit() const;

    [[nodiscard]] const EGG::Quatf &mainRot() const;

    [[nodiscard]] const EGG::Vector3f &angVel2() const;

    [[nodiscard]] bool isBike() const;

    [[nodiscard]] u16 suspCount() const;

    [[nodiscard]] u16 tireCount() const;

    [[nodiscard]] bool hasFloorCollision(const WheelPhysics *wheelPhysics) const;

    [[nodiscard]] std::pair<EGG::Vector3f, EGG::Vector3f> getCannonPosRot();

    [[nodiscard]] f32 speedRatio() const;

    [[nodiscard]] f32 speedRatioCapped() const;

    [[nodiscard]] bool isInRespawn() const;

    [[nodiscard]] Field::KCLTypeMask wallKclType() const;

    [[nodiscard]] u32 wallKclVariant() const;

    [[nodiscard]] Status &status();

    [[nodiscard]] const Status &status() const;

    [[nodiscard]] const EGG::Vector3f &wheelPos(u16 idx) const;

    [[nodiscard]] const EGG::Vector3f &wheelEdgePos(u16 idx) const;

    [[nodiscard]] f32 cameraDistY() const;

    [[nodiscard]] s32 hopStickX() const;

    [[nodiscard]] KartParam::Stats::DriftType vehicleType() const;


    [[nodiscard]] static std::list<KartObjectProxy *, EGG::Allocator<KartObjectProxy *>> &

    proxyList() {

        return s_proxyList;

    }


protected:

    void apply(size_t idx);


private:

    static void ApplyAll(const KartAccessor *pointers);


    const KartAccessor *m_accessor;


    static std::list<KartObjectProxy *, EGG::Allocator<KartObjectProxy *>>

            s_proxyList;

};


} // namespace Kart


} // namespace Kinoko

KCollisionTypes.hh

Kinoko::EGG::Matrix34f
A 3 x 4 matrix.
Definition Matrix.hh:10

Kinoko::Field::ObjectCollisionKart
Relates a KartObject with its convex hull representation.
Definition ObjectCollisionKart.hh:16

Kinoko::Kart::CollisionGroup
Houses hitbox and collision info for an object (body or wheel).
Definition CollisionGroup.hh:122

Kinoko::Kart::KartAction
Definition KartAction.hh:26

Kinoko::Kart::KartBody
Definition KartBody.hh:9

Kinoko::Kart::KartCollide
Manages body+wheel collision and its influence on position/velocity/etc.
Definition KartCollide.hh:49

Kinoko::Kart::KartDynamics
State management for most components of a kart's physics.
Definition KartDynamics.hh:12

Kinoko::Kart::KartHalfPipe
Handles the physics and boosts associated with zippers.
Definition KartHalfPipe.hh:11

Kinoko::Kart::KartJump
Manages trick inputs and state.
Definition KartJump.hh:30

Kinoko::Kart::KartMove
Responsible for reacting to player inputs and moving the kart.
Definition KartMove.hh:19

Kinoko::Kart::KartObjectProxy::bodyUp
EGG::Vector3f bodyUp() const
Returns the second column of the rotation matrix, which is the "up" direction.
Definition KartObjectProxy.cc:295

Kinoko::Kart::KartObjectProxy::bodyForward
EGG::Vector3f bodyForward() const
Returns the first column of the rotation matrix, which is the "right" direction.
Definition KartObjectProxy.cc:288

Kinoko::Kart::KartObjectProxy::bodyFront
EGG::Vector3f bodyFront() const
Returns the third column of the rotation matrix, which is the facing vector.
Definition KartObjectProxy.cc:281

Kinoko::Kart::KartObjectProxy::s_proxyList
static std::list< KartObjectProxy *, EGG::Allocator< KartObjectProxy * > > s_proxyList
List of all KartObjectProxy children.
Definition KartObjectProxy.hh:188

Kinoko::Kart::KartObjectProxy::ApplyAll
static void ApplyAll(const KartAccessor *pointers)
For all proxies in the static list, synchronizes all pointers to the KartAccessor.
Definition KartObjectProxy.cc:468

Kinoko::Kart::KartParam
Houses stats regarding a given character/vehicle combo.
Definition KartParam.hh:51

Kinoko::Kart::KartPhysics
Manages the lifecycle of KartDynamics, handles moving floors and trick rotation.
Definition KartPhysics.hh:13

Kinoko::Kart::KartScale
Mainly responsible for calculating scaling for the squish/unsquish animation.
Definition KartScale.hh:9

Kinoko::Kart::KartState
Houses various flags and other variables to preserve the kart's state.
Definition KartState.hh:13

Kinoko::Kart::KartSub
Hosts a few classes and the high level per-frame calc functions.
Definition KartSub.hh:11

Kinoko::Kart::KartSuspensionPhysics
Physics for a single wheel's suspension.
Definition KartSuspensionPhysics.hh:114

Kinoko::Kart::KartSuspension
Doesn't do much besides hold a pointer to KartSuspensionPhysics.
Definition KartSuspension.hh:9

Kinoko::Kart::KartTire
A holder for a wheel's physics data.
Definition KartTire.hh:9

Kinoko::Kart::WheelPhysics
Manages wheel physics and collision checks.
Definition KartSuspensionPhysics.hh:13

Kinoko::Render::KartModel
Included in Kinoko because it mysteriously sets an angle member variable in KartBody.
Definition KartModel.hh:9

Kinoko::System::KPad
Definition KPadController.hh:311

Kinoko::Field
Pertains to collision.
Definition BoxColManager.cc:10

Kinoko::Kart
Pertains to kart-related functionality.
Definition BoxColManager.hh:14

Kinoko::Render
Pertains to rendering the kart model.
Definition KartObjectProxy.hh:25

Kinoko::EGG::Quatf
A quaternion, used to represent 3D rotation.
Definition Quat.hh:12

Kinoko::EGG::Vector3f
A 3D float vector.
Definition Vector.hh:107

Kinoko::Field::BoxColUnit
A representation of the boundaries of an entity that has dynamic collision.
Definition BoxColManager.hh:40

Kinoko::Kart::BSP
Houses hitbox and wheel positions, radii, and suspension info.
Definition KartParam.hh:8

Kinoko::Kart::CollisionData
Information about the current collision and its properties.
Definition CollisionGroup.hh:17

Kinoko::Kart::KartAccessor
Shared between classes who inherit KartObjectProxy so they can access one another.
Definition KartObjectProxy.hh:54

Kinoko::Kart::KartParam::Stats::DriftType
DriftType
The type of drift (inside/outside).
Definition KartParam.hh:89