OOOGL_Core.hpp

#pragma once
#ifndef KJY_OBJECT_ORIENTED_OPENGL_CORE_HPP_
#define KJY_OBJECT_ORIENTED_OPENGL_CORE_HPP_
#include <glad/glad.h>
#include <memory>
#include <exception>
#include <string>
#include "common.h"

/* OOOGL := Object Oriented OpenGL */
namespace OOOGL{

/* A namespace static flag used as indicator for marking whether or not any
 * OpenGL bindings (such as framebuffer or VAO bindings have been changed
 * indirectly by a function internal to OOOGL) */
enum oglbindstatus : unsigned int {BINDINGS_CLEAN = 0U, BINDINGS_UNCLEAN = 1U, BINDINGS_UNKNOWN = 2U};
static unsigned int binding_purity = BINDINGS_CLEAN;

enum class GpuSyncStatus : unsigned int {GPU_CURRENT = 1, GPU_STALE, GPU_ONLY, GPU_UNINITIALIZED};

/* --- Section 1: Core object oriented types and smart pointers --- */

typedef void (*OglObjectDestroyer)(const GLuint* id);

struct OglNameInterface{
    virtual ~OglNameInterface(){}
    virtual GLuint getName() const = 0;
    operator GLuint() const{return(getName());}
};

class ConstOglName;

class MutableOglName : public OglNameInterface{
 public:
     MutableOglName(OglObjectDestroyer destroyer) : destroyer(destroyer){}
     MutableOglName(GLuint id, OglObjectDestroyer destroyer) : oglID(id),  destroyer(destroyer){}
     ~MutableOglName() {if(destroyer != nullptr) destroyer(&oglID);}
     GLuint* getIdPtr(){return(&oglID);}
     const GLuint* getIdPtr() const {return(&oglID);}
     virtual GLuint getName() const override {return(oglID);}
     inline GLuint getNameDirect() const {return(oglID);}
     const OglObjectDestroyer getDestroyer(){return(destroyer);}

     /* Prematurely delete this OpenGL object from the OpenGL state, but keep the object itself around. */
     virtual void makeZombie() {if(destroyer != nullptr) {destroyer(&oglID);} oglID = 0; _is_zombie_ = true;}
     virtual bool isZombie() const {return(_is_zombie_);}
 protected:
     friend ConstOglName;
     GLuint oglID = 0;
     const OglObjectDestroyer destroyer = nullptr;
     bool _is_zombie_ = false;
};

class ConstOglName : public OglNameInterface{
 public:
     ConstOglName(OglObjectDestroyer destroyer) : destroyer(destroyer) {}
     ConstOglName(GLuint id, OglObjectDestroyer destroyer) : oglID(id), destroyer(destroyer) {}
     ConstOglName(const MutableOglName& othername) : oglID(othername.oglID), destroyer(othername.destroyer) {}
     ~ConstOglName() {if(destroyer != nullptr) destroyer(&oglID);}
     const GLuint* getIdPtr() const {return(&oglID);}
     virtual GLuint getName() const override {return(oglID);}
     inline GLuint getNameDirect() const {return(oglID);}
     const OglObjectDestroyer getDestroyer(){return(destroyer);}
 protected:
     const GLuint oglID = 0;
     const OglObjectDestroyer destroyer = nullptr;
};

/* Marks a class as being worth possessing (aka it will prevent an object from automatic deletion) */
struct PossessibleInteraface{
 virtual bool isPossessible() const = 0;
};

class PersistentOglName : public std::shared_ptr<MutableOglName>, public OglNameInterface, public PossessibleInteraface{
 public:
     PersistentOglName() : std::shared_ptr<MutableOglName>(nullptr){}
     PersistentOglName(OglObjectDestroyer destroyer) : std::shared_ptr<MutableOglName>(std::make_shared<MutableOglName>(destroyer)) {}
     PersistentOglName(GLuint id, OglObjectDestroyer destroyer) : std::shared_ptr<MutableOglName>(std::make_shared<MutableOglName>(id, destroyer)) {}
     virtual ~PersistentOglName() noexcept {}
     GLuint* getIdPtr(){return(get()->getIdPtr());}
     const GLuint* getIdPtr() const {return(get()->getIdPtr());}
     virtual GLuint getName() const override {return(get()->getNameDirect());}
     inline GLuint getNameDirect() const {return(get()->getNameDirect());}
     virtual bool isPossessible() const override {return(true);}
     
     virtual void makeZombie() {get()->makeZombie();}
     virtual bool isZombie() const {return(get() == nullptr || get()->isZombie());}
};

static PersistentOglName _zombie_name;

class ConstPersistentOglName : public std::shared_ptr<ConstOglName>, public OglNameInterface, public PossessibleInteraface {
 public:
     ConstPersistentOglName() : std::shared_ptr<ConstOglName>(nullptr){}
     ConstPersistentOglName(OglObjectDestroyer destroyer) : std::shared_ptr<ConstOglName>(std::make_shared<ConstOglName>(destroyer)) {}
     ConstPersistentOglName(GLuint id, OglObjectDestroyer destroyer) : std::shared_ptr<ConstOglName>(std::make_shared<ConstOglName>(id, destroyer)) {}
     ConstPersistentOglName(const PersistentOglName& other) : std::shared_ptr<ConstOglName>(std::make_shared<ConstOglName>(*other)) {}
     virtual ~ConstPersistentOglName(){}
     const GLuint* getIdPtr()const {return(get()->getIdPtr());}
     virtual GLuint getName() const override {return(get()->getNameDirect());}
     inline GLuint getNameDirect() const {return(get()->getNameDirect());}
     virtual bool isPossessible() const override {return(true);}
};

class OglObject : public PersistentOglName{
 public:
     OglObject(OglObjectDestroyer destroyer) : PersistentOglName(destroyer) {}

 protected:
 
    OglObject(const PersistentOglName& zombie) : PersistentOglName(zombie) {}
};




/* --- Section 2: Interfaces for behaviors, relationships, and interactions with OpenGL objects --- */

template<class... Possessibles> class OglPossessorInterface{};

template<class Possessible, class... Possessibles>
class OglPossessorInterface<Possessible, Possessibles...> : public OglPossessorInterface<Possessibles...>{
    static_assert(std::is_base_of<PossessibleInteraface, Possessible>::value);

 public:

    virtual size_t numPossessed() const = 0;
    virtual void possessObject(Possessible t) = 0;
    virtual bool doesPossessObject(Possessible t) const = 0;
    virtual void dispossessObject(const Possessible& object) = 0;
};

class ObjectTag {
 public:
    virtual const std::string& getTag() const {return(tag);}
    virtual void setTag(const std::string& tag) {this->tag = tag;}
 protected:
    std::string tag;
};


/* --- Section 3: Exceptions and Errors --- */

class BaseGraphicsException : public std::exception{
 public:
    virtual const char* what() const noexcept override{
        return("Base OOOGL graphics exception");
    }
};

class NeedsImplementingException : public BaseGraphicsException{
 public:
    NeedsImplementingException(const std::string& file, const int line, const std::string& tag)
        : file(file), linenum(line), tag(tag),
        _whatstr_("Missing implementation for " + tag + " at " + file + ":" + "line")
        {}
    virtual const char* what() const noexcept override{
        return(_whatstr_.c_str());
    }

 protected:
    const std::string file;
    const int linenum;
    const std::string tag;
    
 private:
    const std::string _whatstr_;
};

class GenericIndexOutOfBoundsException : public BaseGraphicsException{
 public:
    GenericIndexOutOfBoundsException(size_t index, const std::string& note = std::string()) : index(index), _whatstr_("Index out of bounds exception with index '" + std::to_string(index) + "'" + (note.empty() ? "" : " with note: " + note)) {}
    virtual const char* what() const noexcept override{
        return(_whatstr_.c_str());
    }
 protected:
    const size_t index;
    const std::string _whatstr_;
};

} 

#endif