BasicTypes.hpp

Go to the documentation of this file.

#pragma once
 
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/gtc/quaternion.hpp>
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
#include <array>
#include <memory>
#include <vector>
 
// If you get an error here, you might need to run ./scripts/generate_assets.sh
#include "../../../assets/generated/GeneratedAnimations.hpp"
 
#pragma region Constants
 
constexpr uint32_t BONES_PER_VERTEX = 4;
constexpr uint32_t MAX_BONES = 50;
 
constexpr glm::vec3 GAMEOBJECT_MIN = glm::vec3(-0.5f, -0.1f, -0.5f);
constexpr glm::vec3 GAMEOBJECT_MAX = glm::vec3(0.5f, 1.f, 0.5f);
 
constexpr glm::vec3 CHARACTER_MIN = glm::vec3(-0.5f, 0.0f, -0.5f);
constexpr glm::vec3 CHARACTER_MAX = glm::vec3(0.5f, 2.0f, 0.5f);
 
constexpr size_t OBJECT_TYPE_COUNT = 4;
 
enum ObjectType : uint32_t
{
    CHARACTER,
    GAMEOBJECT,
    TESTOBJECT,
    AREA,
    UNDEFINED
};
 
std::array<ObjectType, OBJECT_TYPE_COUNT> getObjectTypes();
 
std::array<AnimationType, ANIMATION_TYPE_COUNT> getAnimationTypes();
 
uint32_t getAnimIndex(AnimationType animType);
 
#pragma endregion
 
#pragma region AnimationTypes
// Animation node. The data stored can also represent any kind of transformation.
struct GfxOrientation
{
    glm::vec3 position; 
    glm::quat rotation; 
    glm::vec3 scale;    
 
    glm::mat4 getTransformationMatrix() const;
 
    static GfxOrientation interpolate(GfxOrientation first, GfxOrientation second, float factor);
};
 
struct AnimationNode
{
    double time;                                 
    std::array<GfxOrientation, MAX_BONES> bones; 
};
 
struct Animation
{
    double totalTicks;                         
    double ticksPerSecond;                     
    float duration;                            
    std::vector<AnimationNode> animationNodes; 
};
 
struct CharacterAnimationData
{
    AnimationType currentAnimation;
    double currentTicks;
    std::array<Animation, ANIMATION_TYPE_COUNT> animations;
};
 
struct BoneNode
{
    glm::mat4 boneOffset;           
    int parent;                     
    std::vector<uint32_t> children; 
};
 
struct CharacterData
{
    GfxOrientation characterOrientation;                    
    glm::mat4 inverseGlobalTransformation;                  
    std::array<glm::mat4, MAX_BONES> boneTransformations{}; 
    std::vector<BoneNode> bones;
    CharacterAnimationData animationData;
    void advanceAnimation(float dt);
};
 
#pragma endregion
 
#pragma region GraphicsObjectTypes
 
struct DirectionalLight
{
    alignas(16) glm::vec3 direction; 
    alignas(16) glm::vec3 color;     
    float intensity;                 
};
 
struct PointLight
{
    alignas(16) glm::vec3 position; 
    alignas(16) glm::vec3 color;    
    float intensity;                
};
 
struct PhongMaterial
{
    alignas(16) glm::vec3 ambient;  
    alignas(16) glm::vec3 diffuse;  
    alignas(16) glm::vec3 specular; 
    float shininess;                
    static PhongMaterial getDefaultMaterial();
};
 
struct CameraData
{
    alignas(16) glm::vec3 position;
    alignas(16) glm::vec3 direction;
};
 
struct Hit
{
    int id;
    ObjectType objectType;
    glm::vec3 hitPoint;
    int button; 
};
 
struct ImageData
{
    unsigned char* pixels;
    int width;
    int height;
};
 
struct CharacterVertex
{
    glm::vec3 pos;
    glm::vec3 normal;
    glm::uvec4 boneIDs;
    glm::vec4 boneWeights;
    glm::vec2 texCoord;
};
 
struct Vertex
{
    glm::vec3 pos;
    glm::vec3 normal;
    glm::vec2 texCoord;
};
 
struct SimpleVertex
{
    glm::vec3 pos;
    glm::vec3 color;
};
 
struct AnimationConfig
{
    glm::vec3 animationDirection = glm::vec3(0.f, 0.f, -1.f);
    AnimationType animType;
    float duration;
    bool looping;
 
    bool operator==(const AnimationConfig& other) const
    {
        return animationDirection == other.animationDirection && animType == other.animType && duration == other.duration && looping == other.looping;
    }
    bool operator!=(const AnimationConfig& other) const
    {
        return !(*this == other);
    }
};