VVGL_Base.hpp

Go to the documentation of this file.

#ifndef VVGL_Base_h
#define VVGL_Base_h

#include "VVGL_Defines.hpp"

#include <vector>
#include <memory>

#include "VVGL_Time.hpp"
#include "VVGL_Range.hpp"
#include "VVGL_StringUtils.hpp"

namespace VVGL
{


using namespace std;


//  some forward declarations used in this header
class GLBuffer;
class GLBufferPool;
class GLTexToTexCopier;
class GLContext;
class GLScene;
struct GLCachedAttrib;
struct GLCachedUni;
class GLTexToCPUCopier;
class GLCPUToTexCopier;
struct Timestamp;


using GLBufferRef = shared_ptr<GLBuffer>;
using GLBufferPoolRef = shared_ptr<GLBufferPool>;
using GLTexToTexCopierRef = shared_ptr<GLTexToTexCopier>;

using GLContextRef = shared_ptr<GLContext>;
using GLSceneRef = shared_ptr<GLScene>;
using GLCachedAttribRef = shared_ptr<GLCachedAttrib>;
using GLCachedUniRef = shared_ptr<GLCachedUni>;
using GLTexToCPUCopierRef = shared_ptr<GLTexToCPUCopier>;
using GLCPUToTexCopierRef = shared_ptr<GLCPUToTexCopier>;




enum GLVersion  {
    GLVersion_Unknown,
    GLVersion_2,
    GLVersion_ES,
    GLVersion_ES2,
    GLVersion_ES3,
    GLVersion_33,
    GLVersion_4
};
inline const string GLVersionToString(const GLVersion & v)  { switch (v) { case GLVersion_Unknown: return string("Unknown"); case GLVersion_2: return string("2"); case GLVersion_ES: return string("ES"); case GLVersion_ES2: return string("ES2"); case GLVersion_ES3: return string("ES3"); case GLVersion_33: return string("3.3"); case GLVersion_4: return string("4"); } return string("err"); }




struct GLColor  {
    float       r = 0.0;
    float       g = 0.0;
    float       b = 0.0;
    float       a = 0.0;
    GLColor() {}
    GLColor(const float & inR, const float & inG, const float & inB, const float & inA) { r=inR;g=inG;b=inB;a=inA; }
    bool operator==(const GLColor & n) const { return (this->r==n.r && this->g==n.g && this->b==n.b && this->a==n.a); }
    bool operator!=(const GLColor & n) const { return !(*this==n); }
};


//  this macro is a crude but effective way of logging GL errors on platforms that don't have dedicated GL debugging utilities
#ifdef GL_DEBUG
#define GLERRLOG { \
    int __ASDFQWERZXCV__=glGetError(); \
    if (__ASDFQWERZXCV__!=0){ \
        std::string     humanReadable("???"); \
        switch(__ASDFQWERZXCV__){ \
        case 0x0: humanReadable=std::string("no error"); break; \
        case 0x500: humanReadable=std::string("invalid enum"); break; \
        case 0x501: humanReadable=std::string("invalid value"); break; \
        case 0x502: humanReadable=std::string("invalid operation"); break; \
        case 0x503: humanReadable=std::string("stack overflow"); break; \
        case 0x504: humanReadable=std::string("stack underflow"); break; \
        case 0x505: humanReadable=std::string("out of memory"); break; \
        case 0x506: humanReadable=std::string("invalid framebuffer"); break; \
        case 0x507: humanReadable=std::string("context lost"); break; \
        case 0x8031: humanReadable=std::string("table too large"); break; \
        default: break; \
        } \
        std::cout<<"\tglGetError() returned "<<__ASDFQWERZXCV__<<" ("<<humanReadable<<") in "<<__LINE__<<" of "<<__FILE__<<endl; \
    } \
}
#else
#define GLERRLOG
#endif


//  this function dumps a 4cc to chars
inline void VVUnpackFourCC_toChar(unsigned long fourCC, char *destCharPtr) { if (destCharPtr==nullptr) return; for (int i=0; i<4; ++i) destCharPtr[i] = (char)((fourCC >> ((3-i)*8)) & 0xFF); }




}   //  namespace VVGL




#if defined(VVGL_SDK_QT)
#include <QThread>
#include <QCoreApplication>
//      this template establishes a function for asynchronously performing a lambda on the passed 
//      object's thread (or the main thread if there's no passed object).
//  
//  usage:
//      perform_async([]() { qDebug() << __PRETTY_FUNCTION__; });
//  
//      perform_async([&]{ o.setObjectName("hello"); }, &o);
//      perform_async(std::bind(&QObject::setObjectName, &o, "hello"), &o);
template <typename FTYPE>
static void perform_async(FTYPE && inFunc, QObject * inObj=qApp)
{
    struct Event : public QEvent
    {
        using Fun = typename std::decay<FTYPE>::type;
        Fun         varFunc;
        Event(Fun && declInFunc) : QEvent(QEvent::None), varFunc(std::move(declInFunc)) {}
        Event(const Fun & declInFunc) : QEvent(QEvent::None), varFunc(declInFunc) {}
        ~Event() { this->varFunc(); }
    };
    QCoreApplication::postEvent(inObj, new Event(std::forward<FTYPE>(inFunc)));
}
#endif




#endif /* VVGL_Base_h */