renderer.h

// Copyright 2020, Aline Normoyle, alinen@savvysine.com, MIT License
 
#ifndef AGL_RENDERER_H_
#define AGL_RENDERER_H_
 
#include <vector>
#include <list>
#include <string>
#include <map>
#include "agl/agl.h"
#include "agl/aglm.h"
#include "agl/image.h"
#include "agl/mesh.h"
 
namespace agl {
 
enum BlendMode {
  DEFAULT,
  ADD,
  BLEND
};
 
class Renderer {
 public:
  Renderer();
  virtual ~Renderer();
 
  void init();
 
  void cleanup();
 
  bool initialized() const;
 
 
  void perspective(float fovRadians,
      float aspect, float near, float far);
 
  void ortho(float minx, float maxx,
      float miny, float maxy, float minz, float maxz);
 
  void lookAt(const glm::vec3& lookfrom,
        const glm::vec3& lookat,
        const glm::vec3& up = glm::vec3(0.0f, 1.0f, 0.0f));
 
  glm::vec3 cameraPosition() const;
 
  glm::mat4 projectionMatrix() const { return _projectionMatrix; }
 
  glm::mat4 viewMatrix() const { return _viewMatrix; }
 
 
  void loadShader(const std::string& name,
      const std::string& vs, const std::string& fs);
 
  void beginShader(const std::string& shaderName);
 
  void endShader();
 
  void beginRenderTexture(const std::string& targetName);
 
  void endRenderTexture();
 
  void loadRenderTexture(const std::string& name, int slot,
      int width, int height);
 
  void cleanupShaders();
 
  void setUniform(const std::string& name, float x, float y, float z);
 
  void setUniform(const std::string& name, float x, float y, float z, float w);
 
  void setUniform(const std::string& name, const glm::vec2 &v);
 
  void setUniform(const std::string& name, const glm::vec3 &v);
 
  void setUniform(const std::string& name, const glm::vec4 &v);
 
  void setUniform(const std::string& name, const glm::mat4 &m);
 
  void setUniform(const std::string& name, const glm::mat3 &m);
 
  void setUniform(const std::string& name, float val);
 
  void setUniform(const std::string& name, int val);
 
  void setUniform(const std::string& name, bool val);
 
  void setUniform(const std::string& name, GLuint val);
 
  void texture(const std::string& uniformName, const std::string& textureName);
 
  void cubemap(const std::string& uniformName, const std::string& texName);
 
 
  void loadTexture(const std::string& name,
      const std::string& filename, int slot);
 
  void loadTexture(const std::string& name, const Image& img, int slot);
 
  void loadCubemap(const std::string& name, const std::string& dir, int slot);
 
  void loadCubemap(const std::string& name,
      const std::vector<std::string>& names, int slot);
 
  void loadCubemap(const std::string& name,
      const std::vector<Image>& images, int slot);
 
  // drawing - positioning
 
  void push();
 
  void pop();
 
  void identity();
 
  void scale(const glm::vec3& xyz);
 
  void translate(const glm::vec3& xyz);
 
  void rotate(float angleRad, const glm::vec3& axis);
 
  void transform(const glm::mat4& trs);
 
  void blendMode(BlendMode mode);
 
 
  void sprite(const glm::vec3& pos, const glm::vec4& color, float size);
 
  void line(const glm::vec3& p1, const glm::vec3& p2,
      const glm::vec3& c1, const glm::vec3& c2);
 
  void text(const std::string& text, float x, float y);
 
  void fontColor(const glm::vec4& color);
 
  void fontSize(int s);
 
  float textWidth(const std::string& text);
 
  float textHeight();
 
  void sphere();
 
  void cube();
 
  void cone();
 
  void teapot();
 
  void plane();
 
  void cylinder();
 
  void capsule();
 
  void torus();
 
  void skybox(float size = 10.0);
 
  void mesh(const Mesh& m);
 
 private:
  void initBillboards();
  void initLines();
  void initMesh();
  void initText();
 
 private:
  bool _initialized;
  BlendMode _blendMode;
 
  // textures
  struct Texture {
    GLuint texId;
    int slot;
  };
  std::map<std::string, Texture> _textures;
 
  // render targets
  struct RenderTexture {
    GLuint handleId;    // fbo id
    GLuint textureId;   // render texture target
    GLuint depthId;     // depth buffer id
    int slot;           // texture slot
    int width;          // texture and depth buffer width
    int height;         // texture and depth buffer height
    GLint winProps[4];  // cached window x,y,w,h (needed to restore viewport)
  };
  std::map<std::string, RenderTexture> _renderTextures;
  std::string _activeRenderTexture;
 
  // shaders
  class Shader* _currentShader;
  std::map<std::string, class Shader*> _shaders;
  std::list<Shader*> _shaderStack;
 
  // matrix stack
  std::list<glm::mat4> _stack;
  glm::mat4 _trs;
 
  // perspective and view
  glm::mat4 _projectionMatrix;
  glm::mat4 _viewMatrix;
  glm::vec3 _lookfrom;
 
  // default meshes
  class Cube* _cube;
  class Cylinder* _cone;
  class Capsule* _capsule;
  class Cylinder* _cylinder;
  class Teapot* _teapot;
  class Torus* _torus;
  class Plane* _plane;
  class Sphere* _sphere;
  class SkyBox* _skybox;
 
  // Quad
  GLuint mBBVboPosId;
  GLuint mBBVaoId;
 
  // Line
  GLuint mVboLinePosId;
  GLuint mVboLineColorId;
  GLuint mVaoLineId;
 
  // Text
  int _fontNormal;
  unsigned int _fontColor;
  float _fontSize;
};
 
}  // namespace agl
#endif  // AGL_RENDERER_H_