GLApp.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "GLEnv.h"
#include "GLProgram.h"
#include "GLArray.h"
#include "GLBuffer.h"
#include "GLTexture2D.h"
#include "Image.h"
#include "GLAppKeyTranslation.h"


enum class LineDrawType {
  LIST,  
  STRIP, 
  LOOP   
};

enum class TrisDrawType {
  LIST,  
  STRIP, 
  FAN    
};
 }
*   void draw() override { /* issue draws */ }
*   void animate(double t) override { /* update state */ }
* };
* int main(){ MyApp().run(); }
* @endcode
*/
class GLApp {
public:
  GLApp(uint32_t w=640, uint32_t h=480, uint32_t s=4,
        const std::string& title = "My OpenGL App",
        bool fpsCounter=true, bool sync=true);
  virtual ~GLApp();

  void run();

  void setAnimation(bool animationActive);
  bool getAnimation() const;
  void resetAnimation();

  float getAspect() const;

  void setImageFilter(GLint magFilter, GLint minFilter);


  void drawRect(const Vec4& color, const Vec2& bl, const Vec2& tr);
  void drawRect(const Vec4& color,
                const Vec3& bl=Vec3{-1.0f,-1.0f,0.0f},
                const Vec3& br=Vec3{1.0f,-1.0f,0.0f},
                const Vec3& tl=Vec3{-1.0f,1.0f,0.0f},
                const Vec3& tr=Vec3{1.0f,1.0f,0.0f});

  void drawImage(const GLTexture2D& image, const Vec2& bl, const Vec2& tr);
  void drawImage(const Image& image, const Vec2& bl, const Vec2& tr);
  void drawImage(const GLTexture2D& image,
                 const Vec3& bl=Vec3{-1.0f,-1.0f,0.0f},
                 const Vec3& br=Vec3{1.0f,-1.0f,0.0f},
                 const Vec3& tl=Vec3{-1.0f,1.0f,0.0f},
                 const Vec3& tr=Vec3{1.0f,1.0f,0.0f});
  void drawImage(const Image& image,
                 const Vec3& bl=Vec3{-1.0f,-1.0f,0.0f},
                 const Vec3& br=Vec3{1.0f,-1.0f,0.0f},
                 const Vec3& tl=Vec3{-1.0f,1.0f,0.0f},
                 const Vec3& tr=Vec3{1.0f,1.0f,0.0f});


  void drawPoints(const std::vector<float>& data, float pointSize=1.0f, bool useTex=false);

  void drawLines(const std::vector<float>& data, LineDrawType t, float lineThickness=1.0f);

  void drawTriangles(const std::vector<float>& data, TrisDrawType t, bool wireframe, bool lighting);
  void redrawTriangles(bool wireframe);


  Mat4 computeImageTransform(const Vec2ui& imageSize) const;
  Mat4 computeImageTransformFixedHeight(const Vec2ui& imageSize,
                                        float height=1.0f,
                                        const Vec3& center=Vec3{0.0f,0.0f,0.0f}) const;
  Mat4 computeImageTransformFixedWidth(const Vec2ui& imageSize,
                                       float width=1.0f,
                                       const Vec3& center=Vec3{0.0f,0.0f,0.0f}) const;


  void setDrawProjection(const Mat4& mat);
  void setDrawTransform(const Mat4& mat);
  Mat4 getDrawProjection() const;
  Mat4 getDrawTransform() const;


  void resetPointTexture(uint32_t resolution=64);
  void setPointTexture(const std::vector<uint8_t>& shape, uint32_t x,
                       uint32_t y, uint8_t components);
  void setPointTexture(const Image& shape);
  void setPointHighlightTexture(const Image& shape);
  void resetPointHighlightTexture();
 
  // ===== Lifecycle hooks (override in subclasses) =====
  virtual void init() {}
  virtual void draw() {}
  virtual void animate(double animationTime) {}
  virtual void resize(int width, int height);
 
  // ===== Input hooks (override in subclasses) =====
  virtual void keyboard(int key, int scancode, int action, int mods) {}
  virtual void keyboardChar(unsigned int key) {}
  virtual void mouseMove(double xPosition, double yPosition) {}
  virtual void mouseButton(int button, int state, int mods, double xPosition, double yPosition) {}
  virtual void mouseWheel(double x_offset, double y_offset, double xPosition, double yPosition) {}
 
protected:
  GLEnv glEnv;                 
  Mat4 p;                      
  Mat4 mv;                     
  Mat4 mvi;                    
  GLProgram simpleProg;        
  GLProgram simplePointProg;   
  GLProgram simpleSpriteProg;  
  GLProgram simpleHLSpriteProg;
  GLProgram simpleTexProg;     
  GLProgram simpleLightProg;   
  GLArray simpleArray;         
  GLBuffer simpleVb;           
  GLTexture2D raster;          
  GLTexture2D pointSprite;     
  GLTexture2D pointSpriteHighlight; 
  double resumeTime;           
#ifdef __EMSCRIPTEN__
  float xMousePos;             
  float yMousePos;             
#endif

  void shaderUpdate();

  void closeWindow() { glEnv.setClose(); }
 
private:
  bool animationActive;   
  TrisDrawType lastTrisType; 
  GLsizei lastTrisCount;  
  bool lastLighting;      
  double startTime;       

  void mainLoop();
 
#ifdef __EMSCRIPTEN__
  static void mainLoopWrapper(void* arg) {
    GLApp* app = static_cast<GLApp*>(arg);
    app->mainLoop();
  }

  static bool sizeCallback(int eventType, const EmscriptenUiEvent *uiEvent, void *userData);
  static bool keyCallback(int eventType, const EmscriptenKeyboardEvent* keyEvent, void* userData);
  static bool cursorPositionCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
  static bool mouseButtonUpCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
  static bool mouseButtonDownCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
  static bool mouseButtonCallback(int eventType, const EmscriptenMouseEvent *mouseEvent, void *userData);
  static bool scrollCallback(int eventType, const EmscriptenWheelEvent *wheelEvent, void *userData);
#else
  static GLApp* staticAppPtr;
  static void sizeCallback(GLFWwindow* window, int width, int height);
  static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
  static void keyCharCallback(GLFWwindow* window, unsigned int codepoint);
  static void cursorPositionCallback(GLFWwindow* window, double xPosition, double yPosition);
  static void mouseButtonCallback(GLFWwindow* window, int button, int state, int mods);
  static void scrollCallback(GLFWwindow* window, double x_offset, double y_offset);
#endif

  void triangulate(const Vec3& p0,
                   const Vec3& p1, const Vec4& c1,
                   const Vec3& p2, const Vec4& c2,
                   const Vec3& p3,
                   float lineThickness,
                   std::vector<float>& trisData);
};