lauchmelder/lol
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

added comments

Browse source
This commit is contained in:
Lauchmelder 2021-12-23 05:24:49 +01:00
parent 5875f1246f
commit 4c1c151422
6 changed files with 220 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

54
include/lol/Camera.hpp
View file

@ -6,8 +6,13 @@
namespace lol
{
// TODO: Find better name
/**
* A base camera object. It hides away part of the interface of a Transformable
* (because e.g. scaling doesn't make sense for a camera), and adds some other
* transformation functions that are useful for cameras.
*/
class CameraBase : public Transformable
{
public:
@ -16,21 +21,39 @@ namespace lol
void SetScale(const glm::vec3&) = delete;
void Scale(const glm::vec3&) = delete;
/**
* @brief Makes the camera look at the target position. Only affects rotation.
*/
inline void LookAt(const glm::vec3& target)
{
transformation = glm::lookAt(position, target, glm::vec3(0.0f, 1.0f, 0.0f));
}
/**
* @brief Get the cameras view matrix
*
* @returns The cameras view matrix
*/
inline const glm::mat4& GetView() const
{
return transformation;
}
/**
*@brief Get the cameras projection matrix
*
* @returns The cameras projection matrix
*/
inline const glm::mat4& GetProjection() const
{
return projection;
}
/**
* @brief Alternative rendering syntax
*
* @param drawable A Drawable that should be rendered through this camera
*/
inline void Draw(const Drawable& drawable) const
{
drawable.Draw(*this);
@ -41,28 +64,57 @@ namespace lol
};
/**
* A camera using perspective projection
*/
class Camera : public CameraBase
{
public:
/**
* @brief Constructs a new camera
*
* @param fov FOV of the camera
* @param aspect Aspect ratio of the screen
* @param zNear Near clipping plane
* @param zFar Far clipping plane
*/
Camera(float fov = 90.0f, float aspect = 1.0f, float zNear = 0.01f, float zFar = 100.0f)
{
projection = glm::perspective(glm::radians(fov), aspect, zNear, zFar);
}
/**
* @brief Update the camera configuration without affecting its transformation
*
* @param fov FOV of the camera
* @param aspect Aspect ratio of the screen
* @param zNear Near clipping plane
* @param zFar Far clipping plane
*/
inline void Update(float fov, float aspect, float zNear, float zFar)
{
projection = glm::perspective(glm::radians(fov), aspect, zNear, zFar);
}
};
/**
* A camera using orthographic projection
*/
class OrthogonalCamera : public CameraBase
{
public:
/**
* @brief Constructs a new camera
*/
OrthogonalCamera(float left = -1.0f, float right = 1.0f, float bottom = -1.0f, float top = 1.0f, float zNear = -100.0f, float zFar = 100.0f)
{
projection = glm::ortho(left, right, bottom, top, zNear, zFar);
}
/**
* @brief Update the camera configuration without affecting its transformation
*/
inline void Update(float left, float right, float bottom, float top, float zNear, float zFar)
{
projection = glm::ortho(left, right, bottom, top, zNear, zFar);

18
include/lol/Drawable.hpp
View file

@ -21,11 +21,29 @@ namespace lol
TriangleFan = GL_TRIANGLE_FAN
};
/**
* A class that can be displayed on a screen.
*/
class Drawable
{
public:
/**
* @brief Called immediately after the shader is bound, and before the VAO is drawn.
*
* @param camera The camera with which this object is rendered.
*/
virtual void PreRender(const CameraBase& camera) const { };
/**
* @brief Bind the shader and draw the VAO
*
* @param camera The camera with which this object is rendered.
*/
void Draw(const CameraBase& camera) const;
/**
* @brief The VAO can be rendered as a mesh, a set of lines, loops, strips etc
*/
void SetPrimitiveType(PrimitiveType type);
protected:

39
include/lol/Shader.hpp
View file

@ -14,21 +14,60 @@ namespace lol
class UniqueShader;
typedef std::shared_ptr<UniqueShader> Shader;
/**
* Compiles shaders into a program and manages access to that program
*/
class UniqueShader : public NonCopyable
{
public:
/**
* @brief Create a new shader program from source
*
* @param vertexShader Source code of the vertex shader
* @param fragmentShader Source code of the fragment shader
*/
UniqueShader(const std::string& vertexShader, const std::string& fragmentShader);
~UniqueShader();
/**
* @brief Creates a shareable UniqueShader. Note that they're SHAREable, not COPYable
*
* @param vertexShader Source code of the vertex shader
* @param fragmentShader Source code of the fragment shader
*
* @returns Shared pointer to a UniqueShader
*/
inline static Shader Share(const std::string& vertexShader, const std::string& fragmentShader)
{
return std::make_shared<UniqueShader>(vertexShader, fragmentShader);
}
/**
* @brief Status of the program creation
*
* @returns `true` if shader was successfully created
*/
inline bool Good() { return id != 0; }
/**
* @brief Bind this shader program
*/
void Use();
/**
* Set a 4x4 matrix uniform
*
* @param name Name of the uniform
* @param value Value of the uniform
*/
void SetUniform(const std::string& name, const glm::mat4& value);
/**
* Set a 4 component vector uniform
*
* @param name Name of the uniform
* @param value Value of the uniform
*/
void SetUniform(const std::string& name, const glm::vec4& value);
private:

76
include/lol/Transformable.hpp
View file

@ -6,26 +6,102 @@
namespace lol
{
/**
* An object with a position, rotation and scale
*/
class Transformable
{
public:
/**
* Create new object at (0, 0, 0), no rotation and default scaling (1)
*/
Transformable();
/**
* @brief Get position of the object
*
* @return The position of the object
*/
const glm::vec3& GetPosition() const;
/**
* @brief Set position of the object
*
* @param pos The new position of the object
*/
void SetPosition(const glm::vec3& pos);
/**
* @brief Move the object
*
* @param direction Vector to move the object by
*/
void Move(const glm::vec3& direction);
/**
* @brief Get rotation of the object in euler angles
*
* @return The rotation of the object
*/
const glm::vec3 GetRotation() const;
/**
* @brief Get the rotation quaternion of the object
*
* @return The rotation of the object
*/
const glm::quat& GetQuaternion() const;
/**
* @brief Set rotation of the object via axis and angle
*
* @param axis Axis to rotate the object around
* @param angle Angle by which to rotate the object
*/
void SetRotation(const glm::vec3& axis, float angle);
/**
* @brief Set rotation of the object via euler angles
*
* @param eulerAngles The orientation of the object
*/
void SetRotation(const glm::vec3& eulerAngles);
/**
* @brief Rotate object around axis
*
* @param axis Axis to rotate the object around
* @param angle Angle by which to rotate the object
*/
void Rotate(const glm::vec3& axis, float angle);
/**
* @brief Get scale of the object
*
* @return Scale of the object
*/
const glm::vec3& GetScale() const;
/**
* @brief Set scale of the object
*
* @param scale New scale of the object
*/
void SetScale(const glm::vec3& scale);
/**
* @brief Scale object by some amount
*
* @param factor By how much to scale the object in all direction
*/
void Scale(const glm::vec3& factor);
private:
/**
* @brief Reconstructs the ultimate transformation matrix
*/
void CalculateTransformationMatrix();
protected:

32
include/lol/VertexArrayObject.hpp
View file

@ -9,7 +9,9 @@
namespace lol
{
// struct representing an OpenGL attribute pointer
/**
* Struct representing an OpenGL attribute pointer
*/
struct VertexAttribute
{
int size;
@ -24,6 +26,7 @@ namespace lol
typedef std::vector<unsigned int> IndexArray;
typedef std::vector<VertexAttribute> Layout;
// OpenGL Buffer usages (I turned them into an enum so it's easier to know what options exist)
enum class Usage
{
@ -37,18 +40,43 @@ namespace lol
// if they have the same model.
typedef std::shared_ptr<UniqueVertexArrayObject> VertexArrayObject;
// VAO structure that sets up the buffers and deletes them at the end of the lifecycle
/**
* VAO structure that sets up the buffers and deletes them at the end of the lifecycle
*/
class UniqueVertexArrayObject : public NonCopyable
{
public:
/**
* @brief Creates new VAO from a set of vertices and indices and a layout/usage description
*
* @param vertices The vertices to go into the array buffer
* @param indices The indices to go into the element array buffer
* @param layout The layout of the VAO
* @param usage Usage of the VAO (static, dynamic, stream)
*/
UniqueVertexArrayObject(const VertexArray& vertices, const IndexArray& indices, const Layout& layout, Usage usage = Usage::Static);
~UniqueVertexArrayObject();
/**
* @brief Creates a shareable UniqueVertexArrayObject. Note that they're SHAREable, not COPYable
*
* @param vertices The vertices to go into the array buffer
* @param indices The indices to go into the element array buffer
* @param layout The layout of the VAO
* @param usage Usage of the VAO (static, dynamic, stream)
*
* @returns Shared pointer to a UniqueVertexArrayObject
*/
inline static VertexArrayObject Share(const VertexArray& vertices, const IndexArray& indices, const Layout& layout, Usage usage = Usage::Static)
{
return std::make_shared<UniqueVertexArrayObject>(vertices, indices, layout, usage);
}
/**
* @brief Render the VAO
*
* @param mode The render mode (lines, triangles, ...)
*/
void Render(unsigned int mode = 4);
private:

4
include/lol/util/NonCopyable.hpp
View file

@ -2,6 +2,10 @@
namespace lol
{
/**
* A object without copy constructors or assignment operators.
* Any object inheriting from this will not be able to be copied anymore
*/
class NonCopyable
{
public: