X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fworld%2FEntity.hpp;h=e38e0b449e79bf41eae31c4800a7bc10ad04d6ea;hb=110ef77a019384fccbbf33649955bcc064a6399e;hp=25818c6f3da5666b671666a600ace04a9552e093;hpb=aefc5482b27e3d259b6c9f3f1e4cdd9ef2e6a8d2;p=blank.git diff --git a/src/world/Entity.hpp b/src/world/Entity.hpp index 25818c6..e38e0b4 100644 --- a/src/world/Entity.hpp +++ b/src/world/Entity.hpp @@ -1,11 +1,14 @@ #ifndef BLANK_WORLD_ENTITY_HPP_ #define BLANK_WORLD_ENTITY_HPP_ -#include "Block.hpp" #include "Chunk.hpp" -#include "../model/geometry.hpp" -#include "../model/EntityModel.hpp" +#include "EntityDerivative.hpp" +#include "EntityState.hpp" +#include "Steering.hpp" +#include "../geometry/primitive.hpp" +#include "../model/Instance.hpp" +#include #include #include #include @@ -13,78 +16,169 @@ namespace blank { +class DirectionalLighting; +class EntityController; class Shape; +class World; class Entity { public: Entity() noexcept; + ~Entity() noexcept; - bool HasShape() const noexcept { return shape; } - const Shape *GetShape() const noexcept { return shape; } - void SetShape(const Shape *, const glm::vec3 &color); - void SetShapeless() noexcept; + // note that when copying an entity which owns its controller, the + // original must outlive the copy, otherwise the copy ends up with + // an invalid controller pointer + Entity(const Entity &) noexcept; + Entity &operator =(const Entity &) = delete; + + Steering &GetSteering() noexcept { return steering; } + const Steering &GetSteering() const noexcept { return steering; } + + bool HasController() const noexcept { return ctrl; } + // entity takes over ownership of controller + void SetController(EntityController *c) noexcept; + // entity uses shared controller + void SetController(EntityController &c) noexcept; + void UnsetController() noexcept; + EntityController &GetController() noexcept { return *ctrl; } + const EntityController &GetController() const noexcept { return *ctrl; } + + Instance &GetModel() noexcept { return model; } + const Instance &GetModel() const noexcept { return model; } + + std::uint32_t ID() const noexcept { return id; } + void ID(std::uint32_t i) noexcept { id = i; } const std::string &Name() const noexcept { return name; } void Name(const std::string &n) { name = n; } const AABB &Bounds() const noexcept { return bounds; } - void Bounds(const AABB &b) noexcept { bounds = b; } + // get distance between local origin and farthest vertex + float Radius() const noexcept { return radius; } + void Bounds(const AABB &b) noexcept { bounds = b; radius = b.OriginRadius(); } bool WorldCollidable() const noexcept { return world_collision; } void WorldCollidable(bool b) noexcept { world_collision = b; } - const glm::vec3 &Velocity() const noexcept { return velocity; } - void Velocity(const glm::vec3 &) noexcept; + float MaxVelocity() const noexcept { return max_vel; } + void MaxVelocity(float v) noexcept { max_vel = v; } + float MaxControlForce() const noexcept { return max_force; } + void MaxControlForce(float f) noexcept { max_force = f; } - const Block::Pos &Position() const noexcept { return position; } - void Position(const Chunk::Pos &, const Block::Pos &) noexcept; - void Position(const Block::Pos &) noexcept; - void Move(const glm::vec3 &delta) noexcept; + glm::vec3 ControlForce(const EntityState &) const noexcept; - const Chunk::Pos ChunkCoords() const noexcept { return chunk; } + const glm::vec3 &Velocity() const noexcept { return state.velocity; } + + const ExactLocation::Fine &Position() const noexcept { return state.pos.block; } + void Position(const ExactLocation::Coarse &, const ExactLocation::Fine &) noexcept; + void Position(const ExactLocation::Fine &) noexcept; + + const glm::ivec3 ChunkCoords() const noexcept { return state.pos.chunk; } glm::vec3 AbsolutePosition() const noexcept { - return glm::vec3(chunk * Chunk::Extent()) + position; + return state.AbsolutePosition(); } glm::vec3 AbsoluteDifference(const Entity &other) const noexcept { - return glm::vec3((chunk - other.chunk) * Chunk::Extent()) + position - other.position; + return state.Diff(other.state); } - const glm::quat &AngularVelocity() const noexcept { return angular_velocity; } - void AngularVelocity(const glm::quat &) noexcept; - - const glm::mat4 &Rotation() const noexcept { return rotation; } - void Rotation(const glm::mat4 &) noexcept; - void Rotate(const glm::quat &delta) noexcept; - - glm::mat4 Transform(const Chunk::Pos &chunk_offset) const noexcept; - Ray Aim(const Chunk::Pos &chunk_offset) const noexcept; + /// orientation of local coordinate system + void Orientation(const glm::quat &o) noexcept { state.orient = o; } + const glm::quat &Orientation() const noexcept { return state.orient; } + + /// orientation of head within local coordinate system, in radians + float Pitch() const noexcept { return state.pitch; } + float Yaw() const noexcept { return state.yaw; } + void TurnHead(float delta_pitch, float delta_yaw) noexcept; + void SetHead(float pitch, float yaw) noexcept; + + /// get a transform for this entity's coordinate space + const glm::mat4 &Transform() const noexcept { return model_transform; } + /// get a transform for this entity's coordinate space relative to reference chunk + glm::mat4 Transform(const glm::ivec3 &reference) const noexcept; + /// get a transform for this entity's view space relative to reference chunk + glm::mat4 ViewTransform(const glm::ivec3 &reference) const noexcept; + /// get a ray in entity's face direction originating from center of vision + Ray Aim(const ExactLocation::Coarse &chunk_offset) const noexcept; + + /// true if this entity's position will change (significantly) the next update + bool Moving() const noexcept { return speed > 0.0f; } + /// magnitude of velocity + float Speed() const noexcept { return speed; } + /// normalized velocity or heading if standing still + const glm::vec3 &Heading() const noexcept { return heading; } + + void SetState(const EntityState &s) noexcept { state = s; } + const EntityState &GetState() const noexcept { return state; } + + void Ref() noexcept { ++ref_count; } + void UnRef() noexcept { --ref_count; } + void Kill() noexcept { dead = true; } + bool Referenced() const noexcept { return ref_count > 0; } + bool Dead() const noexcept { return dead; } + bool CanRemove() const noexcept { return dead && ref_count <= 0; } + + void Update(World &, float dt); + + void Render(const glm::mat4 &M, DirectionalLighting &prog) noexcept { + if (model) model.Render(M, prog); + } - void Remove() noexcept { remove = true; } - bool CanRemove() const noexcept { return remove; } +private: + void UpdatePhysics(World &, float dt); + void UpdateTransforms() noexcept; + void UpdateHeading() noexcept; + void UpdateModel(float dt) noexcept; +public: + // temporarily made public so AI can use it until it's smoothed out to be suitable for players, too + void OrientBody(float dt) noexcept; +private: + void OrientHead(float dt) noexcept; - void Update(int dt) noexcept; + EntityDerivative CalculateStep( + World &, + const EntityState &cur, + float dt, + const EntityDerivative &prev + ) const; - void Draw() noexcept; private: - const Shape *shape; - EntityModel model; + Steering steering; + EntityController *ctrl; + Instance model; + std::uint32_t id; std::string name; AABB bounds; - - glm::vec3 velocity; - Block::Pos position; - Chunk::Pos chunk; - - glm::quat angular_velocity; - glm::mat4 rotation; + float radius; + EntityState state; + + /// chunk to model space + glm::mat4 model_transform; + /// model to view space + /// if this entity has no model, the eyes are assumed to + /// be at origin and oriented towards pitch of model space + glm::mat4 view_transform; + float speed; + glm::vec3 heading; + + // TODO: I'd prefer a drag solution + float max_vel; + // TODO: split max_force into (local) axes? + // e.g. players may want to disable vertical thrust under certain + // conditions (e.g. "walking" ^^) + float max_force; + + int ref_count; bool world_collision; - bool remove; + bool dead; + + bool owns_controller; };