Grapic.h

Go to the documentation of this file.

/****************************************************************************
Copyright (C) 2010-2020 Alexandre Meyer
 
This file is part of Grapic.
 
Grapic is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Grapic is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with Grapic.  If not, see <http://www.gnu.org/licenses/>.
*****************************************************************************/
 
#ifndef GRAPIC_H
#define GRAPIC_H
 
 
#include <cassert>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <vector>
#include <cmath>
#include <cassert>
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <thread>
#include <chrono>
#include <vector>
#include <algorithm>
 
#include <SDL.h>
#include <SDL_ttf.h>
#include <SDL_image.h>
 
 
 
namespace grapic
{
 
 
 
 
 
class Grapic
{
public:
    Grapic();
    void init(const char* name, int w, int h, int posx=-1, int posy=-1, SDL_WindowFlags flag = SDL_WindowFlags(0), std::string render_driver="");
    bool manageEvent();
 
    void clear();
    void clearEvent();
    bool display();
    void quit();
    void color(unsigned char r, unsigned char g, unsigned char b, unsigned char a=255);
    void colorf(float r, float g, float b, float a=1.f);
    SDL_Color& getColor();
    SDL_Color& getBackgroundColor();
    void backgroundColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a=255);
    void backgroundColorf(float r, float g, float b, float a=1.f);
    int inverseY(int y);
    void setFont(int s, const char* ttf=NULL);
    int keyHasBeenPressed(unsigned int sc);
    void setKeyRepeatMode(bool kr);
    int getFontSize();
    void qToQuit(bool enable);
    float framesPerSecond();
    unsigned int lastFrameTime();
 
    const SDL_Window* window() const { return m_window; }
    SDL_Window* window() { return m_window; }
    SDL_Renderer * renderer() { return m_renderer; }
    const SDL_Renderer * renderer() const { return m_renderer; }
    TTF_Font* font() { return m_font; }
    const TTF_Font* font() const { return m_font; }
    bool hasFinished() const { return m_quit; }
    bool isInit() const { return m_window; }
    Uint32 textureFormat() const { return m_textureFormat; }
    int winDimX() const { return m_width; }
    int winDimY() const { return m_height; }
 
    static Grapic& singleton(bool secure=true);
 
protected:
    int m_width;
    int m_height;
    SDL_Window* m_window;
    SDL_Renderer *m_renderer;
    SDL_RendererInfo m_renderInfo;
    Uint32 m_textureFormat;
    TTF_Font *m_font;
    std::string m_fontFile;
    int m_fontSize;
    bool m_quit;
    bool m_anim;
    bool press_q_quit;
    SDL_Color m_currentColor;
    SDL_Color m_backgroundColor;
    std::vector<int> m_keyStates;
    bool m_keyRepeatMode;
    int imagesSavedCount;
    
    // vars used for framerate calculation
    unsigned int m_frameTime[60];
    float m_averageFramePerSecond;
    unsigned int m_lastTime;
    unsigned int m_frameNumber;
    unsigned long m_frameSum;
 
    void initKeyArray();
    void help() const;
    bool manageOneEvent(SDL_Event event);
 
    void initFrameCounter();
    void updateFrameCounter();
 
    static Grapic* currentGrapic;
    friend void winInit(const char* name, int w, int h, int posx, int posy);
    friend void winQuit();
};
 
 
 
 
class Image
{
public:
    Image();
    Image(const char* filename, bool transparency, unsigned char r, unsigned char g, unsigned b, unsigned char a);
    Image(const Image& im);
    Image(int w, int h);
    ~Image();
 
    Image& operator=(const Image& im);
 
    void copy(const Image& im);
    void savePNG(const char* filename) const;
    bool isInit() const;
    unsigned char get(int x, int y, int c) const;
    void set(int x, int y, unsigned char r, unsigned char g, unsigned b, unsigned char a);
    void printInfo() const;
 
    const SDL_Surface* surface() const;
 
    void draw(int x, int y, int w, int h);
    void draw(int x, int y, int w, int h, float angle, int flip);
 
protected:
    SDL_Surface* m_surface;
    SDL_Texture* m_texture;
    bool* m_has_changed;
    int* nb_instance;
 
    void init(int w, int h);
    void destroy();
};
 
 
 
 
 
class Menu
{
public:
    Menu();
    void change(int i, const std::string& str);
    int select() const;
    void setSelect(int s);
    int caseToPixel(int c, int ymin, int ymax) const;
    void draw(int xmin, int ymin, int xmax, int ymax);
    void add(const std::string& str);
    bool has_changed();
 
protected:
    std::vector<std::string> m_txt;
    int m_select;
    bool m_has_changed;
    bool m_visible;
};
 
 
 
typedef std::vector< std::pair<float,float> > Curve;
class Plot
{
public:
    Plot();
    void clear();
    void setSize(const int n);
    void add(float x, float y, int curve_n);
    void draw(int xmin, int ymin, int xmax, int ymax, bool clearOrNot) const;
    void draw( const Curve& cu, int xmin, int ymin, int xmax, int ymax, float fxmin, float fymin, float fxmax, float fymax) const;
    void minMax(float& fxmin, float& fymin, float& fxmax, float& fymax, int& maxsize) const;
 
protected:
    std::vector< Curve  > m_dat;
    int m_nb_plot_max;
};
 
 
 
 
 
 
 
 
 
//==================================================================================================
//==================================================================================================
//==================================================================================================
//============================= GRAPIC FUNCTIONS ===================================================
//==================================================================================================
//==================================================================================================
//==================================================================================================
 
 
 
 
inline void winInit(const char* name, int w, int h, int posx=-1, int posy=-1)
{
    Grapic::currentGrapic = new Grapic();
    Grapic::singleton(false).init(name,w,h,posx,posy);
}
 
inline void winClear()
{
    grapic::Grapic::singleton().clear();
}
 
inline bool winHasFinished()
{
    return Grapic::singleton().hasFinished();
}
 
inline void winClearEvent()
{
    grapic::Grapic::singleton().clearEvent();
}
 
void winSetPosition(int w, int h, int ps, int py, bool fullscreen);
 
 
inline bool winDisplay()
{
    return Grapic::singleton().display();
}
 
inline void winQuit()
{
    Grapic::singleton().quit();
    if (Grapic::currentGrapic)
    {
        delete Grapic::currentGrapic;
        Grapic::currentGrapic = nullptr;
    }
}
 
inline void savePerformanceMode(bool reduceFPS)
{
    SDL_GL_SetSwapInterval(reduceFPS);
}
 
inline float framesPerSecond()
{
    return Grapic::singleton().framesPerSecond();
}
 
inline unsigned int lastFrameTime()
{
    return Grapic::singleton().lastFrameTime();
}
 
inline void color(unsigned char _r = 255, unsigned char _g = 255, unsigned char _b = 255, unsigned char _a = 255)
{
    Grapic::singleton().color( _r, _g, _b, _a );
}
 
inline void colorf(float _r = 1.f, float _g = 1.f, float _b = 1.f, float _a = 1.f)
{
    Grapic::singleton().colorf( _r, _g, _b, _a );
}
 
inline void backgroundColor(unsigned char _r = 255, unsigned char _g = 255, unsigned char _b = 255, unsigned char _a = 255)
{
    Grapic::singleton().backgroundColor( _r, _g, _b, _a);
}
 
inline void backgroundColorf(float _r = 1.f, float _g = 1.f, float _b = 1.f, float _a = 1.f)
{
    Grapic::singleton().backgroundColorf( _r, _g, _b, _a);
}
 
void circle(int xc, int yc, int radius);
 
void circleFill(int xc, int yc, int radius);
 
void ellipse(int xc, int yc, int horizontal, int vertical);
 
void ellipseFill(int xc, int yc, int horizontal, int vertical);
 
void rectangle(int xmin, int ymin, int xmax, int ymax);
 
void rectangleFill(int xmin, int ymin, int xmax, int ymax);
 
inline void line(int x1, int y1, int x2, int y2)
{
    Grapic& g = Grapic::singleton();
    SDL_RenderDrawLine( g.renderer(), x1, g.inverseY(y1), x2, g.inverseY(y2));
}
 
void put_pixel(int x, int y, unsigned char r, unsigned char g, unsigned char b, unsigned char a=255);
 
inline void point(int x, int y)
{
    Grapic& g = Grapic::singleton();
    SDL_RenderDrawPoint( g.renderer(), x, g.inverseY(y));
}
 
inline void points(int p[][2], int n)
{
    Grapic& g = Grapic::singleton();
    SDL_RenderDrawPoints( g.renderer(), ((const SDL_Point*)(p)), n);
}
 
void grid(int xmin, int ymin, int xmax, int ymax, int nx, int ny);
 
inline int irand(int rmin=0, int rmax=100)
{
    return rmin + rand() % (rmax - rmin + 1);
}
 
inline float frand(float rmin = 0.f, float rmax = 1.f)
{
    float r = static_cast<float>(rand()) / RAND_MAX;
    return rmin + r * (rmax - rmin);
}
 
inline float elapsedTime()
{
    return 0.001f * SDL_GetTicks();
}
 
inline int isKeyPressed(int key)
{
    Grapic& g = Grapic::singleton();
    return (g.keyHasBeenPressed(key)); // || (state[key]>0) );
}
 
 
inline void setKeyRepeatMode(bool repeat)
{
    Grapic& g = Grapic::singleton();
    g.setKeyRepeatMode(repeat);
}
 
 
inline void delay(int d)
{
    SDL_Delay(d);
}
 
inline bool isMousePressed(int button)
{
    return SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON(button);
}
 
void mousePos(int& x, int& y);
 
void mousePosGlobal(int& x, int& y);
 
 
inline bool winManageEvent()
{
    return Grapic::singleton().manageEvent();
}
 
inline void fontSize(int s)
{
    Grapic::singleton().setFont(s);
}
 
inline void selectFont(const char* path)
{
    Grapic::singleton().setFont(Grapic::singleton().getFontSize(), path);
}
 
void print(int x, int y, const char* txt);
 
inline void print(int x, int y, int nb)
{
    char txt[64];
    sprintf(txt,"%d", nb);
    print(x,y,txt);
}
 
 
inline void print(int x, int y, float nb)
{
    char txt[64];
    sprintf(txt,"%.2f", nb);
    print(x,y,txt);
}
 
void pressSpace(bool isPrint=true);
 
 
 
 
inline Image image(const char* filename, bool transparency=false, unsigned char r=255, unsigned char g=255, unsigned b=255, unsigned char a=255)
{
    return Image(filename, transparency, r, g, b, a);
}
 
 
inline Image image(int w, int h)
{
    return Image(w,h);
}
 
Image image_copy(const Image& im);
 
inline void image_savePNG(const Image& im, const char* filename)
{
    im.savePNG(filename);
}
 
inline void image_draw(Image& im, int x, int y, int w=-1, int h=-1)
{
    im.draw(x,y,w,h);
}
 
inline void image_draw(Image& im, int x, int y, int w, int h, float angle, float flip=SDL_FLIP_NONE)
{
    im.draw(x,y,w,h,angle,flip);
}
 
inline unsigned char image_get(const Image& im, int x, int y, int c=0)
{
    return im.get(x,y,c);
}
 
void image_set(Image& im, int x, int y, unsigned char r, unsigned char g, unsigned b, unsigned char a);
 
 
inline int image_width(const Image& im)
{
    return im.surface()->w;
}
 
 
inline int image_height(const Image& im)
{
    return im.surface()->h;
}
 
inline bool image_isInit(const Image& im)
{
    return im.isInit();
}
 
inline void image_printInfo(const Image& im)
{
    im.printInfo();
}
 
 
inline void menu_add(Menu& m, const std::string& str)
{
    m.add(str);
}
 
 
inline void menu_change(Menu& m, int i, const std::string& str)
{
    m.change(i,str);
}
 
//
// This functions returns the newly selected item only once per change. 
// Therefore, it can be used to perform 'in-loop' initialization. 
inline int menu_has_changed(Menu& m)
{
    if (m.has_changed())
    {
        return m.select();
    }
    // Invalid item
    return -1;
}
 
inline void menu_draw(Menu& m, int xmin=5, int ymin=5, int xmax=-1, int ymax=-1)
{
    m.draw(xmin,ymin,xmax,ymax);
}
 
inline int menu_select(const Menu& m)
{
    return m.select();
}
 
inline void menu_setSelect(Menu& m, int s)
{
    m.setSelect(s);
}
 
inline int caseToPixel(const Menu& m, int c, int ymin, int ymax)
{
    return m.caseToPixel(c,ymin,ymax);
}
 
 
inline void plot_clear(Plot& p )
{
    p.clear();
}
 
inline void plot_setSize(Plot& p, const int n)
{
    p.setSize(n);
}
 
inline void plot_add(Plot& p, float x, float y, int curve_n=0)
{
    p.add(x,y,curve_n);
}
 
inline void plot_draw( const Plot& p, int xmin, int ymin, int xmax, int ymax, bool clearOrNot=true)
{
    p.draw(xmin,ymin,xmax,ymax,clearOrNot);
}
 
 
 
 
void triangle(int x1, int y1,  int x2, int y2, int x3, int y3);
 
void regular_polygone(int x, int y, unsigned int apotheme, unsigned int line_number);
 
void triangleFill( int x1, int y1,
                   int x2, int y2,
                   int x3, int y3);
 
 
void regular_polygonFill(int x, int y, unsigned int apotheme, unsigned int line_number);
 
 
bool isInTriangle(float px, float py, float ax, float ay, float bx, float by, float cx, float cy);
 
 
void polygonFill(int p[][2], unsigned int number);
 
 
void polygon(int p[][2], unsigned int number);
 
 
void qToQuit(bool enable);
 
 
 
 
 
} // namespace
 
#endif
 
 
 
 
 
 
 
//==================================================================================================
//==================================================================================================
//==================================================================================================
//============================= DOCUMENTATION MAIN PAGE ============================================
//==================================================================================================
//==================================================================================================
//==================================================================================================