mirror of
https://github.com/Kiritow/MiniEngine.git
synced 2024-03-22 13:11:22 +08:00
commit
e87f513857
2420
MiniEngine.cpp
2420
MiniEngine.cpp
File diff suppressed because it is too large
Load Diff
729
MiniEngine.h
729
MiniEngine.h
|
@ -1,739 +1,12 @@
|
|||
#pragma once
|
||||
#include "MiniEngine_Config.h"
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#include "SDLWrapper/IncludeAll.h"
|
||||
|
||||
#define _MINIENGINE_SDL_VERSION_ATLEAST(X,Y,Z) SDL_VERSION_ATLEAST(X,Y,Z)
|
||||
|
||||
namespace MiniEngine
|
||||
{
|
||||
|
||||
class Rect
|
||||
{
|
||||
public:
|
||||
int x, y, w, h;
|
||||
Rect(int X, int Y, int W, int H);
|
||||
Rect(const SDL_Rect&);
|
||||
Rect();
|
||||
SDL_Rect toSDLRect() const;
|
||||
bool isEmpty();
|
||||
bool operator == (const Rect&) const;
|
||||
bool hasIntersection(const Rect&) const;
|
||||
Rect getIntersection(const Rect&) const;
|
||||
Rect getUnion(const Rect&) const;
|
||||
};
|
||||
|
||||
class Point
|
||||
{
|
||||
public:
|
||||
int x, y;
|
||||
Point(int X, int Y);
|
||||
Point();
|
||||
SDL_Point toSDLPoint() const;
|
||||
bool inRect(const Rect& rect) const;
|
||||
};
|
||||
|
||||
class ColorMode
|
||||
{
|
||||
public:
|
||||
int r, g, b;
|
||||
ColorMode(int R, int G, int B);
|
||||
ColorMode();
|
||||
};
|
||||
|
||||
class RGBA
|
||||
{
|
||||
public:
|
||||
int r, g, b, a;
|
||||
RGBA(int R, int G, int B, int A);
|
||||
RGBA(ColorMode mode, int A);
|
||||
RGBA();
|
||||
SDL_Color toSDLColor() const;
|
||||
ColorMode toColorMode() const;
|
||||
};
|
||||
|
||||
class NonCopyable
|
||||
{
|
||||
protected:
|
||||
NonCopyable() = default;
|
||||
~NonCopyable() = default;
|
||||
NonCopyable(const NonCopyable&) = delete;
|
||||
NonCopyable& operator = (const NonCopyable&) = delete;
|
||||
};
|
||||
|
||||
class ErrorViewer : public std::exception
|
||||
{
|
||||
public:
|
||||
void fetch();
|
||||
std::string getError() const;
|
||||
const char* what() const throw() override;
|
||||
private:
|
||||
std::string str;
|
||||
};
|
||||
|
||||
class RWOP
|
||||
{
|
||||
public:
|
||||
RWOP(FILE* fp,bool autoclose);
|
||||
RWOP(const std::string& filename,const std::string& openmode);
|
||||
RWOP(const void* mem,int size);
|
||||
RWOP(void* mem,int size);
|
||||
RWOP()=default;
|
||||
~RWOP()=default;
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_RWops> _op;
|
||||
SDL_RWops* _get() const;
|
||||
void _clear();
|
||||
void _set(SDL_RWops*);
|
||||
friend class Surface;
|
||||
friend class Renderer;
|
||||
};
|
||||
|
||||
enum class BlendMode { None,Blend,Add,Mod };
|
||||
|
||||
class Surface
|
||||
{
|
||||
public:
|
||||
Surface()=default;
|
||||
Surface(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask) throw(ErrorViewer);
|
||||
Surface(int width,int height,int depth,RGBA colorPack) throw(ErrorViewer);
|
||||
Surface(int width,int height,int depth,Uint32 surfaceFormat) throw(ErrorViewer);
|
||||
Surface(const std::string& filename) throw(ErrorViewer);
|
||||
Surface(const RWOP& rwop) throw(ErrorViewer);
|
||||
~Surface() = default;
|
||||
|
||||
/// static functions
|
||||
static Surface load(const std::string& filename);
|
||||
static Surface load(const RWOP& rwop);
|
||||
static Surface create(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask);
|
||||
static Surface create(int width,int height,int depth,Uint32 surfaceFormat);
|
||||
|
||||
/// xxxAs will clear the current surface if loaded or created successfully.
|
||||
int loadAs(const std::string& filename);
|
||||
int loadAs(const RWOP& rwop);
|
||||
int createAs(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask);
|
||||
int createAs(int width,int height,int depth,Uint32 surfaceFormat);
|
||||
|
||||
int savePNG(const std::string& filename) const;
|
||||
int getw() const;
|
||||
int geth() const;
|
||||
BlendMode getBlendMode() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
|
||||
/// Rendering functions. Copy an external surface to this surface. So it has no constant attribute.
|
||||
int blit(const Surface& s,const Rect& src,const Rect& dst);
|
||||
int blitTo(const Surface& t, const Rect& dst);
|
||||
int blitTo(const Surface& t, const Point& lupoint);
|
||||
int blitFill(const Surface& t, const Rect& src);
|
||||
int blitFullFill(const Surface& t);
|
||||
|
||||
int blitScaled(const Surface& s,const Rect& src,const Rect& dst);
|
||||
int blitScaledTo(const Surface& t, const Rect& dst);
|
||||
int blitScaledTo(const Surface& t, const Point& lupoint);
|
||||
int blitScaledFill(const Surface& t, const Rect& src);
|
||||
int blitScaledFullFill(const Surface& t);
|
||||
|
||||
int setClipRect(const Rect& clipRect);
|
||||
Rect getClipRect() const;
|
||||
void disableClipping();
|
||||
|
||||
int setAlphaMode(int alpha);
|
||||
int getAlphaMode() const;
|
||||
|
||||
ColorMode getColorMode() const;
|
||||
int setColorMode(ColorMode mode);
|
||||
RGBA getRGBA() const;
|
||||
void setRGBA(const RGBA& pack);
|
||||
|
||||
bool mustlock() const;
|
||||
int lock();
|
||||
void unlock();
|
||||
|
||||
bool isReady() const;
|
||||
void release();
|
||||
|
||||
/// Experimental : Get SDL_Surface Pointer and then do anything you want!
|
||||
/// In case you can do anything with this pointer, this function should not has constant attribute.
|
||||
SDL_Surface* getRawPointer();
|
||||
private:
|
||||
std::shared_ptr<SDL_Surface> _surf;
|
||||
void _set(SDL_Surface*);
|
||||
void _set_no_delete(SDL_Surface*);
|
||||
void _clear();
|
||||
SDL_Surface* _get() const;
|
||||
|
||||
friend class Window;
|
||||
friend class Renderer;
|
||||
friend class Font;
|
||||
friend class Cursor;
|
||||
};
|
||||
|
||||
class Texture
|
||||
{
|
||||
public:
|
||||
Texture();
|
||||
~Texture() = default;
|
||||
Rect getSize();
|
||||
int getw() const;
|
||||
int geth() const;
|
||||
bool isReady() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
BlendMode getBlendMode() const;
|
||||
/// Alpha: 0: Transparent 255: opaque
|
||||
int setAlphaMode(int alpha);
|
||||
int getAlphaMode() const;
|
||||
|
||||
ColorMode getColorMode() const;
|
||||
int setColorMode(ColorMode mode);
|
||||
RGBA getRGBA() const;
|
||||
void setRGBA(const RGBA& pack);
|
||||
|
||||
void release();
|
||||
protected:
|
||||
/// updateInfo() must be called after Texture is changed.
|
||||
void updateInfo();
|
||||
private:
|
||||
std::shared_ptr<SDL_Texture> _text;
|
||||
void _set(SDL_Texture*);
|
||||
void _clear();
|
||||
SDL_Texture* _get() const;
|
||||
Rect rect;
|
||||
friend class Renderer;
|
||||
};
|
||||
|
||||
enum class RendererType { Software, Accelerated, PresentSync, TargetTexture };
|
||||
|
||||
enum class FlipMode { None, Horizontal, Vertical };
|
||||
|
||||
class Renderer
|
||||
{
|
||||
public:
|
||||
Renderer() = default;
|
||||
int setColor(const RGBA& pack);
|
||||
RGBA getColor() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
BlendMode getBlendMode() const;
|
||||
|
||||
int setTarget(Texture& t);
|
||||
int setTarget();
|
||||
|
||||
int fillRect(const Rect& rect);
|
||||
int drawRect(const Rect& rect);
|
||||
int drawPoint(const Point& p);
|
||||
|
||||
int clear();
|
||||
void update();
|
||||
|
||||
int copy(const Texture& t, const Rect& src, const Rect& dst);
|
||||
int copyTo(const Texture& t, const Rect& dst);
|
||||
int copyTo(const Texture& t, const Point& lupoint);
|
||||
int copyFill(const Texture& t, const Rect& src);
|
||||
int copyFullFill(const Texture& t);
|
||||
|
||||
int supercopy(const Texture& t,
|
||||
bool srcfull,const Rect& src,bool dstfull,const Rect& dst,
|
||||
double angle,
|
||||
bool haspoint,const Point& center,FlipMode mode);
|
||||
|
||||
Texture render(const Surface& surf) const throw (ErrorViewer);
|
||||
Texture loadTexture(const std::string& FileName) const throw(ErrorViewer);
|
||||
Texture loadTextureRW(const RWOP& rwop) const throw(ErrorViewer);
|
||||
Texture createTexture(int Width, int Height) const throw(ErrorViewer);
|
||||
|
||||
bool isReady() const;
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_Renderer> _rnd;
|
||||
void _set(SDL_Renderer*);
|
||||
void _clear();
|
||||
SDL_Renderer* _get() const;
|
||||
|
||||
friend class Window;
|
||||
};
|
||||
|
||||
enum class SystemCursorType
|
||||
{
|
||||
Arrow, Ibeam, CrossHair,
|
||||
Wait, WaitArrow,
|
||||
SizeNWSE, SizeNESW, SizeWE, SizeNS, SizeAll,
|
||||
No, Hand
|
||||
};
|
||||
|
||||
class Cursor
|
||||
{
|
||||
public:
|
||||
Cursor()=default;
|
||||
Cursor(SystemCursorType);
|
||||
Cursor(Surface surf,Point hotspot={0,0});
|
||||
|
||||
static Cursor GetActiveCursor();
|
||||
static Cursor GetDefaultCursor();
|
||||
|
||||
static void setShow(bool);
|
||||
static bool isShow();
|
||||
|
||||
void activate();
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_Cursor> _cur;
|
||||
void _set(SDL_Cursor*);
|
||||
void _set_no_delete(SDL_Cursor*);
|
||||
SDL_Cursor* _get();
|
||||
void _clear();
|
||||
};
|
||||
|
||||
enum class MessageBoxType { Error, Warning, Information };
|
||||
|
||||
enum class WindowType
|
||||
{
|
||||
FullScreen, OpenGL, Shown, Hidden,
|
||||
Borderless, Resizable, Minimized, Maximized,
|
||||
InputGrabbed, InputFocus, MouseFocus,
|
||||
FullScreenDesktop, Foreign, AllowHighDPI,
|
||||
MouseCapture, AlwaysOnTop, SkipTaskBar,
|
||||
Utility, ToolTip, PopUpMenu
|
||||
};
|
||||
|
||||
class Window
|
||||
{
|
||||
public:
|
||||
Window()=default;
|
||||
Window(std::string Title, int Width, int Height,
|
||||
std::initializer_list<RendererType> RendererFlags = { RendererType::Accelerated,RendererType::TargetTexture },
|
||||
std::initializer_list<WindowType> WindowFlags = {WindowType::Shown} ,
|
||||
int WindowPositionX=SDL_WINDOWPOS_CENTERED, int WindowPositionY=SDL_WINDOWPOS_CENTERED) throw(ErrorViewer);
|
||||
Renderer getRenderer() const;
|
||||
|
||||
void setRenderer(RendererType Type)
|
||||
{
|
||||
int flagcalc=0;
|
||||
_setRenderer(flagcalc,Type);
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
void setRenderer(RendererType Type,Args&&... args)
|
||||
{
|
||||
int flagcalc=0;
|
||||
_setRenderer(flagcalc,Type,std::forward<RendererType>(args...));
|
||||
}
|
||||
|
||||
void setRenderer(std::initializer_list<RendererType>);
|
||||
|
||||
Rect getSize() const;
|
||||
void setSize(const Rect& sizeRect);
|
||||
void setSize(int w, int h);
|
||||
|
||||
Point getPosition() const;
|
||||
void setPosition(int x, int y);
|
||||
void setPosition(const Point& point);
|
||||
|
||||
void setTitle(const std::string& Title);
|
||||
std::string getTitle() const;
|
||||
|
||||
void setGrab(bool isGrab);
|
||||
bool getGrab() const;
|
||||
|
||||
#if _MINIENGINE_SDL_VERSION_ATLEAST(2,0,5)
|
||||
/// SDL2.0.5 Required.
|
||||
int setOpacity(float opacity);
|
||||
float getOpacity() const;
|
||||
#endif
|
||||
|
||||
/// FIXME: Not Implemented.
|
||||
void setResizable(bool resizable);
|
||||
|
||||
/// Use UTF8 in Title and Message please.
|
||||
int showSimpleMessageBox(MessageBoxType type,const std::string& Title,const std::string& Message) const;
|
||||
|
||||
void show();
|
||||
void hide();
|
||||
void raise();
|
||||
void minimize();
|
||||
void maximize();
|
||||
void restore();
|
||||
|
||||
_DECL_DEPRECATED Surface getSurface();
|
||||
|
||||
bool isScreenKeyboardShown();
|
||||
|
||||
void release();
|
||||
|
||||
/// Experimental : Free current renderer.
|
||||
/// This will cause all existing Renderer class throw an error on delete.
|
||||
/// This function destroy current renderer (if exist) and all Renderer class will not be notified.
|
||||
void resetRenderer();
|
||||
protected:
|
||||
template<typename... Args>
|
||||
void _setRenderer(int& refcalc,RendererType Type,Args&&... args)
|
||||
{
|
||||
refcalc|=_render_caster(Type);
|
||||
_setRenderer(refcalc,args...);
|
||||
}
|
||||
|
||||
void _setRenderer(int& refcalc,RendererType Type)
|
||||
{
|
||||
refcalc|=_render_caster(Type);
|
||||
_setRenderer_Real(refcalc);
|
||||
}
|
||||
private:
|
||||
void _setRenderer_Real(Uint32 flags);
|
||||
Uint32 _render_caster(RendererType);
|
||||
|
||||
std::shared_ptr<SDL_Window> _wnd;
|
||||
void _set(SDL_Window*);
|
||||
void _clear();
|
||||
SDL_Window* _get() const;
|
||||
|
||||
Renderer _winrnd;
|
||||
};
|
||||
|
||||
enum class FontStyle { Normal, Bold, Italic, UnderLine, StrikeThrough };
|
||||
enum class FontHint { Normal, Light, Mono, None , Error };
|
||||
|
||||
class Font
|
||||
{
|
||||
public:
|
||||
Font() = default;
|
||||
Font(std::string FontFileName, size_t size) throw(ErrorViewer);
|
||||
int use(std::string FontFileName, size_t size);
|
||||
bool isReady() const;
|
||||
|
||||
bool isNormal() const;
|
||||
bool isBold() const;
|
||||
bool isItalic() const;
|
||||
bool isUnderLine() const;
|
||||
bool isStrikeThrough() const;
|
||||
|
||||
void setNormal();
|
||||
void setBold(bool);
|
||||
void setItalic(bool);
|
||||
void setUnderLine(bool);
|
||||
void setStrikeThrough(bool);
|
||||
|
||||
template<typename... Args>
|
||||
void setFontStyle(FontStyle style,Args&&... args)
|
||||
{
|
||||
int fontcalc=0;
|
||||
_setFontStyle(fontcalc,style,args...);
|
||||
}
|
||||
|
||||
void setFontStyle(FontStyle style)
|
||||
{
|
||||
int fontcalc=0;
|
||||
_setFontStyle(fontcalc,style);
|
||||
}
|
||||
|
||||
std::vector<FontStyle> getFontStyles() const;
|
||||
|
||||
int getFontHeight() const;
|
||||
int getFontAscent() const;
|
||||
int getFontDescent() const;
|
||||
int getFontLineSkip() const;
|
||||
|
||||
bool isFontKerning() const;
|
||||
void setFontKerning(bool enableKerning);
|
||||
|
||||
long getFontFaceNum() const;
|
||||
int getFontFaceIsFixedWidth() const;
|
||||
std::string getFontFaceFamilyName() const;
|
||||
std::string getFontFaceStyleName() const;
|
||||
|
||||
FontHint getFontHint() const;
|
||||
void setFontHint(FontHint hint);
|
||||
|
||||
|
||||
Rect sizeText(const std::string& Text) const throw (ErrorViewer);
|
||||
Rect sizeUTF8(const std::string& Text) const throw (ErrorViewer);
|
||||
Rect sizeUnicode(const uint16_t* Text) const throw (ErrorViewer);
|
||||
|
||||
/// Surface Rendering Functions.
|
||||
Surface renderText(const std::string& Text, const RGBA& fg) const;
|
||||
Surface renderTextWrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Surface renderTextShaded(const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Surface renderTextSolid(const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Surface renderUTF8(const std::string& Text, const RGBA& fg) const;
|
||||
Surface renderUTF8Wrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Surface renderUTF8Shaded(const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Surface renderUTF8Solid(const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Surface renderUnicode(const uint16_t* Text,const RGBA& fg) const;
|
||||
Surface renderUnicodeWrapped(const uint16_t* Text,const RGBA& fg,size_t WrapLength) const;
|
||||
Surface renderUnicodeShaded(const uint16_t* Text,const RGBA& fg,const RGBA& bg) const;
|
||||
Surface renderUnicodeSolid(const uint16_t* Text,const RGBA& fg) const;
|
||||
|
||||
/// Texture Rendering Functions.
|
||||
Texture renderText(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
Texture renderTextWrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Texture renderTextShaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Texture renderTextSolid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Texture renderUTF8(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
Texture renderUTF8Wrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Texture renderUTF8Shaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Texture renderUTF8Solid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Texture renderUnicode(const Renderer& rnd,const uint16_t* Text,const RGBA& fg) const;
|
||||
Texture renderUnicodeWrapped(const Renderer& rnd,const uint16_t* Text,const RGBA& fg,size_t WrapLength) const;
|
||||
Texture renderUnicodeShaded(const Renderer& rnd,const uint16_t* Text,const RGBA& fg,const RGBA& bg) const;
|
||||
Texture renderUnicodeSolid(const Renderer& rnd,const uint16_t* Text,const RGBA& fg) const;
|
||||
|
||||
void release();
|
||||
protected:
|
||||
template<typename... Args>
|
||||
void _setFontStyle(int& fontcalc,FontStyle style,Args&&... args)
|
||||
{
|
||||
fontcalc|=_style_caster(style);
|
||||
_setFontStyle(fontcalc,args...);
|
||||
}
|
||||
|
||||
void _setFontStyle(int& fontcalc,FontStyle style)
|
||||
{
|
||||
fontcalc|=_style_caster(style);
|
||||
_real_setFontStyle(fontcalc);
|
||||
}
|
||||
private:
|
||||
void _real_setFontStyle(int);
|
||||
int _style_caster(FontStyle);
|
||||
|
||||
std::shared_ptr<TTF_Font> _font;
|
||||
void _set(TTF_Font*);
|
||||
void _clear();
|
||||
TTF_Font* _get() const;
|
||||
};
|
||||
|
||||
enum class Platform { Unknown,Windows,MacOS,Linux,iOS,Android };
|
||||
enum class PowerState { Unknown,OnBattery,NoBattery,Charging,Charged };
|
||||
|
||||
class LogSystem
|
||||
{
|
||||
static void v(const char* fmt,...);/// Verbose
|
||||
static void d(const char* fmt,...);/// Debug
|
||||
static void i(const char* fmt,...);/// Information
|
||||
static void w(const char* fmt,...);/// Warning
|
||||
static void e(const char* fmt,...);/// Error
|
||||
static void critical(const char* fmt,...);/// Critical
|
||||
};
|
||||
|
||||
class SharedLibrary
|
||||
{
|
||||
public:
|
||||
SharedLibrary();
|
||||
SharedLibrary(const std::string& Filename);
|
||||
~SharedLibrary()=default;
|
||||
int load(const std::string& Filename);
|
||||
int unload();
|
||||
|
||||
template<typename ReturnType,typename... Arguments>
|
||||
std::function<ReturnType(Arguments...)> get(const std::string& FunctionName)
|
||||
{
|
||||
return std::function<ReturnType(Arguments...)>(reinterpret_cast<ReturnType(*)(Arguments...)>(get(FunctionName)));
|
||||
}
|
||||
|
||||
void* get(const std::string& FunctionName) const;
|
||||
void release();
|
||||
private:
|
||||
void* _get() const;
|
||||
void _set(void*);
|
||||
void _clear();
|
||||
std::shared_ptr<void> _obj;
|
||||
};
|
||||
|
||||
class SDLSystem
|
||||
{
|
||||
public:
|
||||
static int SDLInit();
|
||||
static void SDLQuit();
|
||||
static int IMGInit();
|
||||
static void IMGQuit();
|
||||
static int TTFInit();
|
||||
static void TTFQuit();
|
||||
static int MixInit();
|
||||
static void MixQuit();
|
||||
|
||||
static void Init();
|
||||
static void Quit();
|
||||
|
||||
static void Delay(int ms);
|
||||
|
||||
static PowerState GetPowerState();
|
||||
static int GetPowerLifeLeft();
|
||||
static int GetPowerPrecentageLeft();
|
||||
|
||||
static Platform GetPlatform();
|
||||
|
||||
static void StartTextInput();
|
||||
static bool IsTextInputActive();
|
||||
static void StopTextInput();
|
||||
|
||||
static bool HasScreenKeyboardSupport();
|
||||
|
||||
static std::tuple<int,int,int> getCompileVersion();
|
||||
static std::tuple<int,int,int> getLinkedVersion();
|
||||
|
||||
class Android
|
||||
{
|
||||
public:
|
||||
static std::string GetInternal();
|
||||
static bool ExternalAvaliable();
|
||||
static bool CanReadExternal();
|
||||
static bool CanWriteExternal();
|
||||
static std::string GetExternal();
|
||||
static void* GetJNIEnv();
|
||||
};
|
||||
};
|
||||
|
||||
Uint32 _global_timer_executor(Uint32 interval,void* param);
|
||||
|
||||
class Timer
|
||||
{
|
||||
public:
|
||||
Timer();
|
||||
|
||||
/// void func(Uint32,...)
|
||||
template<typename VoidCallable,typename... Args>
|
||||
Timer(Uint32 interval,VoidCallable&& vcallable,Args&&... args) : Timer()
|
||||
{
|
||||
auto realCall=[&,vcallable](Uint32 ims)->Uint32{vcallable(ims,args...);return ims;};
|
||||
auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
|
||||
_real_timer_call(_global_timer_executor,interval,pfunc);
|
||||
}
|
||||
|
||||
/// Uint32 func(Uint32,...)
|
||||
template<typename Callable,typename... Args>
|
||||
Timer(Callable&& callable,Uint32 interval,Args&&... args) : Timer()
|
||||
{
|
||||
auto realCall=[&,callable](Uint32 ims)->Uint32{return callable(ims,args...);};
|
||||
auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
|
||||
_real_timer_call(_global_timer_executor,interval,pfunc);
|
||||
}
|
||||
|
||||
/// Restore For Capability
|
||||
Timer(SDL_TimerCallback callback,Uint32 interval,void* param);
|
||||
|
||||
int enable();
|
||||
int disable();
|
||||
bool isenable() const;
|
||||
void detach();
|
||||
~Timer();
|
||||
|
||||
static void _delete_delegator(std::function<Uint32(Uint32)>* Delegator);
|
||||
private:
|
||||
|
||||
void _real_timer_call(SDL_TimerCallback callback,Uint32 interval,void* param);
|
||||
|
||||
SDL_TimerCallback _callback;
|
||||
Uint32 _interval;
|
||||
void* _param;
|
||||
SDL_TimerID id;
|
||||
bool _enabled;
|
||||
bool _detached;
|
||||
/// Reserved Variable For Template variable Parameter
|
||||
bool _delete_on_disable;
|
||||
};
|
||||
|
||||
class AudioPlayer
|
||||
{
|
||||
public:
|
||||
AudioPlayer();
|
||||
~AudioPlayer();
|
||||
private:
|
||||
class _Audio
|
||||
{
|
||||
public:
|
||||
_Audio();
|
||||
~_Audio();
|
||||
};
|
||||
|
||||
static _Audio* _sysAudio;
|
||||
static int _sysAudioCounter;
|
||||
};
|
||||
|
||||
/// Forward Declaration
|
||||
class Music
|
||||
{
|
||||
public:
|
||||
|
||||
protected:
|
||||
Music() = default;
|
||||
private:
|
||||
std::shared_ptr<Mix_Music> _music;
|
||||
void _set(Mix_Music*);
|
||||
void _clear();
|
||||
Mix_Music* _get();
|
||||
friend class MusicPlayer;
|
||||
};
|
||||
|
||||
class MusicPlayer : public AudioPlayer
|
||||
{
|
||||
public:
|
||||
static int GetDecoderNum();
|
||||
static std::string GetDecoderName(int index);
|
||||
|
||||
Music loadMusic(std::string Filename) throw (ErrorViewer);
|
||||
|
||||
int play(Music music, int loops);
|
||||
void pause();
|
||||
void resume();
|
||||
void rewind();
|
||||
int stop();
|
||||
int fadeIn(int loops, int ms);
|
||||
int fadeOut(int ms);
|
||||
|
||||
bool isPlaying();
|
||||
bool isPaused();
|
||||
int isFading();
|
||||
|
||||
/// Experimental
|
||||
static int SetMusicPosition(double position);
|
||||
|
||||
private:
|
||||
Music m;
|
||||
};
|
||||
|
||||
class Sound
|
||||
{
|
||||
public:
|
||||
protected:
|
||||
Sound() = default;
|
||||
private:
|
||||
std::shared_ptr<Mix_Chunk> _sound;
|
||||
void _set(Mix_Chunk*);
|
||||
void _clear();
|
||||
Mix_Chunk* _get();
|
||||
friend class SoundPlayer;
|
||||
};
|
||||
|
||||
typedef int ChannelID;
|
||||
|
||||
class SoundPlayer : public AudioPlayer
|
||||
{
|
||||
public:
|
||||
static int GetDecoderNum();
|
||||
static std::string GetDecoderName(int index);
|
||||
|
||||
SoundPlayer(int Channels = 16);
|
||||
Sound loadSound(std::string Filename) throw (ErrorViewer);
|
||||
ChannelID playSound(Sound sound, int loops) throw (ErrorViewer);
|
||||
ChannelID fadein(Sound sound, int loops, int ms) throw (ErrorViewer);
|
||||
int fadeout(ChannelID id, int ms);
|
||||
void pause(ChannelID id);
|
||||
void resume(ChannelID id);
|
||||
int stop(ChannelID id);
|
||||
|
||||
/// Experimental
|
||||
int setPanning(ChannelID id,uint8_t left,uint8_t right);
|
||||
int setPosition(ChannelID id,int16_t angle,uint8_t distance);
|
||||
int setDistance(ChannelID id,uint8_t distance);
|
||||
int setReverseStereo(ChannelID id,int flip);
|
||||
};
|
||||
|
||||
class StringEngine
|
||||
{
|
||||
public:
|
||||
|
|
|
@ -13,7 +13,8 @@ void GetMD5Raw(unsigned char* buffer,unsigned int bufferLen,unsigned char* outbu
|
|||
|
||||
int GetCRC32(unsigned char* buffer,unsigned int bufferLen,uint32_t& out_CRCResult);
|
||||
|
||||
int CompareSurface(const Surface& surface1,const Surface& surface2,int allowableError);
|
||||
/// Compare two surfaces. Currently, Surface::getRawPointer() does not has constant attribute.
|
||||
int CompareSurface(Surface& surface1,Surface& surface2,int allowableError);
|
||||
|
||||
class UniRandom
|
||||
{
|
||||
|
|
|
@ -1,32 +0,0 @@
|
|||
#pragma once
|
||||
#include "../config.h"
|
||||
#include <functional>
|
||||
|
||||
//#include <SDL2/SDL_events.h>
|
||||
namespace MiniEngine
|
||||
{
|
||||
|
||||
class MouseEvent
|
||||
{
|
||||
private:
|
||||
struct EventData
|
||||
{
|
||||
int x,y;
|
||||
}
|
||||
public:
|
||||
int type;
|
||||
EventData data;
|
||||
};
|
||||
class MouseEventListener
|
||||
{
|
||||
public:
|
||||
MouseEventListener();
|
||||
|
||||
function<void(const MouseEvent&)> onButtonDown;
|
||||
function<void(const MouseEvent&)> onButtonUp;
|
||||
|
||||
function<void(const MouseEvent&)> onMotion;
|
||||
function<void(const MouseEvent&)> onWheel;
|
||||
};
|
||||
|
||||
}/// End of namespace MiniEngine
|
|
@ -1,47 +0,0 @@
|
|||
#include "Widget.h"
|
||||
|
||||
using namespace Engine;
|
||||
using namespace std;
|
||||
|
||||
namespace MiniEngine
|
||||
{
|
||||
/// Brush
|
||||
#include "widget_brush.hpp"
|
||||
|
||||
struct SimpleProgressBar::impl
|
||||
{
|
||||
int percentage;
|
||||
int w,h;
|
||||
RGBA ucolor,lcolor;
|
||||
};
|
||||
|
||||
SimpleProgressBar::SimpleProgressBar(int incw,int inch,RGBA upper_color,RGBA lower_color)
|
||||
{
|
||||
pimpl=new impl;
|
||||
pimpl->w=incw;
|
||||
pimpl->h=inch;
|
||||
pimpl->ucolor=upper_color;
|
||||
pimpl->lcolor=lower_color;
|
||||
pimpl->percentage=0;
|
||||
}
|
||||
void SimpleProgressBar::DrawAt(Renderer& rnd,int x,int y)
|
||||
{
|
||||
RGBA prev=rnd.getColor();
|
||||
if(pimpl->percentage)
|
||||
{
|
||||
rnd.setColor(pimpl->ucolor);
|
||||
rnd.fillRect(Rect(x,y,pimpl->w*pimpl->percentage/100,pimpl->h));
|
||||
}
|
||||
if(pimpl->percentage-100)
|
||||
{
|
||||
rnd.setColor(pimpl->lcolor);
|
||||
rnd.fillRect(Rect(x+pimpl->w*pimpl->percentage/100,y,pimpl->w*(100-pimpl->percentage)/100,pimpl->h));
|
||||
}
|
||||
rnd.setColor(prev);
|
||||
}
|
||||
void SimpleProgressBar::setPercentage(int iPercentage)
|
||||
{
|
||||
pimpl->percentage=min(max(0,iPercentage),100);
|
||||
}
|
||||
|
||||
}/// End of namespace MiniEngine
|
|
@ -1,89 +0,0 @@
|
|||
#pragma once
|
||||
#include "../config.h"
|
||||
#include <string>
|
||||
|
||||
#define _MINI_ENGINE_IMPL_COPY_DECL(ClassName) _SDL_ENGINE_IMPL_COPY_DECL(ClassName)
|
||||
#define _MINI_ENGINE_IMPL _SDL_ENGINE_IMPL
|
||||
namespace MiniEngine
|
||||
{
|
||||
|
||||
class Stage;
|
||||
|
||||
class Brush
|
||||
{
|
||||
public:
|
||||
~Brush();
|
||||
_MINI_ENGINE_IMPL_COPY_DECL(Brush)
|
||||
|
||||
void copy(Engine::Texture t,Engine::Rect src,Engine::Rect dst,bool autoZoom);
|
||||
void copyTo(Engine::Texture t,Engine::Rect dst,bool autoZoom);
|
||||
void copyFill(Engine::Texture t,Engine::Rect src);
|
||||
void copyFullFill(Engine::Texture t);
|
||||
public:
|
||||
Brush(const Engine::Window& rnd,Engine::Rect DrawableArea);
|
||||
private:
|
||||
_MINI_ENGINE_IMPL
|
||||
friend class Stage;
|
||||
};
|
||||
|
||||
class Stage
|
||||
{
|
||||
public:
|
||||
Stage();
|
||||
~Stage();
|
||||
};
|
||||
|
||||
class Drawable
|
||||
{
|
||||
public:
|
||||
virtual int Draw(const Brush& brush)=0;
|
||||
virtual Engine::Rect getSize()=0;
|
||||
};
|
||||
|
||||
class BaseButton : public Drawable
|
||||
{
|
||||
public:
|
||||
BaseButton();
|
||||
BaseButton(const BaseButton&);
|
||||
BaseButton& operator = (const BaseButton&);
|
||||
BaseButton(BaseButton&&);
|
||||
BaseButton& operator = (BaseButton&&);
|
||||
|
||||
virtual int Draw(const Brush& brush);
|
||||
virtual Engine::Rect getSize();
|
||||
|
||||
virtual ~BaseButton();
|
||||
private:
|
||||
struct impl;
|
||||
impl* pimpl;
|
||||
};
|
||||
|
||||
class SimpleButton : public BaseButton
|
||||
{
|
||||
public:
|
||||
/// Default Style
|
||||
SimpleButton();
|
||||
SimpleButton(std::string word,
|
||||
Engine::RGBA color_word,
|
||||
Engine::RGBA color_background,
|
||||
Engine::RGBA color_highlight);
|
||||
SimpleButton(const SimpleButton&);
|
||||
SimpleButton& operator = (const SimpleButton&);
|
||||
SimpleButton(SimpleButton&&);
|
||||
SimpleButton& operator = (SimpleButton&&);
|
||||
~SimpleButton();
|
||||
};
|
||||
|
||||
class SimpleProgressBar
|
||||
{
|
||||
public:
|
||||
SimpleProgressBar(int incw,int inch,Engine::RGBA upper_color,Engine::RGBA lower_color);
|
||||
void DrawAt(Engine::Renderer& rnd,int x,int y);
|
||||
void setPercentage(int iPercentage);
|
||||
~SimpleProgressBar();
|
||||
private:
|
||||
struct impl;
|
||||
impl* pimpl;
|
||||
};
|
||||
|
||||
}/// End of namespace MiniEngine.
|
|
@ -1,69 +0,0 @@
|
|||
struct Brush::impl
|
||||
{
|
||||
Renderer rnd;
|
||||
Rect area;
|
||||
impl(const Renderer& incrnd) : rnd(incrnd)
|
||||
{
|
||||
|
||||
}
|
||||
};
|
||||
Brush::Brush(const Window& wnd,Rect DrawableArea) /// Protected
|
||||
{
|
||||
pimpl=new impl(wnd.getRenderer());
|
||||
pimpl->area=DrawableArea;
|
||||
}
|
||||
void Brush::copy(Texture t,Rect src,Rect dst,bool autoZoom)
|
||||
{
|
||||
dst.x+=pimpl->area.x;
|
||||
dst.y+=pimpl->area.y;
|
||||
if(dst.w>pimpl->area.w) dst.w=pimpl->area.w;
|
||||
if(dst.h>pimpl->area.h) dst.h=pimpl->area.h;
|
||||
if(autoZoom)
|
||||
{
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
if(src.w>pimpl->area.w) src.w=pimpl->area.w;
|
||||
if(src.h>pimpl->area.h) src.h=pimpl->area.h;
|
||||
}
|
||||
pimpl->rnd.copy(t,src,dst);
|
||||
}
|
||||
void Brush::copyTo(Texture t,Rect dst,bool autoZoom)
|
||||
{
|
||||
dst.x+=pimpl->area.x;
|
||||
dst.y+=pimpl->area.y;
|
||||
|
||||
if(dst.w>pimpl->area.w) dst.w=pimpl->area.w;
|
||||
if(dst.h>pimpl->area.h) dst.h=pimpl->area.h;
|
||||
|
||||
if(autoZoom)
|
||||
{
|
||||
pimpl->rnd.copyTo(t,dst);
|
||||
}
|
||||
else
|
||||
{
|
||||
int w=t.getw();
|
||||
int h=t.geth();
|
||||
if(w>pimpl->area.w) w=pimpl->area.w;
|
||||
if(h>pimpl->area.h) h=pimpl->area.h;
|
||||
Rect src(0,0,w,h);
|
||||
pimpl->rnd.copy(t,src,dst);
|
||||
}
|
||||
}
|
||||
void Brush::copyFill(Texture t,Rect src)
|
||||
{
|
||||
Rect dst=pimpl->area;
|
||||
pimpl->rnd.copy(t,src,dst);
|
||||
}
|
||||
|
||||
void Brush::copyFullFill(Texture t)
|
||||
{
|
||||
Rect dst=pimpl->area;
|
||||
pimpl->rnd.copyTo(t,dst);
|
||||
}
|
||||
|
||||
Brush::~Brush()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
|
@ -1,9 +0,0 @@
|
|||
#pragma once
|
||||
#include "mini_engine.h"
|
||||
|
||||
namespace App
|
||||
{
|
||||
/** Entrance of Application.
|
||||
*/
|
||||
void Main();
|
||||
}
|
|
@ -1,42 +0,0 @@
|
|||
#pragma once
|
||||
#include "config.h"
|
||||
|
||||
class InitManager_SDL
|
||||
{
|
||||
public:
|
||||
InitManager_SDL();
|
||||
~InitManager_SDL();
|
||||
};
|
||||
|
||||
class InitManager_TTF
|
||||
{
|
||||
public:
|
||||
InitManager_TTF();
|
||||
~InitManager_TTF();
|
||||
int openFont(const char* FileName,int Size);
|
||||
int closeFont();
|
||||
TTF_Font* font();
|
||||
private:
|
||||
TTF_Font* _font;
|
||||
static int ctm;
|
||||
};
|
||||
|
||||
class InitManager_IMG
|
||||
{
|
||||
public:
|
||||
InitManager_IMG();
|
||||
~InitManager_IMG();
|
||||
SDL_Surface* loadimage(const char* FileName);
|
||||
SDL_Texture* loadtexture(SDL_Renderer* rnd,const char* Filename);
|
||||
};
|
||||
class InitManager_Mix
|
||||
{
|
||||
public:
|
||||
InitManager_Mix();
|
||||
~InitManager_Mix();
|
||||
};
|
||||
|
||||
extern InitManager_SDL* syssdl;
|
||||
extern InitManager_IMG* sysimg;
|
||||
extern InitManager_TTF* systtf;
|
||||
extern InitManager_Mix* sysmix;
|
|
@ -1,60 +0,0 @@
|
|||
#pragma once
|
||||
#include "config.h"
|
||||
#include <memory>
|
||||
|
||||
#define _MUSIC_MANAGER_IMPL \
|
||||
struct impl; \
|
||||
std::shared_ptr<impl> pimpl;
|
||||
|
||||
/// Fwd Decl
|
||||
class MusicPlayer;
|
||||
|
||||
class Music
|
||||
{
|
||||
public:
|
||||
Music();
|
||||
Music(const char* MusicFileName);
|
||||
int load(const char* MusicFileName);
|
||||
int unload();
|
||||
bool ready();
|
||||
~Music();
|
||||
private:
|
||||
_MUSIC_MANAGER_IMPL
|
||||
|
||||
friend class MusicPlayer;
|
||||
};
|
||||
|
||||
class SoundEffect
|
||||
{
|
||||
public:
|
||||
SoundEffect();
|
||||
SoundEffect(const char* SoundEffectFileName);
|
||||
int load(const char* SoundEffectFileName);
|
||||
~SoundEffect();
|
||||
private:
|
||||
_MUSIC_MANAGER_IMPL
|
||||
};
|
||||
|
||||
class MusicPlayer
|
||||
{
|
||||
public:
|
||||
MusicPlayer(int freq=MIX_DEFAULT_FREQUENCY,Uint16 format=MIX_DEFAULT_FORMAT,int soundChannel=2,int chunkSize=1024);
|
||||
~MusicPlayer();
|
||||
int play();
|
||||
int stop();
|
||||
int add(Music& music,int times);
|
||||
private:
|
||||
static MusicPlayer* pInstance;
|
||||
_MUSIC_MANAGER_IMPL
|
||||
};
|
||||
|
||||
class SoundEffectPlayer
|
||||
{
|
||||
public:
|
||||
SoundEffectPlayer();
|
||||
~SoundEffectPlayer();
|
||||
int play(SoundEffect& soundeffect,int times);
|
||||
private:
|
||||
_MUSIC_MANAGER_IMPL;
|
||||
};
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#ifdef __C4DROID__
|
||||
#define _WINDOW_PROGRAM
|
||||
#endif // __C4DROID__
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
/// If you have configured SDL2 header files,
|
||||
/// they will be used first.
|
||||
|
||||
#include "SDL2/SDL.h"
|
||||
#undef main
|
||||
|
||||
#include "SDL2/SDL_ttf.h"
|
||||
#include "SDL2/SDL_image.h"
|
||||
#include "SDL2/SDL_mixer.h"
|
||||
|
||||
class NonCopyable
|
||||
{
|
||||
public:
|
||||
NonCopyable()=default;
|
||||
~NonCopyable()=default;
|
||||
NonCopyable(const NonCopyable&)=delete;
|
||||
NonCopyable& operator = (const NonCopyable&)=delete;
|
||||
};
|
||||
|
||||
extern FILE* _log_fp;
|
||||
|
||||
#ifdef _WINDOW_PROGRAM
|
||||
#define mlog_init() _log_fp=fopen("mini_engine_log.txt","w")
|
||||
#define mlog(fmt,args...) do {if(_log_fp) {fprintf(_log_fp,fmt,##args);fprintf(_log_fp,"\n");fflush(_log_fp);} }while(0)
|
||||
#else
|
||||
#define mlog_init()
|
||||
#define mlog(fmt,args...) printf(fmt,##args);printf("\n")
|
||||
#endif
|
|
@ -1,9 +0,0 @@
|
|||
#pragma once
|
||||
#include "basic_config.h"
|
||||
|
||||
#include "sdl_engine.h"
|
||||
|
||||
namespace Global
|
||||
{
|
||||
void ErrorQuit(const char* ErrorMessage);
|
||||
}
|
|
@ -1,22 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include "config.h"
|
||||
|
||||
/******************************************************************************/
|
||||
/// InitManager
|
||||
#include "InitManager.h"
|
||||
|
||||
/******************************************************************************/
|
||||
/// MusicManager
|
||||
#include "MusicManager.h"
|
||||
|
||||
/******************************************************************************/
|
||||
/// Widget
|
||||
#include "MiniEngine/Widget.h"
|
||||
|
||||
/******************************************************************************/
|
||||
/// Application
|
||||
#include "App.h"
|
||||
|
||||
void AllInit();
|
||||
void AllQuit();
|
|
@ -1,158 +0,0 @@
|
|||
#pragma once
|
||||
#include "basic_config.h"
|
||||
|
||||
SDL_Texture* RenderText(SDL_Renderer* rnd,TTF_Font* font,const char* Text,SDL_Color color,int* pw,int* ph);
|
||||
SDL_Texture* RenderUTF8(SDL_Renderer* rnd,TTF_Font* font,const char* Text,SDL_Color color,int* pw,int* ph);
|
||||
void TextureDraw(SDL_Renderer* rnd,SDL_Texture* texture,int dstx,int dsty);
|
||||
bool isInRect(int x,int y,SDL_Rect rect);
|
||||
bool isInRect(int x,int y,int LU_x,int LU_y,int RD_x,int RD_y);
|
||||
void ClearMessageQueue();
|
||||
|
||||
int MyChangeDir(const char* DirName);
|
||||
|
||||
namespace Engine
|
||||
{
|
||||
class Rect
|
||||
{
|
||||
public:
|
||||
Rect();
|
||||
Rect(int incx,int incy,int incw,int inch);
|
||||
SDL_Rect toSDLRect();
|
||||
~Rect();
|
||||
|
||||
int x,y,w,h;
|
||||
};
|
||||
class RGBA
|
||||
{
|
||||
public:
|
||||
RGBA();
|
||||
RGBA(int incr,int incg,int incb,int inca);
|
||||
~RGBA();
|
||||
|
||||
SDL_Color toSDLColor();
|
||||
|
||||
int r,g,b,a;
|
||||
};
|
||||
|
||||
class Renderer;
|
||||
class Texture;
|
||||
class Font;
|
||||
|
||||
#define _SDL_ENGINE_IMPL_COPY_DECL(ClassName) \
|
||||
ClassName(const ClassName&); \
|
||||
ClassName(ClassName&&); \
|
||||
ClassName& operator = (const ClassName&); \
|
||||
ClassName& operator = (ClassName&&);
|
||||
|
||||
#define _SDL_ENGINE_IMPL \
|
||||
struct impl; \
|
||||
impl* pimpl;
|
||||
|
||||
#define DEFAULT_WIDTH 1024
|
||||
#define DEFAULT_HEIGHT 768
|
||||
|
||||
class Window
|
||||
{
|
||||
public:
|
||||
Window(int winw,int winh);
|
||||
~Window();
|
||||
|
||||
_SDL_ENGINE_IMPL_COPY_DECL(Window);
|
||||
|
||||
Renderer getRenderer() const;
|
||||
void resetRenderer();
|
||||
|
||||
Rect getSize();
|
||||
|
||||
void setSize(Rect r);
|
||||
|
||||
private:
|
||||
_SDL_ENGINE_IMPL
|
||||
};
|
||||
|
||||
class Surface
|
||||
{
|
||||
public:
|
||||
~Surface();
|
||||
_SDL_ENGINE_IMPL_COPY_DECL(Surface);
|
||||
protected:
|
||||
Surface();
|
||||
private:
|
||||
_SDL_ENGINE_IMPL
|
||||
friend class Renderer;
|
||||
friend class Font;
|
||||
};
|
||||
|
||||
class Renderer
|
||||
{
|
||||
public:
|
||||
virtual ~Renderer();
|
||||
_SDL_ENGINE_IMPL_COPY_DECL(Renderer);
|
||||
|
||||
int clear();
|
||||
void update();
|
||||
int copy(Texture t,Rect src,Rect dst);
|
||||
int copyTo(Texture t,Rect dst);
|
||||
int copyFill(Texture t,Rect src);
|
||||
int copyFullFill(Texture t);
|
||||
Texture loadImage(const char* FileName);
|
||||
Texture render(Surface surface);
|
||||
|
||||
int setColor(RGBA pack);
|
||||
RGBA getColor(int* pStatus=nullptr);
|
||||
|
||||
int fillRect(Rect rect);
|
||||
int drawRect(Rect rect);
|
||||
|
||||
/// Not Recommended
|
||||
SDL_Renderer* getDirectRenderer();
|
||||
protected:
|
||||
Renderer();
|
||||
private:
|
||||
_SDL_ENGINE_IMPL
|
||||
friend class Window;
|
||||
};
|
||||
|
||||
class Texture
|
||||
{
|
||||
public:
|
||||
~Texture();
|
||||
int getw();
|
||||
int geth();
|
||||
_SDL_ENGINE_IMPL_COPY_DECL(Texture);
|
||||
protected:
|
||||
Texture();
|
||||
private:
|
||||
_SDL_ENGINE_IMPL
|
||||
friend class Renderer;
|
||||
};
|
||||
|
||||
class Font
|
||||
{
|
||||
public:
|
||||
Font();
|
||||
Font(const char* FontFileName,int sz);
|
||||
int use(const char* FontFileName,int sz);
|
||||
~Font();
|
||||
|
||||
_SDL_ENGINE_IMPL_COPY_DECL(Font);
|
||||
|
||||
Texture renderText(Renderer rnd,const char* Word,RGBA fg);
|
||||
Texture renderTextShaded(Renderer rnd,const char* Word,RGBA fg,RGBA bg);
|
||||
Texture renderTextSolid(Renderer rnd,const char* Word,RGBA fg);
|
||||
|
||||
Texture renderUTF8(Renderer rnd,const char* Word,RGBA fg);
|
||||
Texture renderUTF8Shaded(Renderer rnd,const char* Word,RGBA fg,RGBA bg);
|
||||
Texture renderUTF8Solid(Renderer rnd,const char* Word,RGBA fg);
|
||||
private:
|
||||
_SDL_ENGINE_IMPL
|
||||
};
|
||||
|
||||
class SDLSystem
|
||||
{
|
||||
public:
|
||||
static void delay(int ms);
|
||||
};
|
||||
|
||||
}/// End of namespace Engine
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
CXXFLAGS = -std=c++14 -Wall -O2 -D__C4DROID__ -Iinclude
|
||||
LDFLAGS =
|
||||
LDLIBS = -lSDL2_image -lSDL2_net -ltiff -ljpeg -lpng -lz -lSDL2_ttf -lfreetype -lSDL2_mixer -lSDL2_test -lsmpeg2 -lvorbisfile -lvorbis -logg -lstdc++ -lSDL2 -lEGL -lGLESv1_CM -lGLESv2 -landroid -Wl,--no-undefined -shared
|
||||
|
||||
PROG = program_name
|
||||
OBJS = basic_config.o sdl_engine.o config.o InitManager.o mini_engine.o App.o main.o
|
||||
|
||||
all: $(PROG)
|
||||
|
||||
$(PROG): $(OBJS)
|
||||
$(CXX) $(CXXFLAGS) $(LDFLAGS) $(LDLIBS) -o $@ $(OBJS) `sdl2-config --cflags --libs`
|
||||
|
||||
clean:
|
||||
rm -f $(PROG) $(OBJS)
|
|
@ -1,44 +0,0 @@
|
|||
#include "App.h"
|
||||
|
||||
using namespace Engine;
|
||||
using namespace MiniEngine;
|
||||
|
||||
namespace App
|
||||
{
|
||||
/// Application Main Method
|
||||
void Main()
|
||||
{
|
||||
Window wnd(1366,768);///16:9
|
||||
Renderer rnd=wnd.getRenderer();
|
||||
Font bigf;
|
||||
if(bigf.use("msyh.ttf",72)<0)
|
||||
{
|
||||
mlog("Failed to open Font.");
|
||||
return;
|
||||
}
|
||||
rnd.clear();
|
||||
rnd.update();
|
||||
|
||||
MusicPlayer player;
|
||||
Music m;
|
||||
int ret=m.load("res/music.mp3");
|
||||
printf("ret=%d\n",ret);
|
||||
ret=player.add(m,-1);
|
||||
printf("ret=%d\n",ret);
|
||||
ret=player.play();
|
||||
printf("ret=%d\n",ret);
|
||||
printf("%s\n",Mix_GetError());
|
||||
|
||||
while(1) SDL_PollEvent(0);
|
||||
|
||||
/*
|
||||
/// Sample Code of Brush
|
||||
Brush b(wnd,Rect(wnd.getSize().w/2-50,wnd.getSize().h/2-50,100,100));
|
||||
Texture t=rnd.loadImage("D:\\sample.png");
|
||||
Rect dst(0,0,wnd.getSize().w,wnd.getSize().h);
|
||||
b.copyTo(t,dst,false);
|
||||
rnd.update();
|
||||
SDL_Delay(2000);
|
||||
*/
|
||||
}
|
||||
}
|
|
@ -1,119 +0,0 @@
|
|||
#include "InitManager.h"
|
||||
|
||||
InitManager_SDL::InitManager_SDL()
|
||||
{
|
||||
if(SDL_Init(SDL_INIT_EVERYTHING)<0)
|
||||
{
|
||||
#ifndef __C4DROID__
|
||||
Global::ErrorQuit("Failed to init SDL2.");
|
||||
#else
|
||||
/// C4droid does not fully support SDL2,
|
||||
/// so initializing everything crashes.
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
InitManager_SDL::~InitManager_SDL()
|
||||
{
|
||||
SDL_Quit();
|
||||
}
|
||||
|
||||
InitManager_IMG::InitManager_IMG()
|
||||
{
|
||||
if(IMG_Init(IMG_INIT_JPG|IMG_INIT_PNG)<0)
|
||||
{
|
||||
Global::ErrorQuit("Failed to init SDL2 Image.");
|
||||
}
|
||||
}
|
||||
|
||||
SDL_Surface* InitManager_IMG::loadimage(const char* Filename)
|
||||
{
|
||||
return IMG_Load(Filename);
|
||||
}
|
||||
|
||||
SDL_Texture* InitManager_IMG::loadtexture(SDL_Renderer* rnd,const char* Filename)
|
||||
{
|
||||
return IMG_LoadTexture(rnd,Filename);
|
||||
}
|
||||
|
||||
InitManager_IMG::~InitManager_IMG()
|
||||
{
|
||||
IMG_Quit();
|
||||
}
|
||||
|
||||
int InitManager_TTF::ctm=0;
|
||||
|
||||
InitManager_TTF::InitManager_TTF()
|
||||
{
|
||||
/// ~_~ check ctm and add it anyway
|
||||
if(ctm++>0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(TTF_Init()<0)
|
||||
{
|
||||
Global::ErrorQuit("Failed to init SDL2 TTF.");
|
||||
}
|
||||
_font=NULL;
|
||||
}
|
||||
|
||||
int InitManager_TTF::openFont(const char* FileName,int Size)
|
||||
{
|
||||
_font=TTF_OpenFont(FileName,Size);
|
||||
if(_font==NULL) return -1;
|
||||
else return 0;
|
||||
}
|
||||
|
||||
TTF_Font* InitManager_TTF::font()
|
||||
{
|
||||
return _font;
|
||||
}
|
||||
|
||||
int InitManager_TTF::closeFont()
|
||||
{
|
||||
TTF_CloseFont(_font);
|
||||
_font=NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
InitManager_TTF::~InitManager_TTF()
|
||||
{
|
||||
/// Close Font anyway.
|
||||
if(_font) closeFont();
|
||||
|
||||
/// ~_~ Firstly ctm=ctm-1, if ctm still > 0, then return ( TTF_Quit Not Executed )
|
||||
if(--ctm>0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
TTF_Quit();
|
||||
}
|
||||
|
||||
InitManager_Mix::InitManager_Mix()
|
||||
{
|
||||
if(Mix_Init(MIX_INIT_MP3)<0)
|
||||
{
|
||||
Global::ErrorQuit("Failed to Init Mixer.");
|
||||
}
|
||||
|
||||
/*
|
||||
if(Mix_OpenAudio(44100, AUDIO_S16SYS, 2, 1024)<0)
|
||||
{
|
||||
Global::ErrorQuit("Failed to OpenAudio");
|
||||
}
|
||||
Mix_AllocateChannels(32);
|
||||
*/
|
||||
}
|
||||
|
||||
InitManager_Mix::~InitManager_Mix()
|
||||
{
|
||||
//Mix_CloseAudio();
|
||||
Mix_Quit();
|
||||
}
|
||||
|
||||
InitManager_SDL* syssdl=NULL;
|
||||
InitManager_IMG* sysimg=NULL;
|
||||
InitManager_TTF* systtf=NULL;
|
||||
InitManager_Mix* sysmix=NULL;
|
|
@ -1,86 +0,0 @@
|
|||
#include "MusicManager.h"
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
using namespace std;
|
||||
|
||||
struct Music::impl
|
||||
{
|
||||
friend class Music;
|
||||
shared_ptr<Mix_Music> sMusic;
|
||||
};
|
||||
Music::Music()
|
||||
{
|
||||
pimpl.reset(new impl);
|
||||
}
|
||||
Music::Music(const char* MusicFileName) : Music()
|
||||
{
|
||||
load(MusicFileName);
|
||||
}
|
||||
int Music::load(const char* MusicFileName)
|
||||
{
|
||||
Mix_Music* ptemp=Mix_LoadMUS(MusicFileName);
|
||||
if(ptemp==nullptr) return -1;
|
||||
pimpl->sMusic.reset(ptemp,Mix_FreeMusic);
|
||||
return 0;
|
||||
}
|
||||
int Music::unload()
|
||||
{
|
||||
printf("Unloaded.\n");
|
||||
if(pimpl->sMusic.get())
|
||||
{
|
||||
printf("Reset to NULL\n");
|
||||
pimpl->sMusic.reset();
|
||||
return 0;
|
||||
}
|
||||
else return -2;
|
||||
}
|
||||
bool Music::ready()
|
||||
{
|
||||
return (pimpl->sMusic.get()!=nullptr);
|
||||
}
|
||||
Music::~Music()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
|
||||
struct MusicPlayer::impl
|
||||
{
|
||||
vector<pair<Music,int>> vec;
|
||||
};
|
||||
MusicPlayer::MusicPlayer(int freq,Uint16 format,int soundChannel,int chunkSize)
|
||||
{
|
||||
pimpl.reset(new impl);
|
||||
if(pInstance) return;
|
||||
Mix_OpenAudio(freq,format,soundChannel,chunkSize);
|
||||
pInstance=this;
|
||||
}
|
||||
MusicPlayer::~MusicPlayer()
|
||||
{
|
||||
if(pInstance) Mix_CloseAudio();
|
||||
pInstance=nullptr;
|
||||
}
|
||||
int MusicPlayer::play()
|
||||
{
|
||||
return Mix_PlayMusic(pimpl->vec.front().first.pimpl->sMusic.get(),pimpl->vec.front().second);
|
||||
}
|
||||
int MusicPlayer::add(Music& music,int times)
|
||||
{
|
||||
if(!music.ready()) return -1;
|
||||
pimpl->vec.push_back(make_pair(music,times));
|
||||
return 0;
|
||||
}
|
||||
MusicPlayer* MusicPlayer::pInstance=nullptr;
|
||||
|
||||
|
||||
|
||||
struct SoundEffect::impl
|
||||
{
|
||||
friend class SoundEffect;
|
||||
shared_ptr<Mix_Chunk> sChunk;
|
||||
};
|
||||
|
||||
SoundEffect::SoundEffect()
|
||||
{
|
||||
pimpl.reset(new impl);
|
||||
}
|
|
@ -1,3 +0,0 @@
|
|||
#include "basic_config.h"
|
||||
|
||||
FILE* _log_fp=NULL;
|
|
@ -1,10 +0,0 @@
|
|||
#include "config.h"
|
||||
|
||||
namespace Global
|
||||
{
|
||||
void ErrorQuit(const char* ErrorMessage)
|
||||
{
|
||||
mlog(ErrorMessage);
|
||||
exit(0);
|
||||
}
|
||||
}
|
|
@ -1,13 +0,0 @@
|
|||
#include "config.h"
|
||||
#include "App.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
/// Initialize SDL2...
|
||||
AllInit();
|
||||
/// Call Application Main
|
||||
App::Main();
|
||||
/// Clean Up SDL2
|
||||
AllQuit();
|
||||
return 0;
|
||||
}
|
|
@ -1,20 +0,0 @@
|
|||
#include "mini_engine.h"
|
||||
|
||||
void AllInit()
|
||||
{
|
||||
mlog_init();
|
||||
|
||||
syssdl=new InitManager_SDL;
|
||||
sysimg=new InitManager_IMG;
|
||||
systtf=new InitManager_TTF;
|
||||
sysmix=new InitManager_Mix;
|
||||
|
||||
}
|
||||
|
||||
void AllQuit()
|
||||
{
|
||||
delete sysmix;
|
||||
delete systtf;
|
||||
delete sysimg;
|
||||
delete syssdl;
|
||||
}
|
|
@ -1,144 +0,0 @@
|
|||
#include "sdl_engine.h"
|
||||
#include "unistd.h"
|
||||
#include <memory>
|
||||
using namespace std;
|
||||
|
||||
SDL_Texture* RenderUTF8(SDL_Renderer* rnd,TTF_Font* font,const char* Text,SDL_Color color,int* pw,int* ph)
|
||||
{
|
||||
SDL_Surface* surf=TTF_RenderUTF8_Blended(font,Text,color);
|
||||
if(surf==NULL) return NULL;
|
||||
SDL_Texture* texture=SDL_CreateTextureFromSurface(rnd,surf);
|
||||
SDL_FreeSurface(surf);
|
||||
if(pw&&ph) SDL_QueryTexture(texture,NULL,NULL,pw,ph);
|
||||
return texture;
|
||||
}
|
||||
|
||||
bool isInRect(int x,int y,SDL_Rect rect)
|
||||
{
|
||||
return ((x>=rect.x&&x<=rect.x+rect.w)&&(y>=rect.y&&y<=rect.y+rect.h));
|
||||
}
|
||||
|
||||
bool isInRect(int x,int y,int LU_x,int LU_y,int RD_x,int RD_y)
|
||||
{
|
||||
return ((x>=LU_x&&x<=RD_x)&&(y>=LU_y&&y<=RD_y));
|
||||
}
|
||||
|
||||
void ClearMessageQueue()
|
||||
{
|
||||
/// Clear Message Queue
|
||||
while(SDL_PeepEvents(NULL,1,SDL_GETEVENT,SDL_FIRSTEVENT,SDL_LASTEVENT));
|
||||
}
|
||||
|
||||
SDL_Color color_white { 255,255,255 };
|
||||
SDL_Color color_black { 0,0,0 };
|
||||
|
||||
int MyChangeDir(const char* DirName)
|
||||
{
|
||||
mlog("Change Dir to \"%s\"",DirName);
|
||||
int ret=chdir(DirName);
|
||||
mlog("Change Dir returns %d",ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
namespace Engine
|
||||
{
|
||||
|
||||
/// Rect
|
||||
#include "sdl_engine_rect.hpp"
|
||||
|
||||
struct Renderer::impl
|
||||
{
|
||||
private:
|
||||
friend class Renderer;
|
||||
shared_ptr<SDL_Renderer> sRnd;
|
||||
public:
|
||||
void set(SDL_Renderer* rnd)
|
||||
{
|
||||
sRnd.reset(rnd,SDL_DestroyRenderer);
|
||||
}
|
||||
};
|
||||
|
||||
struct Window::impl
|
||||
{
|
||||
private:
|
||||
friend class Window;
|
||||
shared_ptr<SDL_Window> sWnd;
|
||||
Renderer rnd;
|
||||
public:
|
||||
void set(SDL_Window* wnd)
|
||||
{
|
||||
sWnd.reset(wnd,SDL_DestroyWindow);
|
||||
rnd.pimpl->set(SDL_CreateRenderer(wnd,-1,SDL_RENDERER_ACCELERATED|SDL_RENDERER_TARGETTEXTURE));
|
||||
}
|
||||
SDL_Window* getRawWindow()
|
||||
{
|
||||
return sWnd.get();
|
||||
}
|
||||
};
|
||||
|
||||
struct Texture::impl
|
||||
{
|
||||
private:
|
||||
friend class Texture;
|
||||
shared_ptr<SDL_Texture> sText;
|
||||
int w,h;
|
||||
public:
|
||||
void set(SDL_Texture* text)
|
||||
{
|
||||
sText.reset(text,SDL_DestroyTexture);
|
||||
SDL_QueryTexture(text,NULL,NULL,&w,&h);
|
||||
}
|
||||
SDL_Texture* getRawTexture()
|
||||
{
|
||||
return sText.get();
|
||||
}
|
||||
};
|
||||
|
||||
struct Surface::impl
|
||||
{
|
||||
private:
|
||||
friend class Surface;
|
||||
shared_ptr<SDL_Surface> sSurf;
|
||||
public:
|
||||
void set(SDL_Surface* surf)
|
||||
{
|
||||
sSurf.reset(surf,SDL_FreeSurface);
|
||||
}
|
||||
SDL_Surface* getRawSurface()
|
||||
{
|
||||
return sSurf.get();
|
||||
}
|
||||
};
|
||||
|
||||
struct Font::impl
|
||||
{
|
||||
private:
|
||||
friend class Font;
|
||||
shared_ptr<TTF_Font> sTTF;
|
||||
public:
|
||||
void set(TTF_Font* font)
|
||||
{
|
||||
sTTF.reset(font,TTF_CloseFont);
|
||||
}
|
||||
};
|
||||
|
||||
/// Window
|
||||
#include "sdl_engine_window.hpp"
|
||||
/// Renderer
|
||||
#include "sdl_engine_renderer.hpp"
|
||||
/// Surface
|
||||
#include "sdl_engine_surface.hpp"
|
||||
/// Texture
|
||||
#include "sdl_engine_texture.hpp"
|
||||
/// RGBA
|
||||
#include "sdl_engine_rgba.hpp"
|
||||
/// Font
|
||||
#include "sdl_engine_font.hpp"
|
||||
|
||||
void SDLSystem::delay(int ms)
|
||||
{
|
||||
SDL_Delay(ms);
|
||||
}
|
||||
|
||||
}/// End of namespace Engine
|
|
@ -1,61 +0,0 @@
|
|||
Font::Font()
|
||||
{
|
||||
pimpl=new impl;
|
||||
}
|
||||
|
||||
Font::Font(const char* FontFileName,int sz) : Font()
|
||||
{
|
||||
use(FontFileName,sz);
|
||||
}
|
||||
|
||||
Font::Font(const Font& inc) : Font()
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
}
|
||||
Font& Font::operator = (const Font& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
Font::Font(Font&& inc)
|
||||
{
|
||||
pimpl=inc.pimpl;
|
||||
inc.pimpl=nullptr;
|
||||
}
|
||||
Font& Font::operator = (Font&& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
inc.pimpl=nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Font::~Font()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
||||
|
||||
int Font::use(const char* FontFileName,int sz)
|
||||
{
|
||||
TTF_Font* font=TTF_OpenFont(FontFileName,sz);
|
||||
if(font==NULL) return -1;
|
||||
pimpl->sTTF.reset(font,TTF_CloseFont);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Texture Font::renderText(Renderer rnd,const char* Word,RGBA fg)
|
||||
{
|
||||
Surface surf;
|
||||
surf.pimpl->set(TTF_RenderText_Blended(pimpl->sTTF.get(),Word,fg.toSDLColor()));
|
||||
Texture t=rnd.render(surf);
|
||||
return t;
|
||||
}
|
||||
|
||||
Texture Font::renderUTF8(Renderer rnd,const char* Word,RGBA fg)
|
||||
{
|
||||
Surface surf;
|
||||
surf.pimpl->set(TTF_RenderUTF8_Blended(pimpl->sTTF.get(),Word,fg.toSDLColor()));
|
||||
Texture t=rnd.render(surf);
|
||||
return t;
|
||||
}
|
|
@ -1,25 +0,0 @@
|
|||
Rect::Rect()
|
||||
{
|
||||
x=y=w=h=0;
|
||||
}
|
||||
Rect::Rect(int incx,int incy,int incw,int inch)
|
||||
{
|
||||
x=incx;
|
||||
y=incy;
|
||||
w=incw;
|
||||
h=inch;
|
||||
}
|
||||
Rect::~Rect()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
SDL_Rect Rect::toSDLRect()
|
||||
{
|
||||
SDL_Rect rect;
|
||||
rect.x=x;
|
||||
rect.y=y;
|
||||
rect.w=w;
|
||||
rect.h=h;
|
||||
return rect;
|
||||
}
|
|
@ -1,98 +0,0 @@
|
|||
Renderer::Renderer()
|
||||
{
|
||||
pimpl=new impl;
|
||||
}
|
||||
Renderer::Renderer(const Renderer& inc) : Renderer()
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
}
|
||||
Renderer& Renderer::operator = (const Renderer& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
Renderer::Renderer(Renderer&& inc)
|
||||
{
|
||||
pimpl=inc.pimpl;
|
||||
inc.pimpl=nullptr;
|
||||
}
|
||||
Renderer& Renderer::operator = (Renderer&& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
inc.pimpl=nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
Renderer::~Renderer()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
||||
|
||||
int Renderer::clear()
|
||||
{
|
||||
return SDL_RenderClear(pimpl->sRnd.get());
|
||||
}
|
||||
Texture Renderer::loadImage(const char* FileName)
|
||||
{
|
||||
Texture t;
|
||||
t.pimpl->set(IMG_LoadTexture(pimpl->sRnd.get(),FileName));
|
||||
return t;
|
||||
}
|
||||
Texture Renderer::render(Surface surface)
|
||||
{
|
||||
Texture t;
|
||||
t.pimpl->set(SDL_CreateTextureFromSurface(pimpl->sRnd.get(),surface.pimpl->getRawSurface()));
|
||||
return t;
|
||||
}
|
||||
|
||||
void Renderer::update()
|
||||
{
|
||||
SDL_RenderPresent(pimpl->sRnd.get());
|
||||
}
|
||||
|
||||
int Renderer::copy(Texture t,Rect src,Rect dst)
|
||||
{
|
||||
SDL_Rect s=src.toSDLRect();
|
||||
SDL_Rect d=dst.toSDLRect();
|
||||
return SDL_RenderCopy(pimpl->sRnd.get(),t.pimpl->getRawTexture(),&s,&d);
|
||||
}
|
||||
int Renderer::copyTo(Texture t,Rect dst)
|
||||
{
|
||||
SDL_Rect d=dst.toSDLRect();
|
||||
return SDL_RenderCopy(pimpl->sRnd.get(),t.pimpl->getRawTexture(),NULL,&d);
|
||||
}
|
||||
int Renderer::copyFill(Texture t,Rect src)
|
||||
{
|
||||
SDL_Rect s=src.toSDLRect();
|
||||
return SDL_RenderCopy(pimpl->sRnd.get(),t.pimpl->getRawTexture(),&s,NULL);
|
||||
}
|
||||
int Renderer::copyFullFill(Texture t)
|
||||
{
|
||||
return SDL_RenderCopy(pimpl->sRnd.get(),t.pimpl->getRawTexture(),NULL,NULL);
|
||||
}
|
||||
|
||||
int Renderer::setColor(RGBA pack)
|
||||
{
|
||||
return SDL_SetRenderDrawColor(pimpl->sRnd.get(),pack.r,pack.g,pack.b,pack.a);
|
||||
}
|
||||
|
||||
RGBA Renderer::getColor(int* pstatus)
|
||||
{
|
||||
Uint8 r,g,b,a;
|
||||
int ret=SDL_GetRenderDrawColor(pimpl->sRnd.get(),&r,&g,&b,&a);
|
||||
RGBA pack(r,g,b,a);
|
||||
if(pstatus) *pstatus=ret;
|
||||
return pack;
|
||||
}
|
||||
|
||||
int Renderer::fillRect(Rect rect)
|
||||
{
|
||||
auto inr=rect.toSDLRect();
|
||||
return SDL_RenderFillRect(pimpl->sRnd.get(),&inr);
|
||||
}
|
||||
|
||||
int Renderer::drawRect(Rect rect)
|
||||
{
|
||||
auto inr=rect.toSDLRect();
|
||||
return SDL_RenderDrawRect(pimpl->sRnd.get(),&inr);
|
||||
}
|
|
@ -1,24 +0,0 @@
|
|||
RGBA::RGBA()
|
||||
{
|
||||
r=g=b=a=0;
|
||||
}
|
||||
RGBA::RGBA(int incr,int incg,int incb,int inca)
|
||||
{
|
||||
r=incr;
|
||||
g=incg;
|
||||
b=incb;
|
||||
a=inca;
|
||||
}
|
||||
SDL_Color RGBA::toSDLColor()
|
||||
{
|
||||
SDL_Color color;
|
||||
color.r=r;
|
||||
color.g=g;
|
||||
color.b=b;
|
||||
color.a=a;
|
||||
return color;
|
||||
}
|
||||
RGBA::~RGBA()
|
||||
{
|
||||
|
||||
}
|
|
@ -1,27 +0,0 @@
|
|||
Surface::Surface()
|
||||
{
|
||||
pimpl=new impl;
|
||||
}
|
||||
Surface::Surface(const Surface& inc) : Surface()
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
}
|
||||
Surface& Surface::operator = (const Surface& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
Surface::Surface(Surface&& inc)
|
||||
{
|
||||
pimpl=inc.pimpl;
|
||||
inc.pimpl=nullptr;
|
||||
}
|
||||
Surface& Surface::operator = (Surface&& inc)
|
||||
{
|
||||
*(pimpl)=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
Surface::~Surface()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
|
@ -1,37 +0,0 @@
|
|||
Texture::Texture()
|
||||
{
|
||||
pimpl=new impl;
|
||||
}
|
||||
Texture::Texture(const Texture& inc) : Texture()
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
}
|
||||
Texture& Texture::operator = (const Texture& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
Texture::Texture(Texture&& inc)
|
||||
{
|
||||
pimpl=inc.pimpl;
|
||||
inc.pimpl=nullptr;
|
||||
}
|
||||
Texture& Texture::operator = (Texture&& inc)
|
||||
{
|
||||
*(pimpl)=*(inc.pimpl);
|
||||
inc.pimpl=nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int Texture::getw()
|
||||
{
|
||||
return pimpl->w;
|
||||
}
|
||||
int Texture::geth()
|
||||
{
|
||||
return pimpl->h;
|
||||
}
|
||||
Texture::~Texture()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
|
@ -1,55 +0,0 @@
|
|||
Window::Window(int winw,int winh)
|
||||
{
|
||||
pimpl=new impl;
|
||||
SDL_Window* wnd=SDL_CreateWindow("Engine",SDL_WINDOWPOS_CENTERED,SDL_WINDOWPOS_CENTERED,winw,winh,SDL_WINDOW_SHOWN);
|
||||
pimpl->set(wnd);
|
||||
}
|
||||
|
||||
Window::Window(const Window& inc)
|
||||
{
|
||||
pimpl=new impl;
|
||||
*pimpl=*(inc.pimpl);
|
||||
}
|
||||
|
||||
Window& Window::operator = (const Window& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Window::Window(Window&& inc)
|
||||
{
|
||||
pimpl=inc.pimpl;
|
||||
inc.pimpl=nullptr;
|
||||
}
|
||||
|
||||
Window& Window::operator = (Window&& inc)
|
||||
{
|
||||
*pimpl=*(inc.pimpl);
|
||||
inc.pimpl=nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
Window::~Window()
|
||||
{
|
||||
delete pimpl;
|
||||
}
|
||||
|
||||
Renderer Window::getRenderer() const
|
||||
{
|
||||
return pimpl->rnd;
|
||||
}
|
||||
|
||||
Rect Window::getSize()
|
||||
{
|
||||
int w,h;
|
||||
SDL_GetWindowSize(pimpl->getRawWindow(),&w,&h);
|
||||
Rect rect(0,0,w,h);
|
||||
return rect;
|
||||
}
|
||||
|
||||
void Window::setSize(Rect rect)
|
||||
{
|
||||
SDL_SetWindowSize(pimpl->getRawWindow(),rect.w,rect.h);
|
||||
}
|
33
SDLWrapper/Audio.cpp
Normal file
33
SDLWrapper/Audio.cpp
Normal file
|
@ -0,0 +1,33 @@
|
|||
#include "Audio.h"
|
||||
#include "begin_code.h"
|
||||
AudioPlayer::AudioPlayer()
|
||||
{
|
||||
if (!_sysAudioCounter)
|
||||
{
|
||||
_sysAudio = new _Audio;
|
||||
}
|
||||
++_sysAudioCounter;
|
||||
}
|
||||
|
||||
AudioPlayer::~AudioPlayer()
|
||||
{
|
||||
--_sysAudioCounter;
|
||||
if (!_sysAudioCounter)
|
||||
{
|
||||
delete _sysAudio;
|
||||
}
|
||||
}
|
||||
|
||||
AudioPlayer::_Audio::_Audio()
|
||||
{
|
||||
Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024);
|
||||
}
|
||||
|
||||
AudioPlayer::_Audio::~_Audio()
|
||||
{
|
||||
Mix_CloseAudio();
|
||||
}
|
||||
|
||||
AudioPlayer::_Audio* AudioPlayer::_sysAudio = nullptr;
|
||||
int AudioPlayer::_sysAudioCounter = 0;
|
||||
#include "end_code.h"
|
20
SDLWrapper/Audio.h
Normal file
20
SDLWrapper/Audio.h
Normal file
|
@ -0,0 +1,20 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "begin_code.h"
|
||||
class AudioPlayer
|
||||
{
|
||||
public:
|
||||
AudioPlayer();
|
||||
~AudioPlayer();
|
||||
private:
|
||||
class _Audio
|
||||
{
|
||||
public:
|
||||
_Audio();
|
||||
~_Audio();
|
||||
};
|
||||
|
||||
static _Audio* _sysAudio;
|
||||
static int _sysAudioCounter;
|
||||
};
|
||||
#include "end_code.h"
|
14
SDLWrapper/ColorMode.cpp
Normal file
14
SDLWrapper/ColorMode.cpp
Normal file
|
@ -0,0 +1,14 @@
|
|||
#include "ColorMode.h"
|
||||
#include "begin_code.h"
|
||||
ColorMode::ColorMode(int R, int G, int B)
|
||||
{
|
||||
r = R;
|
||||
g = G;
|
||||
b = B;
|
||||
}
|
||||
|
||||
ColorMode::ColorMode()
|
||||
{
|
||||
r = g = b = 0;
|
||||
}
|
||||
#include "end_code.h"
|
11
SDLWrapper/ColorMode.h
Normal file
11
SDLWrapper/ColorMode.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "begin_code.h"
|
||||
class ColorMode
|
||||
{
|
||||
public:
|
||||
int r, g, b;
|
||||
ColorMode(int R, int G, int B);
|
||||
ColorMode();
|
||||
};
|
||||
#include "end_code.h"
|
81
SDLWrapper/Cursor.cpp
Normal file
81
SDLWrapper/Cursor.cpp
Normal file
|
@ -0,0 +1,81 @@
|
|||
#include "Cursor.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Cursor::_set(SDL_Cursor* p)
|
||||
{
|
||||
_cur.reset(p,SDL_FreeCursor);
|
||||
}
|
||||
|
||||
//private
|
||||
void Cursor::_set_no_delete(SDL_Cursor* p)
|
||||
{
|
||||
_cur.reset(p,[](SDL_Cursor* p) {});
|
||||
}
|
||||
|
||||
//private
|
||||
SDL_Cursor* Cursor::_get()
|
||||
{
|
||||
return _cur.get();
|
||||
}
|
||||
|
||||
//private
|
||||
void Cursor::_clear()
|
||||
{
|
||||
_cur.reset();
|
||||
}
|
||||
|
||||
Cursor::Cursor(Surface surf,Point hotspot)
|
||||
{
|
||||
Cursor ns;
|
||||
SDL_Cursor* cursor=SDL_CreateColorCursor(surf._get(),hotspot.x,hotspot.y);
|
||||
ns._set(cursor);
|
||||
}
|
||||
|
||||
Cursor::Cursor(SystemCursorType type)
|
||||
{
|
||||
Cursor ns;
|
||||
ns._set(SDL_CreateSystemCursor(_internal::getSDLSystemCursorFromSystemCursorType(type)));
|
||||
}
|
||||
|
||||
//static
|
||||
Cursor Cursor::GetActiveCursor()
|
||||
{
|
||||
Cursor ns;
|
||||
ns._set_no_delete(SDL_GetCursor());
|
||||
return ns;
|
||||
}
|
||||
|
||||
//static
|
||||
Cursor Cursor::GetDefaultCursor()
|
||||
{
|
||||
Cursor ns;
|
||||
ns._set_no_delete(SDL_GetDefaultCursor());
|
||||
return ns;
|
||||
}
|
||||
|
||||
//static
|
||||
bool Cursor::isShow()
|
||||
{
|
||||
return (SDL_ShowCursor(SDL_QUERY)==SDL_ENABLE);
|
||||
}
|
||||
|
||||
//static
|
||||
void Cursor::setShow(bool Settings)
|
||||
{
|
||||
SDL_ShowCursor(Settings?SDL_ENABLE:SDL_DISABLE);
|
||||
}
|
||||
|
||||
void Cursor::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
void Cursor::activate()
|
||||
{
|
||||
if(_get()!=nullptr)
|
||||
{
|
||||
SDL_SetCursor(_get());
|
||||
}
|
||||
}
|
||||
#include "end_code.h"
|
30
SDLWrapper/Cursor.h
Normal file
30
SDLWrapper/Cursor.h
Normal file
|
@ -0,0 +1,30 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_SystemCursorType.h"
|
||||
#include "Point.h"
|
||||
#include "Surface.h"
|
||||
#include "begin_code.h"
|
||||
class Cursor
|
||||
{
|
||||
public:
|
||||
Cursor()=default;
|
||||
Cursor(SystemCursorType);
|
||||
Cursor(Surface surf,Point hotspot= {0,0});
|
||||
|
||||
static Cursor GetActiveCursor();
|
||||
static Cursor GetDefaultCursor();
|
||||
|
||||
static void setShow(bool);
|
||||
static bool isShow();
|
||||
|
||||
void activate();
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_Cursor> _cur;
|
||||
void _set(SDL_Cursor*);
|
||||
void _set_no_delete(SDL_Cursor*);
|
||||
SDL_Cursor* _get();
|
||||
void _clear();
|
||||
};
|
||||
#include "end_code.h"
|
18
SDLWrapper/ErrorViewer.cpp
Normal file
18
SDLWrapper/ErrorViewer.cpp
Normal file
|
@ -0,0 +1,18 @@
|
|||
#include "ErrorViewer.h"
|
||||
#include "include.h"
|
||||
#include "begin_code.h"
|
||||
void ErrorViewer::fetch()
|
||||
{
|
||||
str = SDL_GetError();
|
||||
}
|
||||
|
||||
std::string ErrorViewer::getError() const
|
||||
{
|
||||
return str;
|
||||
}
|
||||
|
||||
const char * ErrorViewer::what() const throw()
|
||||
{
|
||||
return str.c_str();
|
||||
}
|
||||
#include "end_code.h"
|
14
SDLWrapper/ErrorViewer.h
Normal file
14
SDLWrapper/ErrorViewer.h
Normal file
|
@ -0,0 +1,14 @@
|
|||
#pragma once
|
||||
#include <exception>
|
||||
#include <string>
|
||||
#include "begin_code.h"
|
||||
class ErrorViewer : public std::exception
|
||||
{
|
||||
public:
|
||||
void fetch();
|
||||
std::string getError() const;
|
||||
const char* what() const throw() override;
|
||||
private:
|
||||
std::string str;
|
||||
};
|
||||
#include "end_code.h"
|
396
SDLWrapper/Font.cpp
Normal file
396
SDLWrapper/Font.cpp
Normal file
|
@ -0,0 +1,396 @@
|
|||
#include "Font.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
// private
|
||||
void Font::_set(TTF_Font* p)
|
||||
{
|
||||
_font.reset(p,TTF_CloseFont);
|
||||
}
|
||||
// private
|
||||
void Font::_clear()
|
||||
{
|
||||
_font.reset();
|
||||
}
|
||||
// private
|
||||
TTF_Font* Font::_get() const
|
||||
{
|
||||
return _font.get();
|
||||
}
|
||||
|
||||
Font::Font(const std::string& FontFileName, size_t size) throw(ErrorViewer)
|
||||
{
|
||||
if (use(FontFileName, size) != 0)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
int Font::use(const std::string& FontFileName, size_t size)
|
||||
{
|
||||
TTF_Font* temp = TTF_OpenFont(FontFileName.c_str(), size);
|
||||
if (temp == NULL) return -1;
|
||||
_set(temp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool Font::isReady() const
|
||||
{
|
||||
return (_get() != nullptr);
|
||||
}
|
||||
|
||||
bool Font::isNormal() const
|
||||
{
|
||||
return !(TTF_GetFontStyle(_get()));
|
||||
}
|
||||
|
||||
bool Font::isBold() const
|
||||
{
|
||||
return (TTF_GetFontStyle(_get()) & TTF_STYLE_BOLD );
|
||||
}
|
||||
|
||||
bool Font::isItalic() const
|
||||
{
|
||||
return (TTF_GetFontStyle(_get()) & TTF_STYLE_ITALIC );
|
||||
}
|
||||
|
||||
bool Font::isUnderLine() const
|
||||
{
|
||||
return (TTF_GetFontStyle(_get()) & TTF_STYLE_UNDERLINE );
|
||||
}
|
||||
|
||||
bool Font::isStrikeThrough() const
|
||||
{
|
||||
return (TTF_GetFontStyle(_get()) & TTF_STYLE_STRIKETHROUGH );
|
||||
}
|
||||
|
||||
void Font::setNormal()
|
||||
{
|
||||
_real_setFontStyle(TTF_STYLE_NORMAL);
|
||||
}
|
||||
|
||||
void Font::setBold(bool enable)
|
||||
{
|
||||
if( enable!=isBold() )
|
||||
{
|
||||
_real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_BOLD:!TTF_STYLE_BOLD) );
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setItalic(bool enable)
|
||||
{
|
||||
if( enable!=isItalic() )
|
||||
{
|
||||
_real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_ITALIC:!TTF_STYLE_ITALIC) );
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setUnderLine(bool enable)
|
||||
{
|
||||
if( enable!=isUnderLine() )
|
||||
{
|
||||
_real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_UNDERLINE:!TTF_STYLE_UNDERLINE) );
|
||||
}
|
||||
}
|
||||
|
||||
void Font::setStrikeThrough(bool enable)
|
||||
{
|
||||
if( enable!=isStrikeThrough() )
|
||||
{
|
||||
_real_setFontStyle( TTF_GetFontStyle(_get()) | (enable?TTF_STYLE_STRIKETHROUGH:!TTF_STYLE_STRIKETHROUGH) );
|
||||
}
|
||||
}
|
||||
|
||||
void Font::_real_setFontStyle(int Style)
|
||||
{
|
||||
TTF_SetFontStyle(_get(),Style);
|
||||
}
|
||||
|
||||
int Font::_style_caster(FontStyle style)
|
||||
{
|
||||
return _internal::getTTFFontStyleFromFontStyle(style);
|
||||
}
|
||||
|
||||
std::vector<FontStyle> Font::getFontStyles() const
|
||||
{
|
||||
int styles=TTF_GetFontStyle(_get());
|
||||
return _internal::getFontStyleVecFromMixedTTFFontStyle(styles);
|
||||
}
|
||||
|
||||
int Font::getFontHeight() const
|
||||
{
|
||||
return TTF_FontHeight(_get());
|
||||
}
|
||||
|
||||
int Font::getFontAscent() const
|
||||
{
|
||||
return TTF_FontAscent(_get());
|
||||
}
|
||||
|
||||
int Font::getFontDescent() const
|
||||
{
|
||||
return TTF_FontDescent(_get());
|
||||
}
|
||||
|
||||
int Font::getFontLineSkip() const
|
||||
{
|
||||
return TTF_FontLineSkip(_get());
|
||||
}
|
||||
|
||||
bool Font::isFontKerning() const
|
||||
{
|
||||
return (TTF_GetFontKerning(_get())!=0);
|
||||
}
|
||||
|
||||
void Font::setFontKerning(bool enableKerning)
|
||||
{
|
||||
TTF_SetFontKerning(_get(),enableKerning?1:0);
|
||||
}
|
||||
|
||||
long Font::getFontFaceNum() const
|
||||
{
|
||||
return TTF_FontFaces(_get());
|
||||
}
|
||||
|
||||
int Font::getFontFaceIsFixedWidth() const
|
||||
{
|
||||
return TTF_FontFaceIsFixedWidth(_get());
|
||||
}
|
||||
|
||||
std::string Font::getFontFaceFamilyName() const
|
||||
{
|
||||
return std::string(TTF_FontFaceFamilyName(_get()));
|
||||
}
|
||||
|
||||
std::string Font::getFontFaceStyleName() const
|
||||
{
|
||||
return std::string(TTF_FontFaceStyleName(_get()));
|
||||
}
|
||||
|
||||
FontHint Font::getFontHint() const
|
||||
{
|
||||
switch(TTF_GetFontHinting(_get()))
|
||||
{
|
||||
case TTF_HINTING_NORMAL:
|
||||
return FontHint::Normal;
|
||||
case TTF_HINTING_LIGHT:
|
||||
return FontHint::Light;
|
||||
case TTF_HINTING_MONO:
|
||||
return FontHint::Mono;
|
||||
case TTF_HINTING_NONE:
|
||||
return FontHint::None;
|
||||
}
|
||||
/// Return Error on default.
|
||||
return FontHint::Error;
|
||||
}
|
||||
|
||||
void Font::setFontHint(FontHint hint)
|
||||
{
|
||||
int v=0;
|
||||
switch(hint)
|
||||
{
|
||||
case FontHint::Normal:
|
||||
v=TTF_HINTING_NORMAL;
|
||||
break;
|
||||
case FontHint::Light:
|
||||
v=TTF_HINTING_LIGHT;
|
||||
break;
|
||||
case FontHint::Mono:
|
||||
v=TTF_HINTING_MONO;
|
||||
break;
|
||||
case FontHint::None:
|
||||
v=TTF_HINTING_NONE;
|
||||
break;
|
||||
case FontHint::Error:
|
||||
/// No Action on FontHint::Error.
|
||||
return;
|
||||
}
|
||||
TTF_SetFontHinting(_get(),v);
|
||||
}
|
||||
|
||||
Rect Font::sizeText(const std::string& Text) const throw (ErrorViewer)
|
||||
{
|
||||
int w=0,h=0;
|
||||
if(TTF_SizeText(_get(),Text.c_str(),&w,&h)!=0)
|
||||
{
|
||||
/// Something might be wrong
|
||||
throw ErrorViewer();
|
||||
}
|
||||
return Rect(0,0,w,h);
|
||||
}
|
||||
|
||||
Rect Font::sizeUTF8(const std::string& Text) const throw (ErrorViewer)
|
||||
{
|
||||
int w=0,h=0;
|
||||
if(TTF_SizeUTF8(_get(),Text.c_str(),&w,&h)!=0)
|
||||
{
|
||||
/// Something might be wrong
|
||||
throw ErrorViewer();
|
||||
}
|
||||
return Rect(0,0,w,h);
|
||||
}
|
||||
|
||||
Rect Font::sizeUnicode(const uint16_t* Text) const throw (ErrorViewer)
|
||||
{
|
||||
int w=0,h=0;
|
||||
if(TTF_SizeUNICODE(_get(),Text,&w,&h)!=0)
|
||||
{
|
||||
/// Something might be wrong
|
||||
throw ErrorViewer();
|
||||
}
|
||||
return Rect(0,0,w,h);
|
||||
}
|
||||
|
||||
/// rendering surfaces...
|
||||
Surface Font::renderText(const std::string& Text,const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderText_Blended(_get(), Text.c_str(), fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderTextWrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderText_Blended_Wrapped(_get(), Text.c_str(), fg.toSDLColor(), WrapLength));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderTextShaded(const std::string& Text, const RGBA& fg,const RGBA& bg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderText_Shaded(_get(), Text.c_str(), fg.toSDLColor(), bg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderTextSolid(const std::string& Text,const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderText_Solid(_get(), Text.c_str(), fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUTF8(const std::string& Text,const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUTF8_Blended(_get(), Text.c_str(), fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUTF8Wrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUTF8_Blended_Wrapped(_get(), Text.c_str(), fg.toSDLColor(), WrapLength));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUTF8Shaded(const std::string& Text, const RGBA& fg,const RGBA& bg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUTF8_Shaded(_get(), Text.c_str(), fg.toSDLColor(), bg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUTF8Solid(const std::string& Text,const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUTF8_Solid(_get(), Text.c_str(), fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUnicode(const uint16_t* Text, const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUNICODE_Blended(_get(),Text,fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUnicodeWrapped(const uint16_t* Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUNICODE_Blended_Wrapped(_get(),Text,fg.toSDLColor(),WrapLength));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUnicodeShaded(const uint16_t* Text, const RGBA& fg, const RGBA& bg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUNICODE_Shaded(_get(),Text,fg.toSDLColor(),bg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
Surface Font::renderUnicodeSolid(const uint16_t* Text, const RGBA& fg) const
|
||||
{
|
||||
Surface surf;
|
||||
surf._set(TTF_RenderUNICODE_Solid(_get(),Text,fg.toSDLColor()));
|
||||
return surf;
|
||||
}
|
||||
|
||||
/// rendering textures...
|
||||
Texture Font::renderText(const Renderer& rnd, const std::string& Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderText(Text,fg));
|
||||
}
|
||||
|
||||
Texture Font::renderTextWrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
return rnd.render(renderTextWrapped(Text,fg,WrapLength));
|
||||
}
|
||||
|
||||
Texture Font::renderTextShaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const
|
||||
{
|
||||
return rnd.render(renderTextShaded(Text,fg,bg));
|
||||
}
|
||||
|
||||
Texture Font::renderTextSolid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderTextSolid(Text,fg));
|
||||
}
|
||||
|
||||
Texture Font::renderUTF8(const Renderer& rnd, const std::string& Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderUTF8(Text,fg));
|
||||
}
|
||||
|
||||
Texture Font::renderUTF8Wrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
return rnd.render(renderUTF8Wrapped(Text,fg,WrapLength));
|
||||
}
|
||||
|
||||
Texture Font::renderUTF8Shaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const
|
||||
{
|
||||
return rnd.render(renderUTF8Shaded(Text,fg,bg));
|
||||
}
|
||||
|
||||
Texture Font::renderUTF8Solid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderUTF8Solid(Text,fg));
|
||||
}
|
||||
|
||||
|
||||
Texture Font::renderUnicode(const Renderer& rnd, const uint16_t* Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderUnicode(Text,fg));
|
||||
}
|
||||
|
||||
Texture Font::renderUnicodeWrapped(const Renderer& rnd, const uint16_t* Text, const RGBA& fg, size_t WrapLength) const
|
||||
{
|
||||
return rnd.render(renderUnicodeWrapped(Text,fg,WrapLength));
|
||||
}
|
||||
|
||||
Texture Font::renderUnicodeShaded(const Renderer& rnd, const uint16_t* Text, const RGBA& fg, const RGBA& bg) const
|
||||
{
|
||||
return rnd.render(renderUnicodeShaded(Text,fg,bg));
|
||||
}
|
||||
|
||||
Texture Font::renderUnicodeSolid(const Renderer& rnd, const uint16_t* Text, const RGBA& fg) const
|
||||
{
|
||||
return rnd.render(renderUnicodeSolid(Text,fg));
|
||||
}
|
||||
|
||||
void Font::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
#include "end_code.h"
|
122
SDLWrapper/Font.h
Normal file
122
SDLWrapper/Font.h
Normal file
|
@ -0,0 +1,122 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_FontStyle.h"
|
||||
#include "_FontHint.h"
|
||||
#include "Rect.h"
|
||||
#include "Surface.h"
|
||||
#include "Texture.h"
|
||||
#include "Renderer.h"
|
||||
#include <vector>
|
||||
#include "begin_code.h"
|
||||
class Font
|
||||
{
|
||||
public:
|
||||
Font() = default;
|
||||
Font(const std::string& FontFileName, size_t size) throw(ErrorViewer);
|
||||
int use(const std::string& FontFileName, size_t size);
|
||||
bool isReady() const;
|
||||
|
||||
bool isNormal() const;
|
||||
bool isBold() const;
|
||||
bool isItalic() const;
|
||||
bool isUnderLine() const;
|
||||
bool isStrikeThrough() const;
|
||||
|
||||
void setNormal();
|
||||
void setBold(bool);
|
||||
void setItalic(bool);
|
||||
void setUnderLine(bool);
|
||||
void setStrikeThrough(bool);
|
||||
|
||||
template<typename... Args>
|
||||
void setFontStyle(FontStyle style,Args&&... args)
|
||||
{
|
||||
int fontcalc=0;
|
||||
_setFontStyle(fontcalc,style,args...);
|
||||
}
|
||||
|
||||
void setFontStyle(FontStyle style)
|
||||
{
|
||||
int fontcalc=0;
|
||||
_setFontStyle(fontcalc,style);
|
||||
}
|
||||
|
||||
std::vector<FontStyle> getFontStyles() const;
|
||||
|
||||
int getFontHeight() const;
|
||||
int getFontAscent() const;
|
||||
int getFontDescent() const;
|
||||
int getFontLineSkip() const;
|
||||
|
||||
bool isFontKerning() const;
|
||||
void setFontKerning(bool enableKerning);
|
||||
|
||||
long getFontFaceNum() const;
|
||||
int getFontFaceIsFixedWidth() const;
|
||||
std::string getFontFaceFamilyName() const;
|
||||
std::string getFontFaceStyleName() const;
|
||||
|
||||
FontHint getFontHint() const;
|
||||
void setFontHint(FontHint hint);
|
||||
|
||||
|
||||
Rect sizeText(const std::string& Text) const throw (ErrorViewer);
|
||||
Rect sizeUTF8(const std::string& Text) const throw (ErrorViewer);
|
||||
Rect sizeUnicode(const uint16_t* Text) const throw (ErrorViewer);
|
||||
|
||||
/// Surface Rendering Functions.
|
||||
Surface renderText(const std::string& Text, const RGBA& fg) const;
|
||||
Surface renderTextWrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Surface renderTextShaded(const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Surface renderTextSolid(const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Surface renderUTF8(const std::string& Text, const RGBA& fg) const;
|
||||
Surface renderUTF8Wrapped(const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Surface renderUTF8Shaded(const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Surface renderUTF8Solid(const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Surface renderUnicode(const uint16_t* Text,const RGBA& fg) const;
|
||||
Surface renderUnicodeWrapped(const uint16_t* Text,const RGBA& fg,size_t WrapLength) const;
|
||||
Surface renderUnicodeShaded(const uint16_t* Text,const RGBA& fg,const RGBA& bg) const;
|
||||
Surface renderUnicodeSolid(const uint16_t* Text,const RGBA& fg) const;
|
||||
|
||||
/// Texture Rendering Functions.
|
||||
Texture renderText(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
Texture renderTextWrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Texture renderTextShaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Texture renderTextSolid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Texture renderUTF8(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
Texture renderUTF8Wrapped(const Renderer& rnd, const std::string& Text, const RGBA& fg, size_t WrapLength) const;
|
||||
Texture renderUTF8Shaded(const Renderer& rnd, const std::string& Text, const RGBA& fg, const RGBA& bg) const;
|
||||
Texture renderUTF8Solid(const Renderer& rnd, const std::string& Text, const RGBA& fg) const;
|
||||
|
||||
Texture renderUnicode(const Renderer& rnd,const uint16_t* Text,const RGBA& fg) const;
|
||||
Texture renderUnicodeWrapped(const Renderer& rnd,const uint16_t* Text,const RGBA& fg,size_t WrapLength) const;
|
||||
Texture renderUnicodeShaded(const Renderer& rnd,const uint16_t* Text,const RGBA& fg,const RGBA& bg) const;
|
||||
Texture renderUnicodeSolid(const Renderer& rnd,const uint16_t* Text,const RGBA& fg) const;
|
||||
|
||||
void release();
|
||||
protected:
|
||||
template<typename... Args>
|
||||
void _setFontStyle(int& fontcalc,FontStyle style,Args&&... args)
|
||||
{
|
||||
fontcalc|=_style_caster(style);
|
||||
_setFontStyle(fontcalc,args...);
|
||||
}
|
||||
|
||||
void _setFontStyle(int& fontcalc,FontStyle style)
|
||||
{
|
||||
fontcalc|=_style_caster(style);
|
||||
_real_setFontStyle(fontcalc);
|
||||
}
|
||||
private:
|
||||
void _real_setFontStyle(int);
|
||||
int _style_caster(FontStyle);
|
||||
|
||||
std::shared_ptr<TTF_Font> _font;
|
||||
void _set(TTF_Font*);
|
||||
void _clear();
|
||||
TTF_Font* _get() const;
|
||||
};
|
||||
#include "end_code.h"
|
21
SDLWrapper/IncludeAll.h
Normal file
21
SDLWrapper/IncludeAll.h
Normal file
|
@ -0,0 +1,21 @@
|
|||
#pragma once
|
||||
/// Sorted by alphabet sequence. Some files are ignored.
|
||||
#include "ColorMode.h"
|
||||
#include "Cursor.h"
|
||||
#include "ErrorViewer.h"
|
||||
#include "Font.h"
|
||||
#include "Log.h"
|
||||
#include "MessageBox.h"
|
||||
#include "Music.h"
|
||||
#include "Point.h"
|
||||
#include "Rect.h"
|
||||
#include "Renderer.h"
|
||||
#include "RGBA.h"
|
||||
#include "RWOP.h"
|
||||
#include "SDLSystem.h"
|
||||
#include "SharedLibrary.h"
|
||||
#include "Sound.h"
|
||||
#include "Surface.h"
|
||||
#include "Texture.h"
|
||||
#include "Timer.h"
|
||||
#include "Window.h"
|
50
SDLWrapper/Log.cpp
Normal file
50
SDLWrapper/Log.cpp
Normal file
|
@ -0,0 +1,50 @@
|
|||
#include "Log.h"
|
||||
#include "begin_code.h"
|
||||
void LogSystem::d(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_DEBUG,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void LogSystem::v(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_VERBOSE,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void LogSystem::e(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_ERROR,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void LogSystem::i(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_INFO,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void LogSystem::w(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_WARN,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
|
||||
void LogSystem::critical(const char* fmt,...)
|
||||
{
|
||||
va_list ap;
|
||||
va_start(ap,fmt);
|
||||
SDL_LogMessageV(SDL_LOG_CATEGORY_APPLICATION,SDL_LOG_PRIORITY_CRITICAL,fmt,ap);
|
||||
va_end(ap);
|
||||
}
|
||||
#include "end_code.h"
|
13
SDLWrapper/Log.h
Normal file
13
SDLWrapper/Log.h
Normal file
|
@ -0,0 +1,13 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "begin_code.h"
|
||||
class LogSystem
|
||||
{
|
||||
static void v(const char* fmt,...);/// Verbose
|
||||
static void d(const char* fmt,...);/// Debug
|
||||
static void i(const char* fmt,...);/// Information
|
||||
static void w(const char* fmt,...);/// Warning
|
||||
static void e(const char* fmt,...);/// Error
|
||||
static void critical(const char* fmt,...);/// Critical
|
||||
};
|
||||
#include "end_code.h"
|
66
SDLWrapper/MessageBox.cpp
Normal file
66
SDLWrapper/MessageBox.cpp
Normal file
|
@ -0,0 +1,66 @@
|
|||
#include "MessageBox.h"
|
||||
#include "begin_code.h"
|
||||
WindowMessageBoxButton::WindowMessageBoxButton()
|
||||
{
|
||||
_hitoption=0;
|
||||
text="Button";
|
||||
callback=[]() {};
|
||||
}
|
||||
|
||||
WindowMessageBoxButton::WindowMessageBoxButton(const std::string& ButtonText,const std::function<void()>& CallbackFunc) : text(ButtonText)
|
||||
{
|
||||
_hitoption=0;
|
||||
callback=CallbackFunc;
|
||||
}
|
||||
|
||||
void WindowMessageBoxButton::setHitAsEscape(bool enable)
|
||||
{
|
||||
_hitoption=enable?1:0;
|
||||
}
|
||||
|
||||
void WindowMessageBoxButton::setHitAsReturn(bool enable)
|
||||
{
|
||||
_hitoption=enable?2:0;
|
||||
}
|
||||
|
||||
bool WindowMessageBoxButton::isHitAsEscape() const
|
||||
{
|
||||
return _hitoption==1;
|
||||
}
|
||||
|
||||
bool WindowMessageBoxButton::isHitAsReturn() const
|
||||
{
|
||||
return _hitoption==2;
|
||||
}
|
||||
|
||||
WindowMessageBox::WindowMessageBox()
|
||||
{
|
||||
boxtype=MessageBoxType::Information;
|
||||
}
|
||||
|
||||
WindowMessageBox::WindowMessageBox(const std::string& Title,const std::string& Text,MessageBoxType BoxType,const std::function<void()>& DefaultCallback) : title(Title), text(Text)
|
||||
{
|
||||
boxtype=BoxType;
|
||||
defaultcallback=DefaultCallback;
|
||||
}
|
||||
|
||||
void WindowMessageBox::addButton(const WindowMessageBoxButton& button)
|
||||
{
|
||||
_vec.push_back(button);
|
||||
}
|
||||
|
||||
int WindowMessageBox::getButtonNum() const
|
||||
{
|
||||
return _vec.size();
|
||||
}
|
||||
|
||||
WindowMessageBoxButton& WindowMessageBox::getButton(int index)
|
||||
{
|
||||
return _vec.at(index);
|
||||
}
|
||||
|
||||
const WindowMessageBoxButton& WindowMessageBox::getButtonConst(int index) const
|
||||
{
|
||||
return _vec.at(index);
|
||||
}
|
||||
#include "end_code.h"
|
45
SDLWrapper/MessageBox.h
Normal file
45
SDLWrapper/MessageBox.h
Normal file
|
@ -0,0 +1,45 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_MessageBoxType.h"
|
||||
#include <string>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#include "begin_code.h"
|
||||
class WindowMessageBoxButton
|
||||
{
|
||||
public:
|
||||
WindowMessageBoxButton();
|
||||
WindowMessageBoxButton(const std::string& ButtonText,const std::function<void()>& CallbackFunc=[]() {});
|
||||
|
||||
std::string text;
|
||||
std::function<void()> callback;
|
||||
|
||||
/// Default: no hit option set.
|
||||
void setHitAsReturn(bool);
|
||||
void setHitAsEscape(bool);
|
||||
|
||||
bool isHitAsReturn() const;
|
||||
bool isHitAsEscape() const;
|
||||
private:
|
||||
int _hitoption;
|
||||
};
|
||||
|
||||
class WindowMessageBox
|
||||
{
|
||||
public:
|
||||
WindowMessageBox();
|
||||
WindowMessageBox(const std::string& Title,const std::string& Text,MessageBoxType BoxType=MessageBoxType::Information,const std::function<void()>& DefaultCallback=[]() {});
|
||||
|
||||
MessageBoxType boxtype;
|
||||
std::string title;
|
||||
std::string text;
|
||||
std::function<void()> defaultcallback;
|
||||
|
||||
void addButton(const WindowMessageBoxButton& button);
|
||||
int getButtonNum() const;
|
||||
WindowMessageBoxButton& getButton(int index);
|
||||
const WindowMessageBoxButton& getButtonConst(int index) const;
|
||||
private:
|
||||
std::vector<WindowMessageBoxButton> _vec;
|
||||
};
|
||||
#include "end_code.h"
|
112
SDLWrapper/Music.cpp
Normal file
112
SDLWrapper/Music.cpp
Normal file
|
@ -0,0 +1,112 @@
|
|||
#include "Music.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Music::_set(Mix_Music* p)
|
||||
{
|
||||
_music.reset(p,Mix_FreeMusic);
|
||||
}
|
||||
//private
|
||||
void Music::_clear()
|
||||
{
|
||||
_music.reset();
|
||||
}
|
||||
//private
|
||||
Mix_Music* Music::_get() const
|
||||
{
|
||||
return _music.get();
|
||||
}
|
||||
|
||||
Music::Music(const std::string& Filename)
|
||||
{
|
||||
_set(Mix_LoadMUS(Filename.c_str()));
|
||||
}
|
||||
|
||||
bool Music::isReady() const
|
||||
{
|
||||
return (_get()!=nullptr);
|
||||
}
|
||||
|
||||
void Music::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
//static
|
||||
int MusicPlayer::GetDecoderNum()
|
||||
{
|
||||
return Mix_GetNumMusicDecoders();
|
||||
}
|
||||
|
||||
//static
|
||||
std::string MusicPlayer::GetDecoderName(int index)
|
||||
{
|
||||
return std::string(Mix_GetMusicDecoder(index));
|
||||
}
|
||||
|
||||
int MusicPlayer::play(Music music, int loops)
|
||||
{
|
||||
m = music;
|
||||
return Mix_PlayMusic(m._get(), loops);
|
||||
}
|
||||
|
||||
void MusicPlayer::pause()
|
||||
{
|
||||
Mix_PauseMusic();
|
||||
}
|
||||
|
||||
void MusicPlayer::resume()
|
||||
{
|
||||
Mix_ResumeMusic();
|
||||
}
|
||||
|
||||
void MusicPlayer::rewind()
|
||||
{
|
||||
Mix_RewindMusic();
|
||||
}
|
||||
|
||||
int MusicPlayer::stop()
|
||||
{
|
||||
return Mix_HaltMusic();
|
||||
}
|
||||
|
||||
int MusicPlayer::fadeIn(int loops, int ms)
|
||||
{
|
||||
return Mix_FadeInMusic(m._get(), loops, ms);
|
||||
}
|
||||
|
||||
int MusicPlayer::fadeOut(int ms)
|
||||
{
|
||||
return Mix_FadeOutMusic(ms);
|
||||
}
|
||||
|
||||
bool MusicPlayer::isPlaying() const
|
||||
{
|
||||
return (Mix_PlayingMusic() == 1);
|
||||
}
|
||||
|
||||
bool MusicPlayer::isPaused() const
|
||||
{
|
||||
return (Mix_PausedMusic() == 1);
|
||||
}
|
||||
|
||||
int MusicPlayer::isFading() const
|
||||
{
|
||||
switch (Mix_FadingMusic())
|
||||
{
|
||||
case MIX_NO_FADING:
|
||||
return 0;
|
||||
case MIX_FADING_IN:
|
||||
return 1;
|
||||
case MIX_FADING_OUT:
|
||||
return 2;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int MusicPlayer::setPosition(double second)
|
||||
{
|
||||
return Mix_SetMusicPosition(second);
|
||||
}
|
||||
|
||||
#include "end_code.h"
|
49
SDLWrapper/Music.h
Normal file
49
SDLWrapper/Music.h
Normal file
|
@ -0,0 +1,49 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include "ErrorViewer.h"
|
||||
#include "Audio.h"
|
||||
#include "__Noncopyable.h"
|
||||
#include "begin_code.h"
|
||||
/// Forward Declaration
|
||||
class Music
|
||||
{
|
||||
public:
|
||||
Music()=default;
|
||||
Music(const std::string& Filename);
|
||||
bool isReady() const;
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<Mix_Music> _music;
|
||||
void _set(Mix_Music*);
|
||||
void _clear();
|
||||
Mix_Music* _get() const;
|
||||
friend class MusicPlayer;
|
||||
};
|
||||
|
||||
class MusicPlayer : public AudioPlayer, public NonCopyable
|
||||
{
|
||||
public:
|
||||
static int GetDecoderNum();
|
||||
static std::string GetDecoderName(int index);
|
||||
|
||||
/// Play Music. Loop: -1:Infinite, >0:Exact that time.
|
||||
int play(Music music, int loops);
|
||||
void pause();
|
||||
void resume();
|
||||
void rewind();
|
||||
int setPosition(double second);
|
||||
int stop();
|
||||
int fadeIn(int loops, int ms);
|
||||
int fadeOut(int ms);
|
||||
|
||||
bool isPlaying() const;
|
||||
bool isPaused() const;
|
||||
int isFading() const;
|
||||
private:
|
||||
Music m;
|
||||
};
|
||||
|
||||
|
||||
#include "end_code.h"
|
30
SDLWrapper/Point.cpp
Normal file
30
SDLWrapper/Point.cpp
Normal file
|
@ -0,0 +1,30 @@
|
|||
#include "Point.h"
|
||||
#include "begin_code.h"
|
||||
|
||||
Point::Point(int X, int Y)
|
||||
{
|
||||
x = X;
|
||||
y = Y;
|
||||
}
|
||||
|
||||
Point::Point()
|
||||
{
|
||||
x = y = 0;
|
||||
}
|
||||
|
||||
SDL_Point Point::toSDLPoint() const
|
||||
{
|
||||
SDL_Point p;
|
||||
p.x = x;
|
||||
p.y = y;
|
||||
return p;
|
||||
}
|
||||
|
||||
bool Point::inRect(const Rect& rect) const
|
||||
{
|
||||
auto p = toSDLPoint();
|
||||
auto r = rect.toSDLRect();
|
||||
return ( SDL_PointInRect(&p, &r) == SDL_TRUE );
|
||||
}
|
||||
|
||||
#include "end_code.h"
|
14
SDLWrapper/Point.h
Normal file
14
SDLWrapper/Point.h
Normal file
|
@ -0,0 +1,14 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "Rect.h"
|
||||
#include "begin_code.h"
|
||||
class Point
|
||||
{
|
||||
public:
|
||||
int x, y;
|
||||
Point(int X, int Y);
|
||||
Point();
|
||||
SDL_Point toSDLPoint() const;
|
||||
bool inRect(const Rect& rect) const;
|
||||
};
|
||||
#include "end_code.h"
|
38
SDLWrapper/RGBA.cpp
Normal file
38
SDLWrapper/RGBA.cpp
Normal file
|
@ -0,0 +1,38 @@
|
|||
#include "RGBA.h"
|
||||
#include "begin_code.h"
|
||||
RGBA::RGBA(int R, int G, int B, int A)
|
||||
{
|
||||
r = R;
|
||||
g = G;
|
||||
b = B;
|
||||
a = A;
|
||||
}
|
||||
|
||||
RGBA::RGBA(ColorMode mode, int A)
|
||||
{
|
||||
r = mode.r;
|
||||
g = mode.g;
|
||||
b = mode.b;
|
||||
a = A;
|
||||
}
|
||||
|
||||
RGBA::RGBA()
|
||||
{
|
||||
r = g = b = a = 0;
|
||||
}
|
||||
|
||||
SDL_Color RGBA::toSDLColor() const
|
||||
{
|
||||
SDL_Color c;
|
||||
c.r = r;
|
||||
c.g = g;
|
||||
c.b = b;
|
||||
c.a = a;
|
||||
return c;
|
||||
}
|
||||
|
||||
ColorMode RGBA::toColorMode() const
|
||||
{
|
||||
return ColorMode(r, g, b);
|
||||
}
|
||||
#include "end_code.h"
|
17
SDLWrapper/RGBA.h
Normal file
17
SDLWrapper/RGBA.h
Normal file
|
@ -0,0 +1,17 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "ColorMode.h"
|
||||
#include "begin_code.h"
|
||||
|
||||
class RGBA
|
||||
{
|
||||
public:
|
||||
int r, g, b, a;
|
||||
RGBA(int R, int G, int B, int A);
|
||||
RGBA(ColorMode mode, int A);
|
||||
RGBA();
|
||||
SDL_Color toSDLColor() const;
|
||||
ColorMode toColorMode() const;
|
||||
};
|
||||
|
||||
#include "end_code.h"
|
48
SDLWrapper/RWOP.cpp
Normal file
48
SDLWrapper/RWOP.cpp
Normal file
|
@ -0,0 +1,48 @@
|
|||
#include "RWOP.h"
|
||||
#include "begin_code.h"
|
||||
// private
|
||||
void RWOP::_set(SDL_RWops* p)
|
||||
{
|
||||
_op.reset(p,[](SDL_RWops* p)
|
||||
{
|
||||
SDL_RWclose(p);
|
||||
});
|
||||
}
|
||||
|
||||
// private
|
||||
SDL_RWops* RWOP::_get() const
|
||||
{
|
||||
return _op.get();
|
||||
}
|
||||
|
||||
void RWOP::_clear()
|
||||
{
|
||||
_op.reset();
|
||||
}
|
||||
|
||||
RWOP::RWOP(FILE* fp,bool autoclose)
|
||||
{
|
||||
SDL_bool b=autoclose?SDL_TRUE:SDL_FALSE;
|
||||
_set(SDL_RWFromFP(fp,b));
|
||||
}
|
||||
|
||||
RWOP::RWOP(const std::string& filename,const std::string& openmode)
|
||||
{
|
||||
_set(SDL_RWFromFile(filename.c_str(),openmode.c_str()));
|
||||
}
|
||||
|
||||
RWOP::RWOP(const void* mem,int size)
|
||||
{
|
||||
_set(SDL_RWFromConstMem(mem,size));
|
||||
}
|
||||
|
||||
RWOP::RWOP(void* mem,int size)
|
||||
{
|
||||
_set(SDL_RWFromMem(mem,size));
|
||||
}
|
||||
|
||||
void RWOP::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
#include "end_code.h"
|
26
SDLWrapper/RWOP.h
Normal file
26
SDLWrapper/RWOP.h
Normal file
|
@ -0,0 +1,26 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include "begin_code.h"
|
||||
class RWOP
|
||||
{
|
||||
public:
|
||||
RWOP(FILE* fp,bool autoclose);
|
||||
RWOP(const std::string& filename,const std::string& openmode);
|
||||
RWOP(const void* mem,int size);
|
||||
RWOP(void* mem,int size);
|
||||
RWOP()=default;
|
||||
~RWOP()=default;
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_RWops> _op;
|
||||
SDL_RWops* _get() const;
|
||||
void _clear();
|
||||
void _set(SDL_RWops*);
|
||||
friend class Surface;
|
||||
friend class Renderer;
|
||||
};
|
||||
#include "end_code.h"
|
72
SDLWrapper/Rect.cpp
Normal file
72
SDLWrapper/Rect.cpp
Normal file
|
@ -0,0 +1,72 @@
|
|||
#include "Rect.h"
|
||||
|
||||
#include "begin_code.h"
|
||||
|
||||
Rect::Rect(int X, int Y, int W, int H)
|
||||
{
|
||||
x = X;
|
||||
y = Y;
|
||||
w = W;
|
||||
h = H;
|
||||
}
|
||||
|
||||
// explicit
|
||||
Rect::Rect(const SDL_Rect& r):Rect(r.x,r.y,r.w,r.h)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
Rect::Rect()
|
||||
{
|
||||
x = y = w = h = 0;
|
||||
}
|
||||
|
||||
SDL_Rect Rect::toSDLRect() const
|
||||
{
|
||||
SDL_Rect r;
|
||||
r.x = x;
|
||||
r.y = y;
|
||||
r.w = w;
|
||||
r.h = h;
|
||||
return r;
|
||||
}
|
||||
|
||||
bool Rect::isEmpty() const
|
||||
{
|
||||
SDL_Rect r=toSDLRect();
|
||||
return SDL_RectEmpty(&r)==SDL_TRUE;
|
||||
}
|
||||
|
||||
bool Rect::operator == (const Rect& r) const
|
||||
{
|
||||
SDL_Rect a=toSDLRect(),b=r.toSDLRect();
|
||||
return SDL_RectEquals(&a,&b)==SDL_TRUE;
|
||||
}
|
||||
|
||||
bool Rect::hasIntersection(const Rect& r) const
|
||||
{
|
||||
SDL_Rect a=toSDLRect(),b=r.toSDLRect();
|
||||
return SDL_HasIntersection(&a,&b)==SDL_TRUE;
|
||||
}
|
||||
|
||||
Rect Rect::getIntersection(const Rect& r) const
|
||||
{
|
||||
SDL_Rect a=toSDLRect(),b=r.toSDLRect(),c;
|
||||
if(SDL_IntersectRect(&a,&b,&c)==SDL_TRUE)
|
||||
{
|
||||
return Rect(c);
|
||||
}
|
||||
else
|
||||
{
|
||||
return Rect();
|
||||
}
|
||||
}
|
||||
|
||||
Rect Rect::getUnion(const Rect& r) const
|
||||
{
|
||||
SDL_Rect a=toSDLRect(),b=r.toSDLRect(),c;
|
||||
SDL_UnionRect(&a,&b,&c);//void
|
||||
return Rect(c);
|
||||
}
|
||||
|
||||
#include "end_code.h"
|
21
SDLWrapper/Rect.h
Normal file
21
SDLWrapper/Rect.h
Normal file
|
@ -0,0 +1,21 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
|
||||
#include "begin_code.h"
|
||||
|
||||
class Rect
|
||||
{
|
||||
public:
|
||||
int x, y, w, h;
|
||||
Rect(int X, int Y, int W, int H);
|
||||
explicit Rect(const SDL_Rect&);
|
||||
Rect();
|
||||
SDL_Rect toSDLRect() const;
|
||||
bool isEmpty() const;
|
||||
bool operator == (const Rect&) const;
|
||||
bool hasIntersection(const Rect&) const;
|
||||
Rect getIntersection(const Rect&) const;
|
||||
Rect getUnion(const Rect&) const;
|
||||
};
|
||||
|
||||
#include "end_code.h"
|
452
SDLWrapper/Renderer.cpp
Normal file
452
SDLWrapper/Renderer.cpp
Normal file
|
@ -0,0 +1,452 @@
|
|||
#include "Renderer.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
|
||||
//private
|
||||
void Renderer::_set(SDL_Renderer* p)
|
||||
{
|
||||
_rnd.reset(p,SDL_DestroyRenderer);
|
||||
}
|
||||
|
||||
//private
|
||||
void Renderer::_clear()
|
||||
{
|
||||
_rnd.reset();
|
||||
}
|
||||
|
||||
//private
|
||||
SDL_Renderer* Renderer::_get() const
|
||||
{
|
||||
return _rnd.get();
|
||||
}
|
||||
|
||||
Renderer::Renderer(Window& wnd,std::initializer_list<RendererType> RendererFlags) throw (ErrorViewer)
|
||||
{
|
||||
if(createRenderer(wnd,RendererFlags)!=0)
|
||||
{
|
||||
throw ErrorViewer();
|
||||
}
|
||||
}
|
||||
|
||||
int Renderer::createRenderer(Window& wnd,std::initializer_list<RendererType> RendererFlags)
|
||||
{
|
||||
Uint32 flag = 0;
|
||||
for (auto v : RendererFlags)
|
||||
{
|
||||
flag |= _rendertype_caster(v);
|
||||
}
|
||||
return _createRenderer_Real(wnd,flag);
|
||||
}
|
||||
|
||||
int Renderer::setColor(const RGBA& pack)
|
||||
{
|
||||
return SDL_SetRenderDrawColor(_get(), pack.r, pack.g, pack.b, pack.a);
|
||||
}
|
||||
|
||||
RGBA Renderer::getColor() const
|
||||
{
|
||||
Uint8 r, g, b, a;
|
||||
SDL_GetRenderDrawColor(_get(), &r, &g, &b, &a);
|
||||
return RGBA(r, g, b, a);
|
||||
}
|
||||
|
||||
int Renderer::setBlendMode(BlendMode mode)
|
||||
{
|
||||
return SDL_SetRenderDrawBlendMode(_get(), _internal::getSDLBlendModeFromBlendMode(mode));
|
||||
}
|
||||
|
||||
BlendMode Renderer::getBlendMode() const
|
||||
{
|
||||
SDL_BlendMode temp;
|
||||
SDL_GetRenderDrawBlendMode(_get(), &temp);
|
||||
return _internal::getBlendModeFromSDLBlendMode(temp);
|
||||
}
|
||||
|
||||
int Renderer::setTarget(Texture & t)
|
||||
{
|
||||
return SDL_SetRenderTarget(_get(), t._get());
|
||||
}
|
||||
|
||||
int Renderer::setTarget()
|
||||
{
|
||||
return SDL_SetRenderTarget(_get(), nullptr);
|
||||
}
|
||||
|
||||
Texture Renderer::getTarget()
|
||||
{
|
||||
Texture t;
|
||||
t._set_no_delete(SDL_GetRenderTarget(_get()));
|
||||
return t;
|
||||
}
|
||||
|
||||
int Renderer::fillRect(const Rect& rect)
|
||||
{
|
||||
auto inr = rect.toSDLRect();
|
||||
return SDL_RenderFillRect(_get(), &inr);
|
||||
}
|
||||
|
||||
int Renderer::drawRect(const Rect& rect)
|
||||
{
|
||||
auto inr = rect.toSDLRect();
|
||||
return SDL_RenderDrawRect(_get(), &inr);
|
||||
}
|
||||
|
||||
int Renderer::drawPoint(const Point& p)
|
||||
{
|
||||
return SDL_RenderDrawPoint(_get(),p.x,p.y);
|
||||
}
|
||||
|
||||
int Renderer::drawLine(const Point& A,const Point& B)
|
||||
{
|
||||
return SDL_RenderDrawLine(_get(),A.x,A.y,B.x,B.y);
|
||||
}
|
||||
|
||||
int Renderer::fillRects(const SDL_Rect* pRectArray, int n)
|
||||
{
|
||||
return SDL_RenderFillRects(_get(),pRectArray,n);
|
||||
}
|
||||
|
||||
int Renderer::drawRects(const SDL_Rect* pRectArray, int n)
|
||||
{
|
||||
return SDL_RenderDrawRects(_get(),pRectArray,n);
|
||||
}
|
||||
|
||||
int Renderer::drawPoints(const SDL_Point* pPointArray, int n)
|
||||
{
|
||||
return SDL_RenderDrawPoints(_get(),pPointArray,n);
|
||||
}
|
||||
|
||||
int Renderer::drawLines(const SDL_Point* pPointArray, int n)
|
||||
{
|
||||
return SDL_RenderDrawLines(_get(),pPointArray,n);
|
||||
}
|
||||
|
||||
int Renderer::fillRects(const std::vector<SDL_Rect>& rectvec)
|
||||
{
|
||||
return fillRects(rectvec.data(),rectvec.size());
|
||||
}
|
||||
|
||||
int Renderer::drawRects(const std::vector<SDL_Rect>& rectvec)
|
||||
{
|
||||
return drawRects(rectvec.data(),rectvec.size());
|
||||
}
|
||||
|
||||
int Renderer::drawPoints(const std::vector<SDL_Point>& pointvec)
|
||||
{
|
||||
return drawPoints(pointvec.data(),pointvec.size());
|
||||
}
|
||||
|
||||
int Renderer::drawLines(const std::vector<SDL_Point>& pointvec)
|
||||
{
|
||||
return drawLines(pointvec.data(),pointvec.size());
|
||||
}
|
||||
|
||||
int Renderer::setScale(float scaleX, float scaleY)
|
||||
{
|
||||
return SDL_RenderSetScale(_get(),scaleX,scaleY);
|
||||
}
|
||||
|
||||
std::tuple<float,float> Renderer::getScale() const
|
||||
{
|
||||
float sx,sy;
|
||||
SDL_RenderGetScale(_get(),&sx,&sy);
|
||||
return std::make_tuple(sx,sy);
|
||||
}
|
||||
|
||||
int Renderer::setViewport(const Rect& viewport)
|
||||
{
|
||||
auto rect=viewport.toSDLRect();
|
||||
return SDL_RenderSetViewport(_get(),&rect);
|
||||
}
|
||||
|
||||
Rect Renderer::getViewport() const
|
||||
{
|
||||
SDL_Rect rect;
|
||||
SDL_RenderGetViewport(_get(),&rect);
|
||||
return Rect(rect);
|
||||
}
|
||||
|
||||
int Renderer::setLogicalSize(int w, int h)
|
||||
{
|
||||
return SDL_RenderSetLogicalSize(_get(),w,h);
|
||||
}
|
||||
|
||||
Rect Renderer::getLogicalSize() const
|
||||
{
|
||||
int w,h;
|
||||
SDL_RenderGetLogicalSize(_get(),&w,&h);
|
||||
return Rect(0,0,w,h);
|
||||
}
|
||||
|
||||
int Renderer::setClipRect(const Rect& cliprect)
|
||||
{
|
||||
auto r=cliprect.toSDLRect();
|
||||
return SDL_RenderSetClipRect(_get(),&r);
|
||||
}
|
||||
|
||||
Rect Renderer::getClipRect() const
|
||||
{
|
||||
SDL_Rect r;
|
||||
SDL_RenderGetClipRect(_get(),&r);
|
||||
return Rect(r);
|
||||
}
|
||||
|
||||
bool Renderer::isClipEnabled() const
|
||||
{
|
||||
return (SDL_RenderIsClipEnabled(_get())==SDL_TRUE);
|
||||
}
|
||||
|
||||
Rect Renderer::getOutputSize() const
|
||||
{
|
||||
int w,h;
|
||||
SDL_GetRendererOutputSize(_get(),&w,&h);
|
||||
return Rect(0,0,w,h);
|
||||
}
|
||||
|
||||
int Renderer::clear()
|
||||
{
|
||||
return SDL_RenderClear(_get());
|
||||
}
|
||||
|
||||
void Renderer::update()
|
||||
{
|
||||
SDL_RenderPresent(_get());
|
||||
}
|
||||
|
||||
int Renderer::copy(const Texture& t, const Rect& src, const Rect& dst)
|
||||
{
|
||||
SDL_Rect s = src.toSDLRect();
|
||||
SDL_Rect d = dst.toSDLRect();
|
||||
return SDL_RenderCopy(_get(), t._get(), &s, &d);
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Rect& dst)
|
||||
{
|
||||
SDL_Rect d = dst.toSDLRect();
|
||||
return SDL_RenderCopy(_get(), t._get(), NULL, &d);
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Point& lupoint)
|
||||
{
|
||||
return copyTo(t, Rect(lupoint.x, lupoint.y, t.getw(), t.geth()));
|
||||
}
|
||||
|
||||
int Renderer::copyFill(const Texture& t, const Rect& src)
|
||||
{
|
||||
SDL_Rect s = src.toSDLRect();
|
||||
return SDL_RenderCopy(_get(), t._get(), &s, NULL);
|
||||
}
|
||||
|
||||
int Renderer::copyFullFill(const Texture& t)
|
||||
{
|
||||
return SDL_RenderCopy(_get(), t._get(), NULL, NULL);
|
||||
}
|
||||
|
||||
/// ----- Super Copy Extend ----- (Begin)
|
||||
int Renderer::copy(const Texture& t, const Rect& src, const Rect& dst, double angle, FlipMode mode)
|
||||
{
|
||||
auto s=src.toSDLRect();
|
||||
auto d=src.toSDLRect();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),&s,&d,angle,NULL,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Rect& dst, double angle, FlipMode mode)
|
||||
{
|
||||
auto d=dst.toSDLRect();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),NULL,&d,angle,NULL,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Point& lupoint, double angle, FlipMode mode)
|
||||
{
|
||||
return copyTo(t,Rect(lupoint.x,lupoint.y,t.getw(),t.geth()),angle,mode);
|
||||
}
|
||||
|
||||
int Renderer::copyFill(const Texture& t, const Rect& src, double angle, FlipMode mode)
|
||||
{
|
||||
auto s=src.toSDLRect();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),&s,NULL,angle,NULL,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyFullFill(const Texture& t, double angle, FlipMode mode)
|
||||
{
|
||||
return SDL_RenderCopyEx(_get(),t._get(),NULL,NULL,angle,NULL,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copy(const Texture& t, const Rect& src, const Rect& dst, const Point& centerPoint, double angle, FlipMode mode)
|
||||
{
|
||||
auto s=src.toSDLRect();
|
||||
auto d=src.toSDLRect();
|
||||
auto c=centerPoint.toSDLPoint();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),&s,&d,angle,&c,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Rect& dst, const Point& centerPoint, double angle, FlipMode mode)
|
||||
{
|
||||
auto d=dst.toSDLRect();
|
||||
auto c=centerPoint.toSDLPoint();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),NULL,&d,angle,&c,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyTo(const Texture& t, const Point& lupoint, const Point& centerPoint, double angle, FlipMode mode)
|
||||
{
|
||||
return copyTo(t,lupoint,centerPoint,angle,mode);
|
||||
}
|
||||
|
||||
int Renderer::copyFill(const Texture& t, const Rect& src, const Point& centerPoint, double angle, FlipMode mode)
|
||||
{
|
||||
auto s=src.toSDLRect();
|
||||
auto c=centerPoint.toSDLPoint();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),&s,NULL,angle,&c,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
|
||||
int Renderer::copyFullFill(const Texture& t, const Point& centerPoint, double angle, FlipMode mode)
|
||||
{
|
||||
auto c=centerPoint.toSDLPoint();
|
||||
return SDL_RenderCopyEx(_get(),t._get(),NULL,NULL,angle,&c,_internal::getSDLRendererFlipFromFlipMode(mode));
|
||||
}
|
||||
/// ----- Super Copy Extend ----- (End)
|
||||
|
||||
int Renderer::supercopy(const Texture& t,
|
||||
bool srcfull,const Rect& src,bool dstfull,const Rect& dst,
|
||||
double angle,
|
||||
bool haspoint,const Point& center,FlipMode mode)
|
||||
{
|
||||
SDL_Rect R1,R2;
|
||||
SDL_Point P;
|
||||
SDL_Rect* pR1=nullptr;
|
||||
SDL_Rect* pR2=nullptr;
|
||||
SDL_Point* pPoint=nullptr;
|
||||
SDL_RendererFlip flip;
|
||||
if(srcfull)
|
||||
{
|
||||
R1=src.toSDLRect();
|
||||
pR1=&R1;
|
||||
}
|
||||
if(dstfull)
|
||||
{
|
||||
R2=dst.toSDLRect();
|
||||
pR2=&R2;
|
||||
}
|
||||
if(haspoint)
|
||||
{
|
||||
P=center.toSDLPoint();
|
||||
pPoint=&P;
|
||||
}
|
||||
|
||||
flip=_internal::getSDLRendererFlipFromFlipMode(mode);
|
||||
|
||||
return SDL_RenderCopyEx(_get(),t._get(),pR1,pR2,angle,pPoint,flip);
|
||||
}
|
||||
|
||||
Texture Renderer::render(const Surface& surf) const throw(ErrorViewer)
|
||||
{
|
||||
Texture t;
|
||||
SDL_Texture* temp = SDL_CreateTextureFromSurface(_get(), surf._get());
|
||||
if (temp == nullptr)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
t._set(temp);
|
||||
return t;
|
||||
}
|
||||
|
||||
Texture Renderer::loadTexture(const std::string& FileName) const throw(ErrorViewer)
|
||||
{
|
||||
Texture t;
|
||||
SDL_Texture* temp = IMG_LoadTexture(_get(), FileName.c_str());
|
||||
if (temp == nullptr)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
t._set(temp);
|
||||
return t;
|
||||
}
|
||||
|
||||
Texture Renderer::loadTextureRW(const RWOP& rwop) const throw (ErrorViewer)
|
||||
{
|
||||
Texture t;
|
||||
SDL_Texture* temp=IMG_LoadTexture_RW(_get(),rwop._get(),0);
|
||||
if (temp == nullptr)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
t._set(temp);
|
||||
return t;
|
||||
}
|
||||
|
||||
Texture Renderer::createTexture(int Width, int Height) const throw(ErrorViewer)
|
||||
{
|
||||
SDL_Texture* temp = SDL_CreateTexture(_get(), SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, Width, Height);
|
||||
if (temp == NULL)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
Texture t;
|
||||
t._set(temp);
|
||||
return t;
|
||||
}
|
||||
|
||||
bool Renderer::isRenderTargetSupported() const
|
||||
{
|
||||
return (SDL_RenderTargetSupported(_get())==SDL_TRUE);
|
||||
}
|
||||
|
||||
bool Renderer::isReady() const
|
||||
{
|
||||
return (_get() != nullptr);
|
||||
}
|
||||
|
||||
void Renderer::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
//static
|
||||
int Renderer::GetDriversNum()
|
||||
{
|
||||
return SDL_GetNumRenderDrivers();
|
||||
}
|
||||
|
||||
// private
|
||||
Uint32 Renderer::_rendertype_caster(RendererType Type)
|
||||
{
|
||||
switch(Type)
|
||||
{
|
||||
case RendererType::Accelerated:
|
||||
return SDL_RENDERER_ACCELERATED;
|
||||
case RendererType::PresentSync:
|
||||
return SDL_RENDERER_PRESENTVSYNC;
|
||||
case RendererType::Software:
|
||||
return SDL_RENDERER_SOFTWARE;
|
||||
case RendererType::TargetTexture:
|
||||
return SDL_RENDERER_TARGETTEXTURE;
|
||||
}
|
||||
|
||||
/// If an error occurs, return 0 by default.
|
||||
return 0;
|
||||
}
|
||||
|
||||
// private
|
||||
int Renderer::_createRenderer_Real(Window& wnd,Uint32 flags)
|
||||
{
|
||||
SDL_Renderer* pSDLRnd=SDL_CreateRenderer(wnd._get(), -1, flags);
|
||||
if(pSDLRnd!=nullptr)
|
||||
{
|
||||
_set(pSDLRnd);
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
#include "end_code.h"
|
138
SDLWrapper/Renderer.h
Normal file
138
SDLWrapper/Renderer.h
Normal file
|
@ -0,0 +1,138 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_RendererType.h"
|
||||
#include "_FlipMode.h"
|
||||
#include "Window.h"
|
||||
#include "Surface.h"
|
||||
#include "Texture.h"
|
||||
#include <initializer_list>
|
||||
#include "begin_code.h"
|
||||
class Renderer
|
||||
{
|
||||
public:
|
||||
Renderer() = default;
|
||||
Renderer(Window& wnd,std::initializer_list<RendererType> RendererFlags = { RendererType::Accelerated,RendererType::TargetTexture }) throw (ErrorViewer);
|
||||
~Renderer() = default;
|
||||
|
||||
/// If Renderer is current not ready, setRenderer will create Renderer.
|
||||
/// Otherwise, setRenderer will fail.
|
||||
int createRenderer(Window& wnd,RendererType Type)
|
||||
{
|
||||
int flagcalc=0;
|
||||
return _createRenderer(wnd,flagcalc,Type);
|
||||
}
|
||||
|
||||
template<typename... Args>
|
||||
int createRenderer(Window& wnd,RendererType Type,Args&&... args)
|
||||
{
|
||||
int flagcalc=0;
|
||||
return _createRenderer(wnd,flagcalc,Type,std::forward<RendererType>(args...));
|
||||
}
|
||||
|
||||
int createRenderer(Window& wnd,std::initializer_list<RendererType>);
|
||||
|
||||
int setColor(const RGBA& pack);
|
||||
RGBA getColor() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
BlendMode getBlendMode() const;
|
||||
|
||||
int setTarget(Texture& t);
|
||||
int setTarget();
|
||||
Texture getTarget();
|
||||
|
||||
int fillRect(const Rect& rect);
|
||||
int drawRect(const Rect& rect);
|
||||
int drawPoint(const Point& p);
|
||||
int drawLine(const Point& A,const Point& B);
|
||||
|
||||
/// Experimental
|
||||
int fillRects(const SDL_Rect* pRectArray,int n);
|
||||
int drawRects(const SDL_Rect* pRectArray,int n);
|
||||
int drawPoints(const SDL_Point* pPointArray,int n);
|
||||
int drawLines(const SDL_Point* pPointArray,int n);
|
||||
/// Experimental
|
||||
int fillRects(const std::vector<SDL_Rect>& rectvec);
|
||||
int drawRects(const std::vector<SDL_Rect>& rectvec);
|
||||
int drawPoints(const std::vector<SDL_Point>& pointvec);
|
||||
int drawLines(const std::vector<SDL_Point>& pointvec);
|
||||
|
||||
int setScale(float scaleX,float scaleY);
|
||||
std::tuple<float,float> getScale() const;
|
||||
|
||||
int setViewport(const Rect& viewport);
|
||||
Rect getViewport() const;
|
||||
|
||||
int setLogicalSize(int w,int h);
|
||||
Rect getLogicalSize() const;
|
||||
|
||||
int setClipRect(const Rect& cliprect);
|
||||
Rect getClipRect() const;
|
||||
bool isClipEnabled() const;
|
||||
|
||||
Rect getOutputSize() const;
|
||||
|
||||
int clear();
|
||||
void update();
|
||||
|
||||
int copy(const Texture& t, const Rect& src, const Rect& dst);
|
||||
int copyTo(const Texture& t, const Rect& dst);
|
||||
int copyTo(const Texture& t, const Point& lupoint);
|
||||
int copyFill(const Texture& t, const Rect& src);
|
||||
int copyFullFill(const Texture& t);
|
||||
|
||||
/// Super copy without center point.
|
||||
int copy(const Texture& t, const Rect& src, const Rect& dst,double angle,FlipMode mode);
|
||||
int copyTo(const Texture& t, const Rect& dst,double angle,FlipMode mode);
|
||||
int copyTo(const Texture& t, const Point& lupoint,double angle,FlipMode mode);
|
||||
int copyFill(const Texture& t, const Rect& src,double angle,FlipMode mode);
|
||||
int copyFullFill(const Texture& t,double angle,FlipMode mode);
|
||||
/// Super copy with center point
|
||||
int copy(const Texture& t, const Rect& src, const Rect& dst,const Point& centerPoint,double angle,FlipMode mode);
|
||||
int copyTo(const Texture& t, const Rect& dst,const Point& centerPoint,double angle,FlipMode mode);
|
||||
int copyTo(const Texture& t, const Point& lupoint,const Point& centerPoint,double angle,FlipMode mode);
|
||||
int copyFill(const Texture& t, const Rect& src,const Point& centerPoint,double angle,FlipMode mode);
|
||||
int copyFullFill(const Texture& t,const Point& centerPoint,double angle,FlipMode mode);
|
||||
|
||||
/// Reserved for compatibility
|
||||
int supercopy(const Texture& t,
|
||||
bool srcfull,const Rect& src,bool dstfull,const Rect& dst,
|
||||
double angle,
|
||||
bool haspoint,const Point& center,FlipMode mode);
|
||||
|
||||
Texture render(const Surface& surf) const throw (ErrorViewer);
|
||||
Texture loadTexture(const std::string& FileName) const throw(ErrorViewer);
|
||||
Texture loadTextureRW(const RWOP& rwop) const throw(ErrorViewer);
|
||||
Texture createTexture(int Width, int Height) const throw(ErrorViewer);
|
||||
|
||||
bool isRenderTargetSupported() const;
|
||||
bool isReady() const;
|
||||
|
||||
void release();
|
||||
|
||||
/// Experimental
|
||||
static int GetDriversNum();
|
||||
protected:
|
||||
template<typename... Args>
|
||||
int _createRenderer(Window& wnd,int& refcalc,RendererType Type,Args&&... args)
|
||||
{
|
||||
refcalc|=_rendertype_caster(Type);
|
||||
return _createRenderer(wnd,refcalc,args...);
|
||||
}
|
||||
|
||||
// template<>
|
||||
int _createRenderer(Window& wnd,int& refcalc,RendererType Type)
|
||||
{
|
||||
refcalc|=_rendertype_caster(Type);
|
||||
return _createRenderer_Real(wnd,refcalc);
|
||||
}
|
||||
private:
|
||||
std::shared_ptr<SDL_Renderer> _rnd;
|
||||
|
||||
int _createRenderer_Real(Window& wnd,Uint32 flags);
|
||||
Uint32 _rendertype_caster(RendererType);
|
||||
|
||||
void _set(SDL_Renderer*);
|
||||
void _clear();
|
||||
SDL_Renderer* _get() const;
|
||||
};
|
||||
#include "end_code.h"
|
243
SDLWrapper/SDLSystem.cpp
Normal file
243
SDLWrapper/SDLSystem.cpp
Normal file
|
@ -0,0 +1,243 @@
|
|||
#include "SDLSystem.h"
|
||||
#include "begin_code.h"
|
||||
//static
|
||||
int SDLSystem::SDLInit()
|
||||
{
|
||||
return SDL_Init(SDL_INIT_EVERYTHING);
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::SDLQuit()
|
||||
{
|
||||
SDL_Quit();
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::IMGInit()
|
||||
{
|
||||
return IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG);
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::IMGQuit()
|
||||
{
|
||||
IMG_Quit();
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::TTFInit()
|
||||
{
|
||||
return TTF_Init();
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::TTFQuit()
|
||||
{
|
||||
TTF_Quit();
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::MixInit()
|
||||
{
|
||||
return Mix_Init(MIX_INIT_MP3);
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::MixQuit()
|
||||
{
|
||||
Mix_Quit();
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::Init()
|
||||
{
|
||||
SDLInit();
|
||||
IMGInit();
|
||||
TTFInit();
|
||||
MixInit();
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::Quit()
|
||||
{
|
||||
MixQuit();
|
||||
TTFQuit();
|
||||
IMGQuit();
|
||||
SDLQuit();
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::Delay(int ms)
|
||||
{
|
||||
SDL_Delay(ms);
|
||||
}
|
||||
|
||||
//static
|
||||
PowerState SDLSystem::GetPowerState()
|
||||
{
|
||||
SDL_PowerState ret=SDL_GetPowerInfo(NULL,NULL);
|
||||
switch(ret)
|
||||
{
|
||||
case SDL_POWERSTATE_ON_BATTERY:
|
||||
return PowerState::OnBattery;
|
||||
case SDL_POWERSTATE_NO_BATTERY:
|
||||
return PowerState::NoBattery;
|
||||
case SDL_POWERSTATE_CHARGING:
|
||||
return PowerState::Charging;
|
||||
case SDL_POWERSTATE_CHARGED:
|
||||
return PowerState::Charged;
|
||||
|
||||
case SDL_POWERSTATE_UNKNOWN:
|
||||
default:
|
||||
return PowerState::Unknown;
|
||||
}
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::GetPowerLifeLeft()
|
||||
{
|
||||
int i;
|
||||
SDL_GetPowerInfo(&i,NULL);
|
||||
return i;
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::GetPowerPrecentageLeft()
|
||||
{
|
||||
int i;
|
||||
SDL_GetPowerInfo(NULL,&i);
|
||||
return i;
|
||||
}
|
||||
|
||||
//static
|
||||
Platform SDLSystem::GetPlatform()
|
||||
{
|
||||
std::string s(SDL_GetPlatform());
|
||||
if(s=="Windows")
|
||||
{
|
||||
return Platform::Windows;
|
||||
}
|
||||
else if(s=="Mac OS X")
|
||||
{
|
||||
return Platform::MacOS;
|
||||
}
|
||||
else if(s=="Linux")
|
||||
{
|
||||
return Platform::Linux;
|
||||
}
|
||||
else if(s=="iOS")
|
||||
{
|
||||
return Platform::iOS;
|
||||
}
|
||||
else if(s=="Android")
|
||||
{
|
||||
return Platform::Android;
|
||||
}
|
||||
else
|
||||
{
|
||||
return Platform::Unknown;
|
||||
}
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::StartTextInput()
|
||||
{
|
||||
SDL_StartTextInput();
|
||||
}
|
||||
|
||||
//static
|
||||
bool SDLSystem::IsTextInputActive()
|
||||
{
|
||||
return SDL_IsTextInputActive()==SDL_TRUE;
|
||||
}
|
||||
|
||||
//static
|
||||
void SDLSystem::StopTextInput()
|
||||
{
|
||||
SDL_StopTextInput();
|
||||
}
|
||||
|
||||
//static
|
||||
bool SDLSystem::HasScreenKeyboardSupport()
|
||||
{
|
||||
return SDL_HasScreenKeyboardSupport()==SDL_TRUE;
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetSDLCompileVersion()
|
||||
{
|
||||
SDL_version ver;
|
||||
SDL_VERSION(&ver);
|
||||
return std::make_tuple(ver.major,ver.minor,ver.patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetSDLLinkedVersion()
|
||||
{
|
||||
SDL_version ver;
|
||||
SDL_GetVersion(&ver);
|
||||
return std::make_tuple(ver.major,ver.minor,ver.patch);
|
||||
}
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetIMGCompileVersion()
|
||||
{
|
||||
SDL_version ver;
|
||||
SDL_IMAGE_VERSION(&ver);
|
||||
return std::make_tuple(ver.major,ver.minor,ver.patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetIMGLinkedVersion()
|
||||
{
|
||||
const SDL_version* ptr=IMG_Linked_Version();
|
||||
return std::make_tuple(ptr->major,ptr->minor,ptr->patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetMixCompileVersion()
|
||||
{
|
||||
SDL_version ver;
|
||||
SDL_MIXER_VERSION(&ver);
|
||||
return std::make_tuple(ver.major,ver.minor,ver.patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetMixLinkedVersion()
|
||||
{
|
||||
const SDL_version* ptr=Mix_Linked_Version();
|
||||
return std::make_tuple(ptr->major,ptr->minor,ptr->patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetTTFCompileVersion()
|
||||
{
|
||||
SDL_version ver;
|
||||
SDL_TTF_VERSION(&ver);
|
||||
return std::make_tuple(ver.major,ver.minor,ver.patch);
|
||||
}
|
||||
|
||||
//static
|
||||
std::tuple<int,int,int> SDLSystem::GetTTFLinkedVersion()
|
||||
{
|
||||
const SDL_version* ptr=TTF_Linked_Version();
|
||||
return std::make_tuple(ptr->major,ptr->minor,ptr->patch);
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::GetCPUCount()
|
||||
{
|
||||
return SDL_GetCPUCount();
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::GetCPUCacheLineSize()
|
||||
{
|
||||
return SDL_GetCPUCacheLineSize();
|
||||
}
|
||||
|
||||
//static
|
||||
int SDLSystem::GetSystemRAM()
|
||||
{
|
||||
return SDL_GetSystemRAM();
|
||||
}
|
||||
#include "end_code.h"
|
65
SDLWrapper/SDLSystem.h
Normal file
65
SDLWrapper/SDLSystem.h
Normal file
|
@ -0,0 +1,65 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_PowerState.h"
|
||||
#include "_Platform.h"
|
||||
#include <tuple>
|
||||
#include <string>
|
||||
#include "begin_code.h"
|
||||
class SDLSystem
|
||||
{
|
||||
public:
|
||||
static int SDLInit();
|
||||
static void SDLQuit();
|
||||
static int IMGInit();
|
||||
static void IMGQuit();
|
||||
static int TTFInit();
|
||||
static void TTFQuit();
|
||||
static int MixInit();
|
||||
static void MixQuit();
|
||||
|
||||
static void Init();
|
||||
static void Quit();
|
||||
|
||||
static void Delay(int ms);
|
||||
|
||||
static PowerState GetPowerState();
|
||||
static int GetPowerLifeLeft();
|
||||
static int GetPowerPrecentageLeft();
|
||||
|
||||
static Platform GetPlatform();
|
||||
|
||||
static void StartTextInput();
|
||||
static bool IsTextInputActive();
|
||||
static void StopTextInput();
|
||||
|
||||
static bool HasScreenKeyboardSupport();
|
||||
|
||||
static std::tuple<int,int,int> GetSDLCompileVersion();
|
||||
static std::tuple<int,int,int> GetSDLLinkedVersion();
|
||||
|
||||
static std::tuple<int,int,int> GetIMGCompileVersion();
|
||||
static std::tuple<int,int,int> GetIMGLinkedVersion();
|
||||
|
||||
static std::tuple<int,int,int> GetMixCompileVersion();
|
||||
static std::tuple<int,int,int> GetMixLinkedVersion();
|
||||
|
||||
static std::tuple<int,int,int> GetTTFCompileVersion();
|
||||
static std::tuple<int,int,int> GetTTFLinkedVersion();
|
||||
|
||||
static int GetCPUCount();
|
||||
static int GetCPUCacheLineSize();
|
||||
/// RAM is calculated in MB.
|
||||
static int GetSystemRAM();
|
||||
|
||||
class Android
|
||||
{
|
||||
public:
|
||||
static std::string GetInternal();
|
||||
static bool ExternalAvaliable();
|
||||
static bool CanReadExternal();
|
||||
static bool CanWriteExternal();
|
||||
static std::string GetExternal();
|
||||
static void* GetJNIEnv();
|
||||
};
|
||||
};
|
||||
#include "end_code.h"
|
67
SDLWrapper/SharedLibrary.cpp
Normal file
67
SDLWrapper/SharedLibrary.cpp
Normal file
|
@ -0,0 +1,67 @@
|
|||
#include "SharedLibrary.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void* SharedLibrary::_get() const
|
||||
{
|
||||
return _obj.get();
|
||||
}
|
||||
|
||||
//private
|
||||
void SharedLibrary::_set(void* ptr)
|
||||
{
|
||||
_obj.reset(ptr,SDL_UnloadObject);
|
||||
}
|
||||
|
||||
//private
|
||||
void SharedLibrary::_clear()
|
||||
{
|
||||
_obj.reset();
|
||||
}
|
||||
|
||||
SharedLibrary::SharedLibrary()
|
||||
{
|
||||
_obj=nullptr;
|
||||
}
|
||||
|
||||
SharedLibrary::SharedLibrary(const std::string& Filename)
|
||||
{
|
||||
_obj=nullptr;
|
||||
load(Filename);
|
||||
}
|
||||
|
||||
int SharedLibrary::load(const std::string& Filename)
|
||||
{
|
||||
if(_get()!=nullptr) return -1; /// Loaded
|
||||
else
|
||||
{
|
||||
void* ptr=SDL_LoadObject(Filename.c_str());
|
||||
if(ptr)
|
||||
{
|
||||
_set(ptr);
|
||||
return 0; /// Success
|
||||
}
|
||||
else return -2; /// Failed to load
|
||||
}
|
||||
}
|
||||
|
||||
int SharedLibrary::unload()
|
||||
{
|
||||
if(_get()!=nullptr)
|
||||
{
|
||||
_clear();
|
||||
return 0; /// Success to unload
|
||||
}
|
||||
else return -1; /// Not Loaded.
|
||||
}
|
||||
|
||||
void* SharedLibrary::get(const std::string& FunctionName) const
|
||||
{
|
||||
if(_get()==nullptr) return nullptr;
|
||||
else return SDL_LoadFunction(_get(),FunctionName.c_str());
|
||||
}
|
||||
|
||||
void SharedLibrary::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
#include "end_code.h"
|
29
SDLWrapper/SharedLibrary.h
Normal file
29
SDLWrapper/SharedLibrary.h
Normal file
|
@ -0,0 +1,29 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include "begin_code.h"
|
||||
class SharedLibrary
|
||||
{
|
||||
public:
|
||||
SharedLibrary();
|
||||
SharedLibrary(const std::string& Filename);
|
||||
~SharedLibrary()=default;
|
||||
int load(const std::string& Filename);
|
||||
int unload();
|
||||
|
||||
template<typename ReturnType,typename... Arguments>
|
||||
std::function<ReturnType(Arguments...)> get(const std::string& FunctionName)
|
||||
{
|
||||
return std::function<ReturnType(Arguments...)>(reinterpret_cast<ReturnType(*)(Arguments...)>(get(FunctionName)));
|
||||
}
|
||||
|
||||
void* get(const std::string& FunctionName) const;
|
||||
void release();
|
||||
private:
|
||||
void* _get() const;
|
||||
void _set(void*);
|
||||
void _clear();
|
||||
std::shared_ptr<void> _obj;
|
||||
};
|
||||
#include "end_code.h"
|
168
SDLWrapper/Sound.cpp
Normal file
168
SDLWrapper/Sound.cpp
Normal file
|
@ -0,0 +1,168 @@
|
|||
#include "Sound.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Sound::_set(Mix_Chunk* p)
|
||||
{
|
||||
_sound.reset(p,Mix_FreeChunk);
|
||||
}
|
||||
//private
|
||||
void Sound::_clear()
|
||||
{
|
||||
_sound.reset();
|
||||
}
|
||||
//private
|
||||
Mix_Chunk* Sound::_get() const
|
||||
{
|
||||
return _sound.get();
|
||||
}
|
||||
|
||||
Sound::Sound(const std::string& WAVFilename)
|
||||
{
|
||||
_set(Mix_LoadWAV(WAVFilename.c_str()));
|
||||
}
|
||||
|
||||
bool Sound::isReady() const
|
||||
{
|
||||
return (_get()!=nullptr);
|
||||
}
|
||||
|
||||
void Sound::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
//private
|
||||
void Channel::_set(int ChannelID)
|
||||
{
|
||||
_id=ChannelID;
|
||||
}
|
||||
//private
|
||||
int Channel::_get() const
|
||||
{
|
||||
return _id;
|
||||
}
|
||||
//private
|
||||
void Channel::_clear()
|
||||
{
|
||||
_id=-1;
|
||||
}
|
||||
//protected
|
||||
Channel::Channel()
|
||||
{
|
||||
_id=-1;
|
||||
}
|
||||
|
||||
Channel& Channel::playSound(Sound sound, int loops) throw (ErrorViewer)
|
||||
{
|
||||
int cret=Mix_PlayChannel(_get(),sound._get(),loops);
|
||||
if(cret==-1)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
_set(cret);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Channel& Channel::fadeIn(Sound sound, int loops, int ms) throw (ErrorViewer)
|
||||
{
|
||||
int cret=Mix_FadeInChannel(_get(),sound._get(),loops,ms);
|
||||
if(cret==-1)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
_set(cret);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
int Channel::fadeOut(int ms)
|
||||
{
|
||||
return Mix_FadeOutChannel(_get(), ms);
|
||||
}
|
||||
|
||||
void Channel::pause()
|
||||
{
|
||||
Mix_Pause(_get());
|
||||
}
|
||||
|
||||
void Channel::resume()
|
||||
{
|
||||
Mix_Resume(_get());
|
||||
}
|
||||
|
||||
int Channel::stop()
|
||||
{
|
||||
return Mix_HaltChannel(_get());
|
||||
}
|
||||
|
||||
int Channel::setPanning(uint8_t left, uint8_t right)
|
||||
{
|
||||
return Mix_SetPanning(_get(),left,right);
|
||||
}
|
||||
|
||||
int Channel::setPosition(int16_t angle, uint8_t distance)
|
||||
{
|
||||
return Mix_SetPosition(_get(),angle,distance);
|
||||
}
|
||||
|
||||
int Channel::setDistance(uint8_t distance)
|
||||
{
|
||||
return Mix_SetDistance(_get(),distance);
|
||||
}
|
||||
|
||||
int Channel::setReverseStereo(int flip)
|
||||
{
|
||||
return Mix_SetReverseStereo(_get(),flip);
|
||||
}
|
||||
|
||||
int Channel::addEffect(Mix_EffectFunc_t f, Mix_EffectDone_t d, void* arg)
|
||||
{
|
||||
return Mix_RegisterEffect(_get(),f,d,arg);
|
||||
}
|
||||
|
||||
int Channel::removeEffect(Mix_EffectFunc_t f)
|
||||
{
|
||||
return Mix_UnregisterEffect(_get(),f);
|
||||
}
|
||||
|
||||
int Channel::removeAllEffect()
|
||||
{
|
||||
return Mix_UnregisterAllEffects(_get());
|
||||
}
|
||||
|
||||
|
||||
//static
|
||||
int SoundPlayer::GetDecoderNum()
|
||||
{
|
||||
return Mix_GetNumChunkDecoders();
|
||||
}
|
||||
|
||||
//static
|
||||
std::string SoundPlayer::GetDecoderName(int index)
|
||||
{
|
||||
return std::string(Mix_GetChunkDecoder(index));
|
||||
}
|
||||
|
||||
SoundPlayer::SoundPlayer(int Channels)
|
||||
{
|
||||
Mix_AllocateChannels(Channels);
|
||||
}
|
||||
|
||||
Channel SoundPlayer::playSound(Sound sound, int loops) throw(ErrorViewer)
|
||||
{
|
||||
Channel c;
|
||||
c.playSound(sound,loops);
|
||||
return c;
|
||||
}
|
||||
|
||||
Channel SoundPlayer::fadeIn(Sound sound, int loops, int ms) throw(ErrorViewer)
|
||||
{
|
||||
Channel c;
|
||||
c.fadeIn(sound,loops,ms);
|
||||
return c;
|
||||
}
|
||||
#include "end_code.h"
|
66
SDLWrapper/Sound.h
Normal file
66
SDLWrapper/Sound.h
Normal file
|
@ -0,0 +1,66 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include "Audio.h"
|
||||
#include "ErrorViewer.h"
|
||||
#include "begin_code.h"
|
||||
class Sound
|
||||
{
|
||||
public:
|
||||
Sound() = default;
|
||||
Sound(const std::string& WAVFilename);
|
||||
bool isReady() const;
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<Mix_Chunk> _sound;
|
||||
void _set(Mix_Chunk*);
|
||||
void _clear();
|
||||
Mix_Chunk* _get() const;
|
||||
|
||||
friend class Channel;
|
||||
};
|
||||
|
||||
class Channel
|
||||
{
|
||||
public:
|
||||
Channel& playSound(Sound sound,int loops) throw (ErrorViewer);
|
||||
Channel& fadeIn(Sound sound,int loops,int ms) throw (ErrorViewer);
|
||||
|
||||
int fadeOut(int ms);
|
||||
void pause();
|
||||
void resume();
|
||||
int stop();
|
||||
|
||||
/// Experimental
|
||||
int setPanning(uint8_t left,uint8_t right);
|
||||
int setPosition(int16_t angle,uint8_t distance);
|
||||
int setDistance(uint8_t distance);
|
||||
int setReverseStereo(int flip);
|
||||
|
||||
/// Experimental: Direct Add/Remove Effect
|
||||
int addEffect(Mix_EffectFunc_t f, Mix_EffectDone_t d, void *arg);
|
||||
int removeEffect(Mix_EffectFunc_t f);
|
||||
int removeAllEffect();
|
||||
protected:
|
||||
Channel();
|
||||
private:
|
||||
void _set(int ChannelID);
|
||||
int _get() const;
|
||||
void _clear();
|
||||
|
||||
int _id;
|
||||
friend class SoundPlayer;
|
||||
};
|
||||
|
||||
class SoundPlayer : public AudioPlayer
|
||||
{
|
||||
public:
|
||||
static int GetDecoderNum();
|
||||
static std::string GetDecoderName(int index);
|
||||
|
||||
SoundPlayer(int NumChannels = 16);
|
||||
Channel playSound(Sound sound, int loops) throw (ErrorViewer);
|
||||
Channel fadeIn(Sound sound, int loops, int ms) throw (ErrorViewer);
|
||||
};
|
||||
#include "end_code.h"
|
359
SDLWrapper/Surface.cpp
Normal file
359
SDLWrapper/Surface.cpp
Normal file
|
@ -0,0 +1,359 @@
|
|||
#include "Surface.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Surface::_set(SDL_Surface* p)
|
||||
{
|
||||
_surf.reset(p,SDL_FreeSurface);
|
||||
}
|
||||
|
||||
//private
|
||||
void Surface::_clear()
|
||||
{
|
||||
_surf.reset();
|
||||
}
|
||||
|
||||
//private
|
||||
SDL_Surface* Surface::_get() const
|
||||
{
|
||||
return _surf.get();
|
||||
}
|
||||
|
||||
//private
|
||||
void Surface::_set_no_delete(SDL_Surface* p)
|
||||
{
|
||||
_surf.reset(p,[](SDL_Surface*) {});
|
||||
}
|
||||
|
||||
Surface::Surface(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask) throw(ErrorViewer)
|
||||
{
|
||||
if(createAs(width,height,depth,Rmask,Gmask,Bmask,Amask)!=0)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
Surface::Surface(int width,int height,int depth,RGBA maskPack) throw (ErrorViewer)
|
||||
: Surface(width,height,depth,maskPack.r,maskPack.g,maskPack.b,maskPack.a)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
Surface::Surface(int width,int height,int depth,Uint32 surfaceFormat) throw(ErrorViewer)
|
||||
{
|
||||
if(createAs(width,height,depth,surfaceFormat)!=0)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
Surface::Surface(const std::string& filename) throw(ErrorViewer)
|
||||
{
|
||||
if(loadAs(filename)!=0)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
Surface::Surface(const RWOP& rwop) throw (ErrorViewer)
|
||||
{
|
||||
if(loadAs(rwop)!=0)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
//static
|
||||
Surface Surface::load(const std::string& filename)
|
||||
{
|
||||
Surface s;
|
||||
s.loadAs(filename);
|
||||
return s;
|
||||
}
|
||||
|
||||
//static
|
||||
Surface Surface::load(const RWOP& rwop)
|
||||
{
|
||||
Surface s;
|
||||
s.loadAs(rwop);
|
||||
return s;
|
||||
}
|
||||
|
||||
//static
|
||||
Surface Surface::create(int width, int height, int depth, int Rmask, int Gmask, int Bmask, int Amask)
|
||||
{
|
||||
Surface s;
|
||||
s.create(width,height,depth,Rmask,Gmask,Bmask,Amask);
|
||||
return s;
|
||||
}
|
||||
|
||||
//static
|
||||
Surface Surface::create(int width, int height, int depth, Uint32 surfaceFormat)
|
||||
{
|
||||
Surface s;
|
||||
s.create(width,height,depth,surfaceFormat);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
int Surface::loadAs(const std::string& filename)
|
||||
{
|
||||
SDL_Surface* temp=IMG_Load(filename.c_str());
|
||||
if(temp==nullptr)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_set(temp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int Surface::loadAs(const RWOP& rwop)
|
||||
{
|
||||
SDL_Surface* temp=IMG_Load_RW(rwop._get(),0);
|
||||
if(temp==nullptr)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_set(temp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int Surface::createAs(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask)
|
||||
{
|
||||
SDL_Surface* temp=SDL_CreateRGBSurface(0,width,height,depth,Rmask,Gmask,Bmask,Amask);
|
||||
if(temp==nullptr)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_set(temp);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int Surface::createAs(int width,int height,int depth,Uint32 surfaceFormat)
|
||||
{
|
||||
/// FIXME: This Function is available from SDL2.0.5. But the linker report a undefined reference.
|
||||
|
||||
/*
|
||||
SDL_Surface* temp=SDL_CreateRGBSurfaceWithFormat(0,width,height,depth,surfaceFormat);
|
||||
if(temp==nullptr)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_set(temp);
|
||||
return 0;
|
||||
}
|
||||
*/
|
||||
|
||||
SDL_SetError("[MiniEngine] SDL_CreateRGBSurfaceWithFormat Not Linked.");
|
||||
return -1;
|
||||
}
|
||||
|
||||
int Surface::getw() const
|
||||
{
|
||||
if(_get()!=nullptr)
|
||||
{
|
||||
return _get()->w;
|
||||
}
|
||||
else
|
||||
{
|
||||
/// return -1 on null surface pointer
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int Surface::geth() const
|
||||
{
|
||||
if(_get()!=nullptr)
|
||||
{
|
||||
return _get()->h;
|
||||
}
|
||||
else
|
||||
{
|
||||
/// return -1 on null surface pointer
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
BlendMode Surface::getBlendMode() const
|
||||
{
|
||||
SDL_BlendMode temp;
|
||||
/// FIXME: return value are ignored.
|
||||
SDL_GetSurfaceBlendMode(_get(),&temp);
|
||||
return _internal::getBlendModeFromSDLBlendMode(temp);
|
||||
}
|
||||
|
||||
int Surface::setBlendMode(BlendMode mode)
|
||||
{
|
||||
return SDL_SetSurfaceBlendMode(_get(),_internal::getSDLBlendModeFromBlendMode(mode));
|
||||
}
|
||||
|
||||
int Surface::savePNG(const std::string& filename) const
|
||||
{
|
||||
return IMG_SavePNG(_get(),filename.c_str());
|
||||
}
|
||||
|
||||
int Surface::blit(const Surface& s,const Rect& src,const Rect& dst)
|
||||
{
|
||||
SDL_Rect rsrc=src.toSDLRect();
|
||||
SDL_Rect rdst=dst.toSDLRect();
|
||||
return SDL_BlitSurface(s._get(),&rsrc,_get(),&rdst);
|
||||
}
|
||||
|
||||
int Surface::blitTo(const Surface& s,const Rect& dst)
|
||||
{
|
||||
SDL_Rect rdst=dst.toSDLRect();
|
||||
return SDL_BlitSurface(s._get(),NULL,_get(),&rdst);
|
||||
}
|
||||
|
||||
int Surface::blitTo(const Surface& s,const Point& lupoint)
|
||||
{
|
||||
return blitTo(s,Rect(lupoint.x,lupoint.y,s.getw(),s.geth()));
|
||||
}
|
||||
|
||||
int Surface::blitFill(const Surface& s,const Rect& src)
|
||||
{
|
||||
SDL_Rect rsrc=src.toSDLRect();
|
||||
return SDL_BlitSurface(s._get(),&rsrc,_get(),NULL);
|
||||
}
|
||||
|
||||
int Surface::blitFullFill(const Surface& s)
|
||||
{
|
||||
return SDL_BlitSurface(s._get(),NULL,_get(),NULL);
|
||||
}
|
||||
|
||||
int Surface::blitScaled(const Surface& s,const Rect& src,const Rect& dst)
|
||||
{
|
||||
SDL_Rect rsrc=src.toSDLRect();
|
||||
SDL_Rect rdst=dst.toSDLRect();
|
||||
return SDL_BlitScaled(s._get(),&rsrc,_get(),&rdst);
|
||||
}
|
||||
|
||||
int Surface::blitScaledTo(const Surface& s,const Rect& dst)
|
||||
{
|
||||
SDL_Rect rdst=dst.toSDLRect();
|
||||
return SDL_BlitScaled(s._get(),NULL,_get(),&rdst);
|
||||
}
|
||||
|
||||
int Surface::blitScaledTo(const Surface& s,const Point& lupoint)
|
||||
{
|
||||
return blitScaledTo(s,Rect(lupoint.x,lupoint.y,s.getw(),s.geth()));
|
||||
}
|
||||
|
||||
int Surface::blitScaledFill(const Surface& s,const Rect& src)
|
||||
{
|
||||
SDL_Rect rsrc=src.toSDLRect();
|
||||
return SDL_BlitScaled(s._get(),&rsrc,_get(),NULL);
|
||||
}
|
||||
|
||||
int Surface::blitScaledFullFill(const Surface& s)
|
||||
{
|
||||
return SDL_BlitScaled(s._get(),NULL,_get(),NULL);
|
||||
}
|
||||
|
||||
int Surface::setClipRect(const Rect& clipRect)
|
||||
{
|
||||
auto m=clipRect.toSDLRect();
|
||||
return (SDL_SetClipRect(_get(),&m) == SDL_TRUE) ? 0 : -1;
|
||||
}
|
||||
|
||||
Rect Surface::getClipRect() const
|
||||
{
|
||||
SDL_Rect rect;
|
||||
SDL_GetClipRect(_get(),&rect);
|
||||
return Rect(rect);
|
||||
}
|
||||
|
||||
void Surface::disableClipping()
|
||||
{
|
||||
SDL_SetClipRect(_get(),NULL);
|
||||
}
|
||||
|
||||
int Surface::setAlphaMode(int alpha)
|
||||
{
|
||||
return SDL_SetSurfaceAlphaMod(_get(),alpha);
|
||||
}
|
||||
|
||||
int Surface::getAlphaMode() const
|
||||
{
|
||||
Uint8 al;
|
||||
SDL_GetSurfaceAlphaMod(_get(),&al);
|
||||
return al;
|
||||
}
|
||||
|
||||
int Surface::setColorMode(ColorMode mode)
|
||||
{
|
||||
return SDL_SetSurfaceColorMod(_get(),mode.r,mode.g,mode.b);
|
||||
}
|
||||
|
||||
ColorMode Surface::getColorMode() const
|
||||
{
|
||||
Uint8 r,g,b;
|
||||
SDL_GetSurfaceColorMod(_get(),&r,&g,&b);
|
||||
ColorMode mode;
|
||||
mode.r=r;
|
||||
mode.g=g;
|
||||
mode.b=b;
|
||||
return mode;
|
||||
}
|
||||
|
||||
void Surface::setRGBA(const RGBA& pack)
|
||||
{
|
||||
setColorMode(pack.toColorMode());
|
||||
setAlphaMode(pack.a);
|
||||
}
|
||||
|
||||
RGBA Surface::getRGBA() const
|
||||
{
|
||||
return RGBA(getColorMode(),getAlphaMode());
|
||||
}
|
||||
|
||||
bool Surface::mustlock() const
|
||||
{
|
||||
return SDL_MUSTLOCK(_get());
|
||||
}
|
||||
|
||||
int Surface::lock()
|
||||
{
|
||||
return SDL_LockSurface(_get());
|
||||
}
|
||||
|
||||
void Surface::unlock()
|
||||
{
|
||||
SDL_UnlockSurface(_get());
|
||||
}
|
||||
|
||||
bool Surface::isReady() const
|
||||
{
|
||||
return _get()!=nullptr;
|
||||
}
|
||||
|
||||
void Surface::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
/// Experimental (Not constant)
|
||||
SDL_Surface* Surface::getRawPointer()
|
||||
{
|
||||
return _get();
|
||||
}
|
||||
#include "end_code.h"
|
86
SDLWrapper/Surface.h
Normal file
86
SDLWrapper/Surface.h
Normal file
|
@ -0,0 +1,86 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_BlendMode.h"
|
||||
#include "RGBA.h"
|
||||
#include "Point.h"
|
||||
#include "RWOP.h"
|
||||
#include "ErrorViewer.h"
|
||||
#include "begin_code.h"
|
||||
class Surface
|
||||
{
|
||||
public:
|
||||
Surface()=default;
|
||||
Surface(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask) throw(ErrorViewer);
|
||||
Surface(int width,int height,int depth,RGBA colorPack) throw(ErrorViewer);
|
||||
Surface(int width,int height,int depth,Uint32 surfaceFormat) throw(ErrorViewer);
|
||||
Surface(const std::string& filename) throw(ErrorViewer);
|
||||
Surface(const RWOP& rwop) throw(ErrorViewer);
|
||||
~Surface() = default;
|
||||
|
||||
/// static functions
|
||||
static Surface load(const std::string& filename);
|
||||
static Surface load(const RWOP& rwop);
|
||||
static Surface create(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask);
|
||||
static Surface create(int width,int height,int depth,Uint32 surfaceFormat);
|
||||
|
||||
/// xxxAs will clear the current surface if loaded or created successfully.
|
||||
int loadAs(const std::string& filename);
|
||||
int loadAs(const RWOP& rwop);
|
||||
int createAs(int width,int height,int depth,int Rmask,int Gmask,int Bmask,int Amask);
|
||||
int createAs(int width,int height,int depth,Uint32 surfaceFormat);
|
||||
|
||||
int savePNG(const std::string& filename) const;
|
||||
int getw() const;
|
||||
int geth() const;
|
||||
BlendMode getBlendMode() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
|
||||
/// Rendering functions. Copy an external surface to this surface. So it has no constant attribute.
|
||||
int blit(const Surface& s,const Rect& src,const Rect& dst);
|
||||
int blitTo(const Surface& t, const Rect& dst);
|
||||
int blitTo(const Surface& t, const Point& lupoint);
|
||||
int blitFill(const Surface& t, const Rect& src);
|
||||
int blitFullFill(const Surface& t);
|
||||
|
||||
int blitScaled(const Surface& s,const Rect& src,const Rect& dst);
|
||||
int blitScaledTo(const Surface& t, const Rect& dst);
|
||||
int blitScaledTo(const Surface& t, const Point& lupoint);
|
||||
int blitScaledFill(const Surface& t, const Rect& src);
|
||||
int blitScaledFullFill(const Surface& t);
|
||||
|
||||
int setClipRect(const Rect& clipRect);
|
||||
Rect getClipRect() const;
|
||||
void disableClipping();
|
||||
|
||||
int setAlphaMode(int alpha);
|
||||
int getAlphaMode() const;
|
||||
|
||||
ColorMode getColorMode() const;
|
||||
int setColorMode(ColorMode mode);
|
||||
RGBA getRGBA() const;
|
||||
void setRGBA(const RGBA& pack);
|
||||
|
||||
bool mustlock() const;
|
||||
int lock();
|
||||
void unlock();
|
||||
|
||||
bool isReady() const;
|
||||
void release();
|
||||
|
||||
/// Experimental : Get SDL_Surface Pointer and then do anything you want!
|
||||
/// In case you can do anything with this pointer, this function should not has constant attribute.
|
||||
SDL_Surface* getRawPointer();
|
||||
private:
|
||||
std::shared_ptr<SDL_Surface> _surf;
|
||||
void _set(SDL_Surface*);
|
||||
void _set_no_delete(SDL_Surface*);
|
||||
void _clear();
|
||||
SDL_Surface* _get() const;
|
||||
|
||||
friend class Window;
|
||||
friend class Renderer;
|
||||
friend class Font;
|
||||
friend class Cursor;
|
||||
};
|
||||
|
||||
#include "end_code.h"
|
126
SDLWrapper/Texture.cpp
Normal file
126
SDLWrapper/Texture.cpp
Normal file
|
@ -0,0 +1,126 @@
|
|||
#include "Texture.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Texture::_set(SDL_Texture* p)
|
||||
{
|
||||
_text.reset(p,SDL_DestroyTexture);
|
||||
updateInfo();
|
||||
}
|
||||
|
||||
//private
|
||||
void Texture::_set_no_delete(SDL_Texture* p)
|
||||
{
|
||||
_text.reset(p,[](SDL_Texture*) {});
|
||||
updateInfo();
|
||||
}
|
||||
|
||||
//private
|
||||
void Texture::_clear()
|
||||
{
|
||||
_text.reset();
|
||||
updateInfo();
|
||||
}
|
||||
|
||||
//private
|
||||
SDL_Texture* Texture::_get() const
|
||||
{
|
||||
return _text.get();
|
||||
}
|
||||
|
||||
Texture::Texture()
|
||||
{
|
||||
updateInfo();
|
||||
}
|
||||
|
||||
Rect Texture::getSize()
|
||||
{
|
||||
return _rect;
|
||||
}
|
||||
|
||||
int Texture::getw() const
|
||||
{
|
||||
return _rect.w;
|
||||
}
|
||||
|
||||
int Texture::geth() const
|
||||
{
|
||||
return _rect.h;
|
||||
}
|
||||
|
||||
bool Texture::isReady() const
|
||||
{
|
||||
return (_get() != nullptr);
|
||||
}
|
||||
|
||||
int Texture::setBlendMode(BlendMode mode)
|
||||
{
|
||||
return SDL_SetTextureBlendMode(_get(), _internal::getSDLBlendModeFromBlendMode(mode));
|
||||
}
|
||||
|
||||
BlendMode Texture::getBlendMode() const
|
||||
{
|
||||
SDL_BlendMode temp;
|
||||
SDL_GetTextureBlendMode(_get(), &temp);
|
||||
return _internal::getBlendModeFromSDLBlendMode(temp);
|
||||
}
|
||||
|
||||
/// Alpha: 0: Transparent 255: opaque
|
||||
|
||||
int Texture::setAlphaMode(int alpha)
|
||||
{
|
||||
Uint8 temp = std::max(std::min(alpha, 255), 0);
|
||||
return SDL_SetTextureAlphaMod(_get(), temp);
|
||||
}
|
||||
|
||||
int Texture::getAlphaMode() const
|
||||
{
|
||||
Uint8 temp;
|
||||
SDL_GetTextureAlphaMod(_get(), &temp);
|
||||
return temp;
|
||||
}
|
||||
|
||||
ColorMode Texture::getColorMode() const
|
||||
{
|
||||
ColorMode pack;
|
||||
Uint8 r, g, b;
|
||||
SDL_GetTextureColorMod(_get(), &r, &g, &b);
|
||||
pack.r = r;
|
||||
pack.g = g;
|
||||
pack.b = b;
|
||||
return pack;
|
||||
}
|
||||
|
||||
int Texture::setColorMode(ColorMode mode)
|
||||
{
|
||||
return SDL_SetTextureColorMod(_get(), mode.r, mode.g, mode.b);
|
||||
}
|
||||
|
||||
RGBA Texture::getRGBA() const
|
||||
{
|
||||
return RGBA(getColorMode(), getAlphaMode());
|
||||
}
|
||||
|
||||
void Texture::setRGBA(const RGBA& pack)
|
||||
{
|
||||
setColorMode(pack.toColorMode());
|
||||
setAlphaMode(pack.a);
|
||||
}
|
||||
|
||||
/// updateInfo() must be called after Texture is changed.
|
||||
//protected
|
||||
void Texture::updateInfo()
|
||||
{
|
||||
if(_get()==nullptr)
|
||||
{
|
||||
_rect.x=_rect.y=_rect.w=_rect.h=0;
|
||||
}
|
||||
SDL_QueryTexture(_get(), NULL, NULL, &_rect.w, &_rect.h);
|
||||
_rect.x = _rect.y = 0;
|
||||
}
|
||||
|
||||
void Texture::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
#include "end_code.h"
|
45
SDLWrapper/Texture.h
Normal file
45
SDLWrapper/Texture.h
Normal file
|
@ -0,0 +1,45 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "Rect.h"
|
||||
#include "RGBA.h"
|
||||
#include "ColorMode.h"
|
||||
#include "_BlendMode.h"
|
||||
#include <memory>
|
||||
#include "begin_code.h"
|
||||
|
||||
class Texture
|
||||
{
|
||||
public:
|
||||
Texture();
|
||||
~Texture() = default;
|
||||
Rect getSize();
|
||||
int getw() const;
|
||||
int geth() const;
|
||||
bool isReady() const;
|
||||
int setBlendMode(BlendMode mode);
|
||||
BlendMode getBlendMode() const;
|
||||
/// Alpha: 0: Transparent 255: opaque
|
||||
int setAlphaMode(int alpha);
|
||||
int getAlphaMode() const;
|
||||
|
||||
ColorMode getColorMode() const;
|
||||
int setColorMode(ColorMode mode);
|
||||
RGBA getRGBA() const;
|
||||
void setRGBA(const RGBA& pack);
|
||||
|
||||
void release();
|
||||
protected:
|
||||
/// updateInfo() must be called after Texture is changed.
|
||||
void updateInfo();
|
||||
private:
|
||||
std::shared_ptr<SDL_Texture> _text;
|
||||
void _set(SDL_Texture*);
|
||||
/// Just used for "SDL_GetRenderTarget"
|
||||
void _set_no_delete(SDL_Texture*);
|
||||
void _clear();
|
||||
SDL_Texture* _get() const;
|
||||
Rect _rect;
|
||||
friend class Renderer;
|
||||
};
|
||||
|
||||
#include "end_code.h"
|
87
SDLWrapper/Timer.cpp
Normal file
87
SDLWrapper/Timer.cpp
Normal file
|
@ -0,0 +1,87 @@
|
|||
#include "Timer.h"
|
||||
#include "begin_code.h"
|
||||
/// Global Executor For class Timer
|
||||
Uint32 _global_timer_executor(Uint32 interval,void* param)
|
||||
{
|
||||
auto p=reinterpret_cast<std::function<Uint32(Uint32 interval)>*>(param);
|
||||
return (*p)(interval);
|
||||
}
|
||||
|
||||
Timer::Timer()
|
||||
{
|
||||
_enabled=false;
|
||||
_detached=false;
|
||||
_delete_on_disable=false;
|
||||
id=-1;
|
||||
}
|
||||
|
||||
Timer::Timer(SDL_TimerCallback callback,Uint32 interval,void* param) : Timer()
|
||||
{
|
||||
_real_timer_call(callback,interval,param);
|
||||
}
|
||||
|
||||
void Timer::_real_timer_call(SDL_TimerCallback callback,Uint32 interval,void* param)
|
||||
{
|
||||
_callback=callback;
|
||||
_interval=interval;
|
||||
_param=param;
|
||||
}
|
||||
|
||||
int Timer::enable()
|
||||
{
|
||||
if(_enabled)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
{
|
||||
id=SDL_AddTimer(_interval,_callback,_param);
|
||||
if(id<0) return -2;
|
||||
_enabled=true;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int Timer::disable()
|
||||
{
|
||||
if(_enabled)
|
||||
{
|
||||
SDL_RemoveTimer(id);
|
||||
_enabled=false;
|
||||
id=-1;
|
||||
_callback=nullptr;
|
||||
|
||||
if(_delete_on_disable)
|
||||
{
|
||||
_delete_delegator(reinterpret_cast<std::function<Uint32(Uint32 interval)>*>(_param));
|
||||
_delete_on_disable=false;
|
||||
}
|
||||
|
||||
_param=nullptr;
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void Timer::detach()
|
||||
{
|
||||
_detached=true;
|
||||
}
|
||||
|
||||
Timer::~Timer()
|
||||
{
|
||||
if(!_detached)
|
||||
{
|
||||
disable();
|
||||
}
|
||||
}
|
||||
|
||||
//static
|
||||
void Timer::_delete_delegator(std::function<Uint32(Uint32)>* param)
|
||||
{
|
||||
delete param;
|
||||
}
|
||||
#include "end_code.h"
|
51
SDLWrapper/Timer.h
Normal file
51
SDLWrapper/Timer.h
Normal file
|
@ -0,0 +1,51 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include <functional>
|
||||
#include "begin_code.h"
|
||||
Uint32 _global_timer_executor(Uint32 interval,void* param);
|
||||
|
||||
class Timer
|
||||
{
|
||||
public:
|
||||
Timer();
|
||||
|
||||
/// void func(Uint32,...)
|
||||
template<typename VoidCallable,typename... Args>
|
||||
Timer(Uint32 interval,VoidCallable&& vcallable,Args&&... args) : Timer()
|
||||
{
|
||||
auto realCall=[&,vcallable](Uint32 ims)->Uint32{vcallable(ims,args...); return ims;};
|
||||
auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
|
||||
_real_timer_call(_global_timer_executor,interval,pfunc);
|
||||
}
|
||||
|
||||
/// Uint32 func(Uint32,...)
|
||||
template<typename Callable,typename... Args>
|
||||
Timer(Callable&& callable,Uint32 interval,Args&&... args) : Timer()
|
||||
{
|
||||
auto realCall=[&,callable](Uint32 ims)->Uint32{return callable(ims,args...);};
|
||||
auto pfunc=new std::function<Uint32(Uint32 interval)>(realCall);
|
||||
_real_timer_call(_global_timer_executor,interval,pfunc);
|
||||
}
|
||||
|
||||
/// Restore For Capability
|
||||
Timer(SDL_TimerCallback callback,Uint32 interval,void* param);
|
||||
|
||||
int enable();
|
||||
int disable();
|
||||
bool isenable() const;
|
||||
void detach();
|
||||
~Timer();
|
||||
|
||||
static void _delete_delegator(std::function<Uint32(Uint32)>* Delegator);
|
||||
private:
|
||||
void _real_timer_call(SDL_TimerCallback callback,Uint32 interval,void* param);
|
||||
SDL_TimerCallback _callback;
|
||||
Uint32 _interval;
|
||||
void* _param;
|
||||
SDL_TimerID id;
|
||||
bool _enabled;
|
||||
bool _detached;
|
||||
/// Reserved Variable For Template variable Parameter
|
||||
bool _delete_on_disable;
|
||||
};
|
||||
#include "end_code.h"
|
250
SDLWrapper/Window.cpp
Normal file
250
SDLWrapper/Window.cpp
Normal file
|
@ -0,0 +1,250 @@
|
|||
#include "Window.h"
|
||||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
//private
|
||||
void Window::_set(SDL_Window* p)
|
||||
{
|
||||
_wnd.reset(p,SDL_DestroyWindow);
|
||||
}
|
||||
|
||||
//private
|
||||
void Window::_clear()
|
||||
{
|
||||
_wnd.reset();
|
||||
}
|
||||
|
||||
//private
|
||||
SDL_Window* Window::_get() const
|
||||
{
|
||||
return _wnd.get();
|
||||
}
|
||||
|
||||
Window::Window(std::string Title, int Width, int Height,
|
||||
std::initializer_list<WindowType> WindowFlags, int WindowPositionX, int WindowPositionY) throw(ErrorViewer)
|
||||
{
|
||||
/// Calculate Window Flags
|
||||
Uint32 windowFlag=0;
|
||||
for(auto v:WindowFlags)
|
||||
{
|
||||
windowFlag|=_internal::getSDLWindowFlagsFromWindowType(v);
|
||||
}
|
||||
|
||||
SDL_Window* temp = SDL_CreateWindow(Title.c_str(), WindowPositionX, WindowPositionY, Width, Height, windowFlag);
|
||||
if (temp == NULL)
|
||||
{
|
||||
ErrorViewer e;
|
||||
e.fetch();
|
||||
throw e;
|
||||
}
|
||||
|
||||
_set(temp);
|
||||
}
|
||||
|
||||
Rect Window::getSize() const
|
||||
{
|
||||
int w, h;
|
||||
SDL_GetWindowSize(_get(), &w, &h);
|
||||
return Rect(0, 0, w, h);
|
||||
}
|
||||
|
||||
void Window::setSize(const Rect& sizeRect)
|
||||
{
|
||||
setSize(sizeRect.w, sizeRect.h);
|
||||
}
|
||||
|
||||
void Window::setSize(int w, int h)
|
||||
{
|
||||
SDL_SetWindowSize(_get(), w, h);
|
||||
}
|
||||
|
||||
Point Window::getPosition() const
|
||||
{
|
||||
int x, y;
|
||||
SDL_GetWindowPosition(_get(), &x, &y);
|
||||
return Point(x, y);
|
||||
}
|
||||
|
||||
void Window::setPosition(int x, int y)
|
||||
{
|
||||
SDL_SetWindowPosition(_get(), x, y);
|
||||
}
|
||||
|
||||
void Window::setPosition(const Point& point)
|
||||
{
|
||||
SDL_SetWindowPosition(_get(), point.x, point.y);
|
||||
}
|
||||
|
||||
void Window::setTitle(const std::string& Title)
|
||||
{
|
||||
SDL_SetWindowTitle(_get(), Title.c_str());
|
||||
}
|
||||
|
||||
std::string Window::getTitle() const
|
||||
{
|
||||
return std::string(SDL_GetWindowTitle(_get()));
|
||||
}
|
||||
|
||||
void Window::setGrab(bool isGrab)
|
||||
{
|
||||
SDL_SetWindowGrab(_get(),isGrab?SDL_TRUE:SDL_FALSE);
|
||||
}
|
||||
|
||||
bool Window::getGrab() const
|
||||
{
|
||||
return (SDL_GetWindowGrab(_get())==SDL_TRUE)?true:false;
|
||||
}
|
||||
|
||||
#if _MINIENGINE_SDL_VERSION_ATLEAST(2,0,5)
|
||||
int Window::setOpacity(float opacity)
|
||||
{
|
||||
return SDL_SetWindowOpacity(_get(),opacity);
|
||||
}
|
||||
float Window::getOpacity() const
|
||||
{
|
||||
float op=-1;
|
||||
SDL_GetWindowOpacity(_get(),&op);
|
||||
return op;
|
||||
}
|
||||
#endif /// End of SDL2 2.0.5 Require.
|
||||
|
||||
/// FIXME: Not Implemented.
|
||||
void Window::setResizable(bool resizable)
|
||||
{
|
||||
//SDL_SetWindowResizable(_get(), resizable?SDL_TRUE:SDL_FALSE);
|
||||
}
|
||||
|
||||
void Window::show()
|
||||
{
|
||||
SDL_ShowWindow(_get());
|
||||
}
|
||||
|
||||
void Window::hide()
|
||||
{
|
||||
SDL_HideWindow(_get());
|
||||
}
|
||||
|
||||
void Window::raise()
|
||||
{
|
||||
SDL_RaiseWindow(_get());
|
||||
}
|
||||
|
||||
void Window::minimize()
|
||||
{
|
||||
SDL_MinimizeWindow(_get());
|
||||
}
|
||||
|
||||
void Window::maximize()
|
||||
{
|
||||
SDL_MaximizeWindow(_get());
|
||||
}
|
||||
|
||||
void Window::restore()
|
||||
{
|
||||
SDL_RestoreWindow(_get());
|
||||
}
|
||||
|
||||
_DECL_DEPRECATED Surface Window::getSurface()
|
||||
{
|
||||
SDL_Surface* temp = SDL_GetWindowSurface(_get());
|
||||
Surface s;
|
||||
/// Don't Free This Surface
|
||||
s._set_no_delete(temp);
|
||||
return s;
|
||||
}
|
||||
|
||||
void Window::release()
|
||||
{
|
||||
_clear();
|
||||
}
|
||||
|
||||
int Window::showSimpleMessageBox(MessageBoxType type,const std::string& Title,const std::string& Message) const
|
||||
{
|
||||
Uint32 flags=0;
|
||||
switch(type)
|
||||
{
|
||||
case MessageBoxType::Error:
|
||||
flags=SDL_MESSAGEBOX_ERROR;
|
||||
break;
|
||||
case MessageBoxType::Information:
|
||||
flags=SDL_MESSAGEBOX_INFORMATION;
|
||||
break;
|
||||
case MessageBoxType::Warning:
|
||||
flags=SDL_MESSAGEBOX_WARNING;
|
||||
break;
|
||||
}
|
||||
return SDL_ShowSimpleMessageBox(flags,Title.c_str(),Message.c_str(),_get());
|
||||
}
|
||||
|
||||
int Window::showMessageBox(const WindowMessageBox& box) const
|
||||
{
|
||||
SDL_MessageBoxData mboxdata;
|
||||
mboxdata.title=box.title.c_str();
|
||||
mboxdata.message=box.text.c_str();
|
||||
mboxdata.window=_get();
|
||||
mboxdata.colorScheme=nullptr;
|
||||
mboxdata.numbuttons=box.getButtonNum();
|
||||
SDL_MessageBoxButtonData* pButtonArr=(SDL_MessageBoxButtonData*)malloc(sizeof(SDL_MessageBoxButtonData)*(mboxdata.numbuttons));
|
||||
if(pButtonArr==nullptr)
|
||||
{
|
||||
/// Failed to malloc
|
||||
return -2;
|
||||
}
|
||||
for(int i=0; i<mboxdata.numbuttons; i++)
|
||||
{
|
||||
pButtonArr[i].buttonid=i+1;
|
||||
pButtonArr[i].text=box.getButtonConst(i).text.c_str();
|
||||
pButtonArr[i].flags=
|
||||
(box.getButtonConst(i).isHitAsEscape()) ? SDL_MESSAGEBOX_BUTTON_ESCAPEKEY_DEFAULT
|
||||
:(
|
||||
(box.getButtonConst(i).isHitAsReturn()) ?SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT
|
||||
:0
|
||||
);
|
||||
}
|
||||
mboxdata.buttons=pButtonArr;
|
||||
switch(box.boxtype)
|
||||
{
|
||||
case MessageBoxType::Error:
|
||||
mboxdata.flags=SDL_MESSAGEBOX_ERROR;
|
||||
break;
|
||||
case MessageBoxType::Information:
|
||||
mboxdata.flags=SDL_MESSAGEBOX_INFORMATION;
|
||||
break;
|
||||
case MessageBoxType::Warning:
|
||||
mboxdata.flags=SDL_MESSAGEBOX_WARNING;
|
||||
break;
|
||||
}
|
||||
|
||||
int clickret=-2;
|
||||
|
||||
/// Call SDL2 to show MessageBox.
|
||||
int ret=SDL_ShowMessageBox(&mboxdata,&clickret);
|
||||
|
||||
if(ret==0)
|
||||
{
|
||||
/// Success.
|
||||
if(clickret>=1)
|
||||
{
|
||||
/// If any button is clicked, call the callback function associated with it.
|
||||
if(box.getButtonConst(clickret-1).callback)
|
||||
{
|
||||
box.getButtonConst(clickret-1).callback();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/// ... else, call the default callback
|
||||
if(box.defaultcallback) box.defaultcallback();
|
||||
}
|
||||
}
|
||||
|
||||
/// Free allocated memory
|
||||
free(pButtonArr);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool Window::isScreenKeyboardShown()
|
||||
{
|
||||
return SDL_IsScreenKeyboardShown(_get())==SDL_TRUE;
|
||||
}
|
||||
#include "end_code.h"
|
66
SDLWrapper/Window.h
Normal file
66
SDLWrapper/Window.h
Normal file
|
@ -0,0 +1,66 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_WindowType.h"
|
||||
#include "_MessageBoxType.h"
|
||||
#include "ErrorViewer.h"
|
||||
#include "MessageBox.h"
|
||||
#include "Surface.h"
|
||||
#include "begin_code.h"
|
||||
class Window
|
||||
{
|
||||
public:
|
||||
Window()=default;
|
||||
Window(std::string Title, int Width, int Height,
|
||||
std::initializer_list<WindowType> WindowFlags = {WindowType::Shown},
|
||||
int WindowPositionX=SDL_WINDOWPOS_CENTERED, int WindowPositionY=SDL_WINDOWPOS_CENTERED) throw(ErrorViewer);
|
||||
|
||||
Rect getSize() const;
|
||||
void setSize(const Rect& sizeRect);
|
||||
void setSize(int w, int h);
|
||||
|
||||
Point getPosition() const;
|
||||
void setPosition(int x, int y);
|
||||
void setPosition(const Point& point);
|
||||
|
||||
void setTitle(const std::string& Title);
|
||||
std::string getTitle() const;
|
||||
|
||||
void setGrab(bool isGrab);
|
||||
bool getGrab() const;
|
||||
|
||||
#if _MINIENGINE_SDL_VERSION_ATLEAST(2,0,5)
|
||||
/// SDL2.0.5 Required.
|
||||
int setOpacity(float opacity);
|
||||
float getOpacity() const;
|
||||
#endif
|
||||
|
||||
/// FIXME: Not Implemented.
|
||||
void setResizable(bool resizable);
|
||||
|
||||
/// Use UTF8 in Title and Message please.
|
||||
int showSimpleMessageBox(MessageBoxType type,const std::string& Title,const std::string& Message) const;
|
||||
|
||||
int showMessageBox(const WindowMessageBox& box) const;
|
||||
|
||||
void show();
|
||||
void hide();
|
||||
void raise();
|
||||
void minimize();
|
||||
void maximize();
|
||||
void restore();
|
||||
|
||||
_DECL_DEPRECATED Surface getSurface();
|
||||
|
||||
bool isScreenKeyboardShown();
|
||||
|
||||
void release();
|
||||
private:
|
||||
std::shared_ptr<SDL_Window> _wnd;
|
||||
|
||||
void _set(SDL_Window*);
|
||||
void _clear();
|
||||
SDL_Window* _get() const;
|
||||
|
||||
friend class Renderer;
|
||||
};
|
||||
#include "end_code.h"
|
10
SDLWrapper/_BlendMode.h
Normal file
10
SDLWrapper/_BlendMode.h
Normal file
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class BlendMode
|
||||
{
|
||||
None,
|
||||
Blend,
|
||||
Add,
|
||||
Mod
|
||||
};
|
||||
#include "end_code.h"
|
9
SDLWrapper/_FlipMode.h
Normal file
9
SDLWrapper/_FlipMode.h
Normal file
|
@ -0,0 +1,9 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class FlipMode
|
||||
{
|
||||
None,
|
||||
Horizontal,
|
||||
Vertical
|
||||
};
|
||||
#include "end_code.h"
|
11
SDLWrapper/_FontHint.h
Normal file
11
SDLWrapper/_FontHint.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class FontHint
|
||||
{
|
||||
Normal,
|
||||
Light,
|
||||
Mono,
|
||||
None,
|
||||
Error
|
||||
};
|
||||
#include "end_code.h"
|
11
SDLWrapper/_FontStyle.h
Normal file
11
SDLWrapper/_FontStyle.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class FontStyle
|
||||
{
|
||||
Normal,
|
||||
Bold,
|
||||
Italic,
|
||||
UnderLine,
|
||||
StrikeThrough
|
||||
};
|
||||
#include "end_code.h"
|
9
SDLWrapper/_MessageBoxType.h
Normal file
9
SDLWrapper/_MessageBoxType.h
Normal file
|
@ -0,0 +1,9 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class MessageBoxType
|
||||
{
|
||||
Error,
|
||||
Warning,
|
||||
Information
|
||||
};
|
||||
#include "end_code.h"
|
12
SDLWrapper/_Platform.h
Normal file
12
SDLWrapper/_Platform.h
Normal file
|
@ -0,0 +1,12 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class Platform
|
||||
{
|
||||
Unknown,
|
||||
Windows,
|
||||
MacOS,
|
||||
Linux,
|
||||
iOS,
|
||||
Android
|
||||
};
|
||||
#include "end_code.h"
|
11
SDLWrapper/_PowerState.h
Normal file
11
SDLWrapper/_PowerState.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class PowerState
|
||||
{
|
||||
Unknown,
|
||||
OnBattery,
|
||||
NoBattery,
|
||||
Charging,
|
||||
Charged
|
||||
};
|
||||
#include "end_code.h"
|
10
SDLWrapper/_RendererType.h
Normal file
10
SDLWrapper/_RendererType.h
Normal file
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class RendererType
|
||||
{
|
||||
Software,
|
||||
Accelerated,
|
||||
PresentSync,
|
||||
TargetTexture
|
||||
};
|
||||
#include "end_code.h"
|
10
SDLWrapper/_SystemCursorType.h
Normal file
10
SDLWrapper/_SystemCursorType.h
Normal file
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class SystemCursorType
|
||||
{
|
||||
Arrow, Ibeam, CrossHair,
|
||||
Wait, WaitArrow,
|
||||
SizeNWSE, SizeNESW, SizeWE, SizeNS, SizeAll,
|
||||
No, Hand
|
||||
};
|
||||
#include "end_code.h"
|
12
SDLWrapper/_WindowType.h
Normal file
12
SDLWrapper/_WindowType.h
Normal file
|
@ -0,0 +1,12 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
enum class WindowType
|
||||
{
|
||||
FullScreen, OpenGL, Shown, Hidden,
|
||||
Borderless, Resizable, Minimized, Maximized,
|
||||
InputGrabbed, InputFocus, MouseFocus,
|
||||
FullScreenDesktop, Foreign, AllowHighDPI,
|
||||
MouseCapture, AlwaysOnTop, SkipTaskBar,
|
||||
Utility, ToolTip, PopUpMenu
|
||||
};
|
||||
#include "end_code.h"
|
11
SDLWrapper/__Noncopyable.h
Normal file
11
SDLWrapper/__Noncopyable.h
Normal file
|
@ -0,0 +1,11 @@
|
|||
#pragma once
|
||||
#include "begin_code.h"
|
||||
class NonCopyable
|
||||
{
|
||||
protected:
|
||||
NonCopyable() = default;
|
||||
~NonCopyable() = default;
|
||||
NonCopyable(const NonCopyable&) = delete;
|
||||
NonCopyable& operator = (const NonCopyable&) = delete;
|
||||
};
|
||||
#include "end_code.h"
|
10
SDLWrapper/__Optional.h
Normal file
10
SDLWrapper/__Optional.h
Normal file
|
@ -0,0 +1,10 @@
|
|||
#pragma once
|
||||
#include <experimental/optional>
|
||||
#include "begin_code.h"
|
||||
template<typename T>
|
||||
using Optional = std::experimental::optional<T>;
|
||||
|
||||
using BadOptionalAccess = std::experimental::bad_optional_access;
|
||||
|
||||
constexpr std::experimental::nullopt_t NullOpt = std::experimental::nullopt;
|
||||
#include "end_code.h"
|
219
SDLWrapper/_caster.cpp
Normal file
219
SDLWrapper/_caster.cpp
Normal file
|
@ -0,0 +1,219 @@
|
|||
#include "_caster.h"
|
||||
#include "begin_code.h"
|
||||
namespace _internal
|
||||
{
|
||||
BlendMode getBlendModeFromSDLBlendMode(SDL_BlendMode mode)
|
||||
{
|
||||
switch(mode)
|
||||
{
|
||||
case SDL_BLENDMODE_ADD:
|
||||
return BlendMode::Add;
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
return BlendMode::Blend;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
return BlendMode::Mod;
|
||||
case SDL_BLENDMODE_NONE:
|
||||
default:/// return BlendMode::None on default.
|
||||
return BlendMode::None;
|
||||
}
|
||||
}
|
||||
|
||||
SDL_BlendMode getSDLBlendModeFromBlendMode(BlendMode mode)
|
||||
{
|
||||
switch(mode)
|
||||
{
|
||||
case BlendMode::Add:
|
||||
return SDL_BLENDMODE_ADD;
|
||||
case BlendMode::Blend:
|
||||
return SDL_BLENDMODE_BLEND;
|
||||
case BlendMode::Mod:
|
||||
return SDL_BLENDMODE_MOD;
|
||||
case BlendMode::None:
|
||||
default:/// return SDL_BLENDMODE_NONE on default.
|
||||
return SDL_BLENDMODE_NONE;
|
||||
}
|
||||
}
|
||||
|
||||
/// FIXME: return SDL_WindowFlags or Uint32 ?
|
||||
Uint32 getSDLWindowFlagsFromWindowType(WindowType type)
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case WindowType::FullScreen:
|
||||
return SDL_WINDOW_FULLSCREEN;
|
||||
case WindowType::OpenGL:
|
||||
return SDL_WINDOW_OPENGL;
|
||||
case WindowType::Shown:
|
||||
return SDL_WINDOW_SHOWN;
|
||||
case WindowType::Hidden:
|
||||
return SDL_WINDOW_HIDDEN;
|
||||
case WindowType::Borderless:
|
||||
return SDL_WINDOW_BORDERLESS;
|
||||
case WindowType::Resizable:
|
||||
return SDL_WINDOW_RESIZABLE;
|
||||
case WindowType::Minimized:
|
||||
return SDL_WINDOW_MINIMIZED;
|
||||
case WindowType::Maximized:
|
||||
return SDL_WINDOW_MAXIMIZED;
|
||||
case WindowType::InputGrabbed:
|
||||
return SDL_WINDOW_INPUT_GRABBED;
|
||||
case WindowType::InputFocus:
|
||||
return SDL_WINDOW_INPUT_FOCUS;
|
||||
case WindowType::MouseFocus:
|
||||
return SDL_WINDOW_MOUSE_FOCUS;
|
||||
case WindowType::FullScreenDesktop:
|
||||
return SDL_WINDOW_FULLSCREEN_DESKTOP;
|
||||
case WindowType::Foreign:
|
||||
return SDL_WINDOW_FOREIGN;
|
||||
case WindowType::AllowHighDPI:
|
||||
return SDL_WINDOW_ALLOW_HIGHDPI;
|
||||
case WindowType::MouseCapture:
|
||||
return SDL_WINDOW_MOUSE_CAPTURE;
|
||||
|
||||
#if _MINIENGINE_SDL_VERSION_ATLEAST(2,0,5) /// SDL 2.0.5 Required
|
||||
case WindowType::AlwaysOnTop:
|
||||
return SDL_WINDOW_ALWAYS_ON_TOP;
|
||||
case WindowType::SkipTaskBar:
|
||||
return SDL_WINDOW_SKIP_TASKBAR;
|
||||
case WindowType::Utility:
|
||||
return SDL_WINDOW_UTILITY;
|
||||
case WindowType::ToolTip:
|
||||
return SDL_WINDOW_TOOLTIP;
|
||||
case WindowType::PopUpMenu:
|
||||
return SDL_WINDOW_POPUP_MENU;
|
||||
#endif // End of SDL2.0.5 Require
|
||||
|
||||
default:
|
||||
return 0;/// Return 0 on default.
|
||||
}
|
||||
}
|
||||
|
||||
SystemCursorType getCursorTypeFromSDLSystemCursor(SDL_SystemCursor id)
|
||||
{
|
||||
switch(id)
|
||||
{
|
||||
case SDL_SYSTEM_CURSOR_ARROW:
|
||||
return SystemCursorType::Arrow;
|
||||
case SDL_SYSTEM_CURSOR_CROSSHAIR:
|
||||
return SystemCursorType::CrossHair;
|
||||
case SDL_SYSTEM_CURSOR_HAND:
|
||||
return SystemCursorType::Hand;
|
||||
case SDL_SYSTEM_CURSOR_IBEAM:
|
||||
return SystemCursorType::Ibeam;
|
||||
case SDL_SYSTEM_CURSOR_NO:
|
||||
return SystemCursorType::No;
|
||||
case SDL_SYSTEM_CURSOR_SIZEALL:
|
||||
return SystemCursorType::SizeAll;
|
||||
case SDL_SYSTEM_CURSOR_SIZENESW:
|
||||
return SystemCursorType::SizeNESW;
|
||||
case SDL_SYSTEM_CURSOR_SIZENS:
|
||||
return SystemCursorType::SizeNS;
|
||||
case SDL_SYSTEM_CURSOR_SIZENWSE:
|
||||
return SystemCursorType::SizeNWSE;
|
||||
case SDL_SYSTEM_CURSOR_SIZEWE:
|
||||
return SystemCursorType::SizeWE;
|
||||
case SDL_SYSTEM_CURSOR_WAIT:
|
||||
return SystemCursorType::Wait;
|
||||
case SDL_SYSTEM_CURSOR_WAITARROW:
|
||||
return SystemCursorType::WaitArrow;
|
||||
default:/// return SystemCursorType::Arrow on default.
|
||||
return SystemCursorType::Arrow;
|
||||
}
|
||||
}
|
||||
|
||||
SDL_SystemCursor getSDLSystemCursorFromSystemCursorType(SystemCursorType type)
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case SystemCursorType::Arrow:
|
||||
return SDL_SYSTEM_CURSOR_ARROW;
|
||||
case SystemCursorType::CrossHair:
|
||||
return SDL_SYSTEM_CURSOR_CROSSHAIR;
|
||||
case SystemCursorType::Hand:
|
||||
return SDL_SYSTEM_CURSOR_HAND;
|
||||
case SystemCursorType::Ibeam:
|
||||
return SDL_SYSTEM_CURSOR_IBEAM;
|
||||
case SystemCursorType::No:
|
||||
return SDL_SYSTEM_CURSOR_NO;
|
||||
case SystemCursorType::SizeAll:
|
||||
return SDL_SYSTEM_CURSOR_SIZEALL;
|
||||
case SystemCursorType::SizeNESW:
|
||||
return SDL_SYSTEM_CURSOR_SIZENESW;
|
||||
case SystemCursorType::SizeNS:
|
||||
return SDL_SYSTEM_CURSOR_SIZENS;
|
||||
case SystemCursorType::SizeNWSE:
|
||||
return SDL_SYSTEM_CURSOR_SIZENWSE;
|
||||
case SystemCursorType::SizeWE:
|
||||
return SDL_SYSTEM_CURSOR_SIZEWE;
|
||||
case SystemCursorType::Wait:
|
||||
return SDL_SYSTEM_CURSOR_WAIT;
|
||||
case SystemCursorType::WaitArrow:
|
||||
return SDL_SYSTEM_CURSOR_WAITARROW;
|
||||
default:/// return SDL_SYSTEM_CURSOR_ARROW on default.
|
||||
return SDL_SYSTEM_CURSOR_ARROW;
|
||||
}
|
||||
}
|
||||
|
||||
int getTTFFontStyleFromFontStyle(FontStyle style)
|
||||
{
|
||||
switch(style)
|
||||
{
|
||||
case FontStyle::Bold:
|
||||
return TTF_STYLE_BOLD;
|
||||
case FontStyle::Italic:
|
||||
return TTF_STYLE_ITALIC;
|
||||
case FontStyle::Normal:
|
||||
return TTF_STYLE_NORMAL;
|
||||
case FontStyle::StrikeThrough:
|
||||
return TTF_STYLE_STRIKETHROUGH;
|
||||
case FontStyle::UnderLine:
|
||||
return TTF_STYLE_UNDERLINE;
|
||||
default:
|
||||
return TTF_STYLE_NORMAL;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<FontStyle> getFontStyleVecFromMixedTTFFontStyle(int Mixed_TTF_Font_Style)
|
||||
{
|
||||
std::vector<FontStyle> vec;
|
||||
if(Mixed_TTF_Font_Style&TTF_STYLE_BOLD)
|
||||
{
|
||||
vec.push_back(FontStyle::Bold);
|
||||
}
|
||||
if(Mixed_TTF_Font_Style&TTF_STYLE_ITALIC)
|
||||
{
|
||||
vec.push_back(FontStyle::Italic);
|
||||
}
|
||||
if(Mixed_TTF_Font_Style&TTF_STYLE_STRIKETHROUGH)
|
||||
{
|
||||
vec.push_back(FontStyle::StrikeThrough);
|
||||
}
|
||||
if(Mixed_TTF_Font_Style&TTF_STYLE_UNDERLINE)
|
||||
{
|
||||
vec.push_back(FontStyle::UnderLine);
|
||||
}
|
||||
if(vec.empty())
|
||||
{
|
||||
vec.push_back(FontStyle::Normal);
|
||||
}
|
||||
|
||||
return vec;
|
||||
}
|
||||
|
||||
SDL_RendererFlip getSDLRendererFlipFromFlipMode(FlipMode mode)
|
||||
{
|
||||
switch(mode)
|
||||
{
|
||||
case FlipMode::None:
|
||||
return SDL_FLIP_NONE;
|
||||
case FlipMode::Horizontal:
|
||||
return SDL_FLIP_HORIZONTAL;
|
||||
case FlipMode::Vertical:
|
||||
return SDL_FLIP_VERTICAL;
|
||||
default:
|
||||
/// return non-flip mode on default.
|
||||
return SDL_FLIP_NONE;
|
||||
}
|
||||
}
|
||||
}/// End of namespace _internal
|
||||
#include "end_code.h"
|
22
SDLWrapper/_caster.h
Normal file
22
SDLWrapper/_caster.h
Normal file
|
@ -0,0 +1,22 @@
|
|||
#pragma once
|
||||
#include "include.h"
|
||||
#include "_BlendMode.h"
|
||||
#include "_WindowType.h"
|
||||
#include "_SystemCursorType.h"
|
||||
#include "_FontStyle.h"
|
||||
#include "_FlipMode.h"
|
||||
#include <vector>
|
||||
#include "begin_code.h"
|
||||
namespace _internal
|
||||
{
|
||||
BlendMode getBlendModeFromSDLBlendMode(SDL_BlendMode mode);
|
||||
SDL_BlendMode getSDLBlendModeFromBlendMode(BlendMode mode);
|
||||
/// FIXME: return SDL_WindowFlags or Uint32 ?
|
||||
Uint32 getSDLWindowFlagsFromWindowType(WindowType type);
|
||||
SystemCursorType getCursorTypeFromSDLSystemCursor(SDL_SystemCursor id);
|
||||
SDL_SystemCursor getSDLSystemCursorFromSystemCursorType(SystemCursorType type);
|
||||
int getTTFFontStyleFromFontStyle(FontStyle style);
|
||||
std::vector<FontStyle> getFontStyleVecFromMixedTTFFontStyle(int Mixed_TTF_Font_Style);
|
||||
SDL_RendererFlip getSDLRendererFlipFromFlipMode(FlipMode mode);
|
||||
}/// End of namespace _internal
|
||||
#include "end_code.h"
|
3
SDLWrapper/begin_code.h
Normal file
3
SDLWrapper/begin_code.h
Normal file
|
@ -0,0 +1,3 @@
|
|||
/// Include this file at the beginning of MiniEngine headers and sources.
|
||||
namespace MiniEngine
|
||||
{
|
3
SDLWrapper/end_code.h
Normal file
3
SDLWrapper/end_code.h
Normal file
|
@ -0,0 +1,3 @@
|
|||
/// Include this file at the end of MiniEngine headers and sources.
|
||||
} /// End of namespace MiniEngine
|
||||
/// NOTICE: If you see an compile error here, there must be some unclosed "{" !
|
14
SDLWrapper/include.h
Normal file
14
SDLWrapper/include.h
Normal file
|
@ -0,0 +1,14 @@
|
|||
#pragma once
|
||||
|
||||
/// Include SDL Library Headers.
|
||||
#include <SDL2/SDL.h>
|
||||
#undef main
|
||||
#include <SDL2/SDL_image.h>
|
||||
#include <SDL2/SDL_ttf.h>
|
||||
#include <SDL2/SDL_mixer.h>
|
||||
|
||||
/// Version Requiring Definition
|
||||
#define _MINIENGINE_SDL_VERSION_ATLEAST(X,Y,Z) SDL_VERSION_ATLEAST(X,Y,Z)
|
||||
|
||||
/// Deprecated Definition
|
||||
#define _DECL_DEPRECATED [[deprecated]]
|
13003
json/json.hpp
Normal file
13003
json/json.hpp
Normal file
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user