chronos.hpp

Go to the documentation of this file.

/*
Copyright (c) 2024 Rahul Satish Vadhyar
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/
 
#pragma once
#include "vulkanHeaders.hpp"
#include "commonStructs.hpp"
#include "engine.hpp"
#include "animManager.hpp"
#include "engineStructs.hpp"
 
namespace Chronos {
namespace Manager {
    struct Initializer {
    int WindowWidth = 800;
    int WindowHeight = 600;
    int BackgroundColor[3] = { 0, 0, 0 };
#ifdef ENABLE_EDITOR
    // function pointer for calling the function that will render the editor
    // elements on the screen
    void (*editorAddElements)();
#endif
    };
 
    struct Text {
    float x = 0.0;
    float y = 0.0;
    float rotation = 0.0;
    float scale = 1.0;
    std::string text = "";
    };
 
    struct TextureDetails {
    std::string textureName;
    std::string texturePath;
    int textureNo;
    int width;
    int height;
#ifdef ENABLE_EDITOR
    VkDescriptorSet descriptorSet;
#endif
    };
 
    class Manager {
    public:
    Manager(Initializer initializer);
    GLFWwindow* getWindow();
 
    void drawFrame();
 
    int addText(Chronos::Engine::TextParams params, std::string fontType,
        int fontSize);
 
    int addShape(Chronos::Manager::ShapeParams shapeParams, int texture);
 
    int addShape(Chronos::Manager::ShapeParams shapeParams);
 
    void updateShape(
        int objectNo, Chronos::Manager::ShapeParams shapeParams);
    std::vector<std::pair<int, Chronos::Manager::ShapeParams>>
    getShapeDetails();
    void updateText(int objectNo, Chronos::Engine::TextParams params);
 
    std::vector<std::pair<int, Chronos::Engine::TextParams>>
    getTextDetails();
 
    void removeObject(int objectNo);
 
    int changeBackgroundColor(float r, float g, float b);
 
    int addTexture(std::string texturePath, std::string textureName);
 
    void removeTexture(int textureNo);
 
    std::vector<TextureDetails> getTextureDetails();
 
    void changePresentMode(std::string presentMode)
    {
        engine.setPresentMode(presentMode);
    }
 
    std::vector<std::string> getMSAAModes()
    {
        return engine.getAvailableMSAAModes();
    }
 
    void changeMSAA(std::string mode) { engine.changeMSAA(mode); }
 
    int addRig(int x, int y) { return animManager.addRig(x, y); }
 
    void removeRig(int rigNo) { animManager.removeRig(rigNo); }
 
    void rigAddBone(int rigNo, int parentNo)
    {
        animManager.rigAddBone(rigNo, parentNo);
    }
 
    void rigRemoveBone(int rigNo, int boneNo)
    {
        animManager.rigRemoveBone(rigNo, boneNo);
    }
 
    void rigAddChild(int rigNo, int parentNo, int childNo)
    {
        animManager.rigAddChild(rigNo, parentNo, childNo);
    }
 
    void rigRemoveChild(int rigNo, int parentNo, int childNo)
    {
        animManager.rigRemoveChild(rigNo, parentNo, childNo);
    }
 
    void rigSetRelX(int rigNo, int boneNo, float relX)
    {
        animManager.rigSetRelX(rigNo, boneNo, relX);
    }
 
    void rigSetRelY(int rigNo, int boneNo, float relY)
    {
        animManager.rigSetRelY(rigNo, boneNo, relY);
    }
 
    void rigSetLength(int rigNo, int boneNo, float length)
    {
        animManager.rigSetLength(rigNo, boneNo, length);
    }
 
    void rigSetAngle(int rigNo, int boneNo, float angle)
    {
        animManager.rigSetAngle(rigNo, boneNo, angle);
    }
 
    void rigSetParent(int rigNo, int boneNo, int parentNo)
    {
        animManager.rigSetParent(rigNo, boneNo, parentNo);
    }
 
    float rigGetRelX(int rigNo, int boneNo)
    {
        return animManager.rigGetRelX(rigNo, boneNo);
    }
 
    float rigGetRelY(int rigNo, int boneNo)
    {
        return animManager.rigGetRelY(rigNo, boneNo);
    }
 
    float rigGetLength(int rigNo, int boneNo)
    {
        return animManager.rigGetLength(rigNo, boneNo);
    }
 
    float rigGetAngle(int rigNo, int boneNo)
    {
        return animManager.rigGetAngle(rigNo, boneNo);
    }
 
    float rigGetX(int rigNo, int boneNo)
    {
        return animManager.rigGetX(rigNo, boneNo);
    }
 
    float rigGetY(int rigNo, int boneNo)
    {
        return animManager.rigGetY(rigNo, boneNo);
    }
 
    int rigGetParent(int rigNo, int boneNo)
    {
        return animManager.rigGetParent(rigNo, boneNo);
    }
 
    std::vector<int> rigGetChildren(int rigNo, int boneNo)
    {
        return animManager.rigGetChildren(rigNo, boneNo);
    }
 
    int addKeyframeVariable(std::vector<std::pair<float, float>> keyframes)
    {
        return animManager.addKeyframeVariable(keyframes);
    }
 
    void removeKeyframeVariable(int keyframeNo)
    {
        animManager.removeKeyframeVariable(keyframeNo);
    }
 
    void keyframeSetTime(int keyframeNo, float time)
    {
        animManager.keyframeSetTime(keyframeNo, time);
    }
 
    void keyframeSetKeyframe(int keyframeNo, int keyframe)
    {
        animManager.keyframeSetKeyframe(keyframeNo, keyframe);
    }
 
    int keyframeGetKeyframe(int keyframeNo)
    {
        return animManager.keyframeGetKeyframe(keyframeNo);
    }
 
    std::vector<std::pair<float, float>> getKeyframes(int keyframeNo)
    {
        return animManager.getKeyframes(keyframeNo);
    }
 
    float keyframeGetVariable(int keyframeNo)
    {
        return animManager.keyframeGetVariable(keyframeNo);
    }
 
#ifdef CHRONOS_PROFILING
    float getWaitTime() { return engine.getWaitTime() * 1e-6; }
 
    float getUpdateTime() { return engine.getUpdateTime() * 1e-6; }
 
    float getCpuTime() { return engine.getCpuTime() * 1e-6; }
 
    float getTotalTime() { return engine.getTotalTime() * 1e-6; }
 
    float getPresentTime() { return engine.getPresentTime() * 1e-6; }
#endif
 
    private:
    Chronos::Engine::Engine engine;
 
    Chronos::Animation::AnimationManager animManager;
    };
};
};