mirror of
https://github.com/Kiritow/MiniEngine.git
synced 2024-03-22 13:11:22 +08:00
425 lines
7.2 KiB
C++
425 lines
7.2 KiB
C++
#pragma once
|
|
#include <SDL2/SDL.h>
|
|
#undef main
|
|
#include <SDL2/SDL_image.h>
|
|
#include <SDL2/SDL_ttf.h>
|
|
#include <SDL2/SDL_mixer.h>
|
|
|
|
#include <memory>
|
|
|
|
namespace MiniEngine
|
|
{
|
|
using namespace std;
|
|
|
|
|
|
class Rect
|
|
{
|
|
public:
|
|
int x, y, w, h;
|
|
Rect(int X, int Y, int W, int H)
|
|
{
|
|
x = X;y = Y;w = W;h = H;
|
|
}
|
|
Rect()
|
|
{
|
|
x = y = w = h = 0;
|
|
}
|
|
SDL_Rect toSDLRect()
|
|
{
|
|
SDL_Rect r;
|
|
r.x = x;r.y = y;r.w = w;r.h = h;
|
|
return r;
|
|
}
|
|
};
|
|
|
|
class Point
|
|
{
|
|
public:
|
|
int x,y;
|
|
Point(int X,int Y)
|
|
{
|
|
x=X;y=Y;
|
|
}
|
|
Point()
|
|
{
|
|
x=y=0;
|
|
}
|
|
SDL_Point toSDLPoint()
|
|
{
|
|
SDL_Point p;
|
|
p.x=x;
|
|
p.y=y;
|
|
return p;
|
|
}
|
|
bool inRect(Rect rect)
|
|
{
|
|
auto p=toSDLPoint();
|
|
auto r=rect.toSDLRect();
|
|
return SDL_PointInRect(&p,&r);
|
|
}
|
|
};
|
|
|
|
class RGBA
|
|
{
|
|
public:
|
|
int r, g, b, a;
|
|
RGBA(int R, int G, int B, int A)
|
|
{
|
|
r = R;g = G;b = B;a = A;
|
|
}
|
|
RGBA()
|
|
{
|
|
r = g = b = a = 0;
|
|
}
|
|
SDL_Color toSDLColor()
|
|
{
|
|
SDL_Color c;
|
|
c.r = r;c.g = g;c.b = b;c.a = a;
|
|
return c;
|
|
}
|
|
};
|
|
|
|
class NonCopyable
|
|
{
|
|
protected:
|
|
NonCopyable() = default;
|
|
~NonCopyable() = default;
|
|
NonCopyable(const NonCopyable&) = delete;
|
|
NonCopyable& operator = (const NonCopyable&) = delete;
|
|
};
|
|
|
|
class Window;
|
|
class Renderer;
|
|
|
|
class ErrorViewer : public exception
|
|
{
|
|
public:
|
|
void fetch()
|
|
{
|
|
str = SDL_GetError();
|
|
}
|
|
string getError()
|
|
{
|
|
return str;
|
|
}
|
|
const char* what() const throw() override
|
|
{
|
|
return str.c_str();
|
|
}
|
|
private:
|
|
string str;
|
|
};
|
|
|
|
class Surface
|
|
{
|
|
public:
|
|
~Surface()
|
|
{
|
|
|
|
}
|
|
protected:
|
|
Surface() = default;
|
|
private:
|
|
shared_ptr<SDL_Surface> surf;
|
|
friend class Renderer;
|
|
friend class Font;
|
|
};
|
|
|
|
class Texture
|
|
{
|
|
public:
|
|
~Texture()
|
|
{
|
|
|
|
}
|
|
Rect getSize()
|
|
{
|
|
return rect;
|
|
}
|
|
int getw()
|
|
{
|
|
return rect.w;
|
|
}
|
|
int geth()
|
|
{
|
|
return rect.h;
|
|
}
|
|
protected:
|
|
Texture()
|
|
{
|
|
|
|
}
|
|
void updateInfo()
|
|
{
|
|
SDL_QueryTexture(text.get(), NULL, NULL, &rect.w, &rect.h);
|
|
rect.x = rect.y = 0;
|
|
}
|
|
private:
|
|
shared_ptr<SDL_Texture> text;
|
|
Rect rect;
|
|
friend class Renderer;
|
|
};
|
|
|
|
|
|
class Renderer
|
|
{
|
|
public:
|
|
enum class Type { Software=SDL_RENDERER_SOFTWARE, Accelerated=SDL_RENDERER_ACCELERATED,
|
|
PresentSync=SDL_RENDERER_PRESENTVSYNC, TargetTexture=SDL_RENDERER_TARGETTEXTURE };
|
|
|
|
int setColor(RGBA pack)
|
|
{
|
|
return SDL_SetRenderDrawColor(rnd.get(), pack.r, pack.g, pack.b, pack.a);
|
|
}
|
|
|
|
RGBA getColor()
|
|
{
|
|
Uint8 r, g, b, a;
|
|
SDL_GetRenderDrawColor(rnd.get(), &r, &g, &b, &a);
|
|
RGBA pack(r, g, b, a);
|
|
return pack;
|
|
}
|
|
int fillRect(Rect rect)
|
|
{
|
|
auto inr = rect.toSDLRect();
|
|
return SDL_RenderFillRect(rnd.get(), &inr);
|
|
}
|
|
|
|
int drawRect(Rect rect)
|
|
{
|
|
auto inr = rect.toSDLRect();
|
|
return SDL_RenderDrawRect(rnd.get(), &inr);
|
|
}
|
|
int clear()
|
|
{
|
|
return SDL_RenderClear(rnd.get());
|
|
}
|
|
void update()
|
|
{
|
|
SDL_RenderPresent(rnd.get());
|
|
}
|
|
int copy(Texture t, Rect src, Rect dst)
|
|
{
|
|
SDL_Rect s = src.toSDLRect();
|
|
SDL_Rect d = dst.toSDLRect();
|
|
return SDL_RenderCopy(rnd.get(), t.text.get(), &s, &d);
|
|
}
|
|
int copyTo(Texture t, Rect dst)
|
|
{
|
|
SDL_Rect d = dst.toSDLRect();
|
|
return SDL_RenderCopy(rnd.get(), t.text.get(), NULL, &d);
|
|
}
|
|
int copyFill(Texture t, Rect src)
|
|
{
|
|
SDL_Rect s = src.toSDLRect();
|
|
return SDL_RenderCopy(rnd.get(), t.text.get(), &s, NULL);
|
|
}
|
|
int copyFullFill(Texture t)
|
|
{
|
|
return SDL_RenderCopy(rnd.get(), t.text.get(), NULL, NULL);
|
|
}
|
|
Surface loadSurface(string FileName) throw(ErrorViewer)
|
|
{
|
|
Surface surf;
|
|
SDL_Surface* temp = IMG_Load(FileName.c_str());
|
|
if (temp == nullptr)
|
|
{
|
|
ErrorViewer e;
|
|
e.fetch();
|
|
throw e;
|
|
}
|
|
surf.surf.reset(temp, SDL_FreeSurface);
|
|
return surf;
|
|
}
|
|
Texture render(Surface surf) throw (ErrorViewer)
|
|
{
|
|
Texture t;
|
|
SDL_Texture* temp = SDL_CreateTextureFromSurface(rnd.get(), surf.surf.get());
|
|
if (temp == nullptr)
|
|
{
|
|
ErrorViewer e;
|
|
e.fetch();
|
|
throw e;
|
|
}
|
|
t.text.reset(temp, SDL_DestroyTexture);
|
|
t.updateInfo();
|
|
return t;
|
|
}
|
|
Texture loadTexture(string FileName) throw(ErrorViewer)
|
|
{
|
|
Texture t;
|
|
SDL_Texture* temp = IMG_LoadTexture(rnd.get(), FileName.c_str());
|
|
if (temp == nullptr)
|
|
{
|
|
ErrorViewer e;
|
|
e.fetch();
|
|
throw e;
|
|
}
|
|
t.text.reset(temp, SDL_DestroyTexture);
|
|
t.updateInfo();
|
|
return t;
|
|
}
|
|
|
|
protected:
|
|
Renderer()
|
|
{
|
|
/// This function is called by Window ONLY.
|
|
}
|
|
private:
|
|
shared_ptr<SDL_Renderer> rnd;
|
|
friend class Window;
|
|
};
|
|
|
|
class Window
|
|
{
|
|
public:
|
|
Window(string Title, int Width, int Height) throw(ErrorViewer)
|
|
{
|
|
SDL_Window* temp = SDL_CreateWindow(Title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, Width, Height, SDL_WINDOW_SHOWN);
|
|
if (temp == NULL)
|
|
{
|
|
ErrorViewer e;
|
|
e.fetch();
|
|
throw e;
|
|
}
|
|
wnd.reset(temp, SDL_DestroyWindow);
|
|
setRenderer(Renderer::Type::Accelerated,Renderer::Type::TargetTexture);
|
|
}
|
|
Renderer getRenderer() const
|
|
{
|
|
return winrnd;
|
|
}
|
|
|
|
/// TODO: Unfinished.
|
|
void setRenderer(Renderer::Type a,Renderer::Type b)
|
|
{
|
|
_setRenderer_Real(static_cast<int>(a)|static_cast<int>(b));
|
|
}
|
|
|
|
Rect getSize()
|
|
{
|
|
int w, h;
|
|
SDL_GetWindowSize(wnd.get(), &w, &h);
|
|
Rect rect(0, 0, w, h);
|
|
return rect;
|
|
}
|
|
void setSize(Rect sizeRect)
|
|
{
|
|
setSize(sizeRect.w, sizeRect.h);
|
|
}
|
|
void setSize(int w, int h)
|
|
{
|
|
SDL_SetWindowSize(wnd.get(),w,h);
|
|
}
|
|
private:
|
|
void _setRenderer_Real(Uint32 flags)
|
|
{
|
|
winrnd.rnd.reset(SDL_CreateRenderer(wnd.get(), -1, flags),SDL_DestroyRenderer);
|
|
}
|
|
shared_ptr<SDL_Window> wnd;
|
|
Renderer winrnd;
|
|
};
|
|
|
|
class Font
|
|
{
|
|
public:
|
|
Font()
|
|
{
|
|
|
|
}
|
|
Font(string FontFileName, int size) throw(ErrorViewer)
|
|
{
|
|
if (use(FontFileName, size) != 0)
|
|
{
|
|
ErrorViewer e;
|
|
e.fetch();
|
|
throw e;
|
|
}
|
|
}
|
|
int use(string FontFileName, int size)
|
|
{
|
|
TTF_Font* temp = TTF_OpenFont(FontFileName.c_str(), size);
|
|
if (temp == NULL) return -1;
|
|
font.reset(temp, TTF_CloseFont);
|
|
return 0;
|
|
}
|
|
Texture renderText(Renderer rnd, string Text, RGBA fg)
|
|
{
|
|
Surface surf;
|
|
surf.surf.reset(TTF_RenderText_Blended(font.get(), Text.c_str(), fg.toSDLColor()));
|
|
Texture t = rnd.render(surf);
|
|
return t;
|
|
}
|
|
|
|
Texture renderUTF8(Renderer rnd, string Text, RGBA fg)
|
|
{
|
|
Surface surf;
|
|
surf.surf.reset(TTF_RenderUTF8_Blended(font.get(), Text.c_str(), fg.toSDLColor()));
|
|
Texture t = rnd.render(surf);
|
|
return t;
|
|
}
|
|
private:
|
|
shared_ptr<TTF_Font> font;
|
|
};
|
|
|
|
class SDLSystem
|
|
{
|
|
public:
|
|
static int SDLInit()
|
|
{
|
|
return SDL_Init(SDL_INIT_EVERYTHING);
|
|
}
|
|
static void SDLQuit()
|
|
{
|
|
SDL_Quit();
|
|
}
|
|
static int IMGInit()
|
|
{
|
|
return IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG);
|
|
}
|
|
static void IMGQuit()
|
|
{
|
|
IMG_Quit();
|
|
}
|
|
static int TTFInit()
|
|
{
|
|
return TTF_Init();
|
|
}
|
|
static void TTFQuit()
|
|
{
|
|
TTF_Quit();
|
|
}
|
|
static int MixInit()
|
|
{
|
|
return Mix_Init(MIX_INIT_MP3);
|
|
}
|
|
static void MixQuit()
|
|
{
|
|
Mix_Quit();
|
|
}
|
|
|
|
static void Init()
|
|
{
|
|
SDLInit();
|
|
IMGInit();
|
|
TTFInit();
|
|
MixInit();
|
|
}
|
|
static void Quit()
|
|
{
|
|
MixQuit();
|
|
TTFQuit();
|
|
IMGQuit();
|
|
SDLQuit();
|
|
}
|
|
|
|
static void delay(int ms)
|
|
{
|
|
SDL_Delay(ms);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
}/// End of namespace MiniEngine
|