EffekseerRendererGL.h

Go to the documentation of this file.

#ifndef __EFFEKSEERRENDERER_GL_BASE_PRE_H__
#define __EFFEKSEERRENDERER_GL_BASE_PRE_H__

#include <Effekseer.h>
#include <vector>

#if __EFFEKSEER_RENDERER_GLES2_ONLY__
#else

#ifdef _WIN32
#include <Windows.h>
#endif

#endif // #if __EFFEKSEER_RENDERER_GLES2_ONLY__

#if defined(__EFFEKSEER_RENDERER_GLES2__)

#if defined(__APPLE__)
#include <OpenGLES/ES2/gl.h>
#include <OpenGLES/ES2/glext.h>
#else
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#endif

#elif defined(__EFFEKSEER_RENDERER_GLES3__)

#if defined(__APPLE__)
#include <OpenGLES/ES3/gl.h>
#else
#define GL_GLEXT_PROTOTYPES
#include <GLES3/gl3.h>
#endif

#elif defined(__EFFEKSEER_RENDERER_GL2__)

#if _WIN32
#include <GL/gl.h>
#elif defined(__APPLE__)
#define GL_SILENCE_DEPRECATION
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif

#else

#if _WIN32
#include <GL/gl.h>
#elif defined(__APPLE__)
#define GL_SILENCE_DEPRECATION
#include <OpenGL/gl3.h>
#else
#define GL_GLEXT_PROTOTYPES
#include <GL/gl.h>
#endif

#endif

#if __EFFEKSEER_RENDERER_GLES2_ONLY__
#else

#if _WIN32
#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "opengl32.lib")
#endif

#endif // #if __EFFEKSEER_RENDERER_GLES2_ONLY__

namespace EffekseerRendererGL
{

class Renderer;

enum class OpenGLDeviceType
{
        OpenGL2,
        OpenGL3,
        OpenGLES2,
        OpenGLES3,
        Emscripten,
};

} // namespace EffekseerRendererGL

#endif // __EFFEKSEERRENDERER_GL_BASE_PRE_H__

#ifndef __EFFEKSEERRENDERER_GL_DEVICEOBJECT_COLLECTION_H__
#define __EFFEKSEERRENDERER_GL_DEVICEOBJECT_COLLECTION_H__

#include <set>
#include <Effekseer.h>

namespace EffekseerRendererGL
{

class DeviceObject;

class DeviceObjectCollection : public ::Effekseer::ReferenceObject
{
        friend class DeviceObject;

private:
        std::set<DeviceObject*> deviceObjects_;

        void Register(DeviceObject* device);

        void Unregister(DeviceObject* device);

public:
        DeviceObjectCollection() = default;

        ~DeviceObjectCollection() = default;

        void OnLostDevice();

        void OnResetDevice();
};

} // namespace EffekseerRendererGL

#endif // __EFFEKSEERRENDERER_GL_DEVICEOBJECT_H__
#ifndef __EFFEKSEERRENDERER_RENDERER_H__
#define __EFFEKSEERRENDERER_RENDERER_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------
#include <Effekseer.h>

//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------
namespace EffekseerRenderer
{
//-----------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------

class DistortingCallback
{
public:
        DistortingCallback() {}
        virtual ~DistortingCallback() {}

        virtual bool OnDistorting() { return false; }
};

enum class UVStyle
{
        Normal,
        VerticalFlipped,
};

enum class ProxyTextureType
{
        White,
        Normal,
};

class GraphicsDevice : public ::Effekseer::IReference
{
public:
        GraphicsDevice() = default;
        virtual ~GraphicsDevice() = default;
};      
        
class CommandList : public ::Effekseer::IReference
{
public:
        CommandList() = default;
        virtual ~CommandList() = default;
};

class SingleFrameMemoryPool : public ::Effekseer::IReference
{
public:
        SingleFrameMemoryPool() = default;
        virtual ~SingleFrameMemoryPool() = default;

        virtual void NewFrame() {}
};

class Renderer
        : public ::Effekseer::IReference
{
protected:
        Renderer();
        virtual ~Renderer();

        class Impl;
        Impl* impl = nullptr;

public:

        Impl* GetImpl();

        virtual void OnLostDevice() = 0;

        virtual void OnResetDevice() = 0;

        virtual void Destroy() = 0;

        virtual void SetRestorationOfStatesFlag(bool flag) = 0;

        virtual bool BeginRendering() = 0;

        virtual bool EndRendering() = 0;

        virtual ::Effekseer::Vector3D GetLightDirection() const;

        virtual void SetLightDirection(const ::Effekseer::Vector3D& direction);

        virtual const ::Effekseer::Color& GetLightColor() const;

        virtual void SetLightColor(const ::Effekseer::Color& color);

        virtual const ::Effekseer::Color& GetLightAmbientColor() const;

        virtual void SetLightAmbientColor(const ::Effekseer::Color& color);

        virtual int32_t GetSquareMaxCount() const = 0;

        virtual ::Effekseer::Matrix44 GetProjectionMatrix() const;

        virtual void SetProjectionMatrix( const ::Effekseer::Matrix44& mat );

        virtual ::Effekseer::Matrix44 GetCameraMatrix() const;

        virtual void SetCameraMatrix( const ::Effekseer::Matrix44& mat );

        virtual ::Effekseer::Matrix44 GetCameraProjectionMatrix() const;

        virtual ::Effekseer::Vector3D GetCameraFrontDirection() const;

        virtual ::Effekseer::Vector3D GetCameraPosition() const;

        virtual void SetCameraParameter(const ::Effekseer::Vector3D& front, const ::Effekseer::Vector3D& position);

        virtual ::Effekseer::SpriteRenderer* CreateSpriteRenderer() = 0;

        virtual ::Effekseer::RibbonRenderer* CreateRibbonRenderer() = 0;

        virtual ::Effekseer::RingRenderer* CreateRingRenderer() = 0;

        virtual ::Effekseer::ModelRenderer* CreateModelRenderer() = 0;

        virtual ::Effekseer::TrackRenderer* CreateTrackRenderer() = 0;

        virtual ::Effekseer::TextureLoader* CreateTextureLoader( ::Effekseer::FileInterface* fileInterface = NULL ) = 0;

        virtual ::Effekseer::ModelLoader* CreateModelLoader( ::Effekseer::FileInterface* fileInterface = NULL ) = 0;

        virtual ::Effekseer::MaterialLoader* CreateMaterialLoader(::Effekseer::FileInterface* fileInterface = nullptr) = 0;

        virtual void ResetRenderState() = 0;

        virtual DistortingCallback* GetDistortingCallback() = 0;

        virtual void SetDistortingCallback(DistortingCallback* callback) = 0;

        virtual int32_t GetDrawCallCount() const;

        virtual int32_t GetDrawVertexCount() const;

        virtual void ResetDrawCallCount();

        virtual void ResetDrawVertexCount();

        virtual Effekseer::RenderMode GetRenderMode() const;

        virtual void SetRenderMode(Effekseer::RenderMode renderMode);

        virtual UVStyle GetTextureUVStyle() const;

        virtual void SetTextureUVStyle(UVStyle style);

        virtual UVStyle GetBackgroundTextureUVStyle() const;

        virtual void SetBackgroundTextureUVStyle(UVStyle style);

        virtual float GetTime() const;

        virtual void SetTime(float time);

        virtual void SetCommandList(CommandList* commandList) {}

        virtual void SetBackgroundTexture(::Effekseer::TextureData* textureData);

        virtual Effekseer::TextureData* CreateProxyTexture(ProxyTextureType type) { return nullptr; }

        virtual void DeleteProxyTexture(Effekseer::TextureData* data) { }
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEERRENDERER_RENDERER_H__

#ifndef __EFFEKSEERRENDERER_GL_RENDERER_H__
#define __EFFEKSEERRENDERER_GL_RENDERER_H__

//----------------------------------------------------------------------------------
// Include
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
// Lib
//----------------------------------------------------------------------------------

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
namespace EffekseerRendererGL
{

class DeviceObjectCollection;

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------

::Effekseer::TextureLoader* CreateTextureLoader(::Effekseer::FileInterface* fileInterface = nullptr, ::Effekseer::ColorSpaceType colorSpaceType = ::Effekseer::ColorSpaceType::Gamma);

::Effekseer::ModelLoader* CreateModelLoader(::Effekseer::FileInterface* fileInterface = NULL);

class Renderer
        : public ::EffekseerRenderer::Renderer
{
protected:
        Renderer() {}
        virtual ~Renderer() {}

public:
        static Renderer* Create(int32_t squareMaxCount,
                                                        OpenGLDeviceType deviceType = OpenGLDeviceType::OpenGL2,
                                                        DeviceObjectCollection* deviceObjectCollection = nullptr);

        virtual int32_t GetSquareMaxCount() const = 0;

        virtual void SetSquareMaxCount(int32_t count) = 0;

        virtual Effekseer::TextureData* GetBackground() = 0;

        virtual void SetBackground(GLuint background, bool hasMipmap = false) = 0;

        virtual OpenGLDeviceType GetDeviceType() const = 0;

        virtual bool IsVertexArrayObjectSupported() const = 0;
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
class Model
        : public Effekseer::Model
{
private:

public:
        struct InternalModel
        {
                GLuint          VertexBuffer;
                GLuint          IndexBuffer;
                int32_t         VertexCount;
                int32_t         IndexCount;

                std::vector<uint8_t> delayVertexBuffer;
                std::vector<uint8_t> delayIndexBuffer;

                InternalModel();

                virtual ~InternalModel();

                bool TryDelayLoad();
        };


        InternalModel*                          InternalModels = nullptr;
        int32_t                                         ModelCount;


        Model(void* data, int32_t size);
        ~Model();
};

//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
#endif  // __EFFEKSEERRENDERER_GL_RENDERER_H__