d7/dbf/_j_g_l_8h_source.html

#pragma once


#include <string>

#include <Color4.hpp>

#include <JGL/types/Texture.h>

#include <JGL/types/Enums.h>

#include <JGL/types/FontCache.h>

#include <JGL/types/Font.h>

#include <JGL/types/RenderTarget.h>

#include <JGL/types/Light.h>

#include <J3ML/LinearAlgebra.hpp>

#include <J3ML/LinearAlgebra/Vector2.hpp>

#include <J3ML/LinearAlgebra/Vector3.hpp>

#include <J3ML/Geometry/Sphere.hpp>

#include <J3ML/Geometry/Capsule.hpp>

#include <J3ML/Geometry/Triangle2D.hpp>


namespace JGL {

    using namespace J3ML::LinearAlgebra;

    using namespace J3ML::Geometry;


    void Update(const Vector2& window_size);

    inline void PurgeFontCache() { JGL::fontCache.purgeCache(); }

    std::array<GLfloat, 16> OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far);

    bool MeetsRequirements();

    namespace J2D {

        void Begin(RenderTarget* render_target = nullptr, bool clear_buffers = false);

        void End();

        void LightArray(Light*, size_t size);

        void LightArray(std::vector<Light> lights);


        void DrawPoint(const Color4& color, const Vector2& coordinates, float radius = 1.f);

        void DrawPoint(const Color4& color, float x, float y, float radius = 1.f);


        void DrawPoints(const Color4& color, const Vector2* points, int num_points, float radius = 1.f);


        void DrawLine(const Color4& color, const Vector2& A, const Vector2& B, float thickness = 1);

        void DrawLine(const Color4& color, float x1, float y1, float x2, float y2, float thickness = 1);


        void DrawGradientLine(const Color4& color_a, const Color4& color_b, const Vector2& A, const Vector2& B, float thickness = 1);

        void DrawGradientLine(const Color4& color_a, const Color4& color_b, float x, float y, float w, float h, float thickness = 1);


        void OutlineRect(const Color4& color, const Vector2& pos, const Vector2& size, float thickness = 1);


        void OutlineRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);


        void OutlineChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, float thickness = 1);


        void FillRect(const Color4& color, const Vector2& pos, const Vector2& size);


        void FillGradientRect(const Color4& color1, const Color4& color2, const Direction& gradient, const Vector2& pos, const Vector2& size);


        void FillRoundedRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5, unsigned int subdivisions = 8);


        void FillChamferRect(const Color4& color, const Vector2& pos, const Vector2& size, float radius = 5);


        void DrawRenderTarget(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),

                              const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawRenderTarget(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),

                              const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);


        void DrawSprite(const RenderTarget& render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),

                const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawSprite(const RenderTarget* render_target, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0 , 0),

                        const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);


        void DrawSprite(const Texture& texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),

                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawSprite(const Texture* texture, const Vector2& position, float rad_rotation = 0, const Vector2& origin = Vector2(0,0),

                        const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawSprite(const Texture& texture, float positionX, float positionY, float rad_rotation = 0, float originX = 0, float originY = 0,

                        float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawSprite(const Texture* texture, float positionX, float positionY, float rad_rotation = 0,

                        float originX = 0, float originY = 0,float scaleX = 1, float scaleY = 1,

                        const Color4& color = Colors::White, Direction inversion = Direction::None);


        void DrawPartialSprite(const Texture& texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,

                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawPartialSprite(const Texture* texture, const Vector2& position, const Vector2& sub_texture_position, const Vector2& sub_texture_size, float rad_rotation = 0,

                               const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1, 1), const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawPartialSprite(const Texture& texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,

                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);

        void DrawPartialSprite(const Texture* texture, float positionX, float positionY, float sub_texture_positionX, float sub_texture_positionY, unsigned int sub_texture_sizeX, unsigned int sub_texture_sizeY,

                               float rad_rotation = 0, float originX = 0, float originY = 0, float scaleX = 1, float scaleY = 1, const Color4& color = Colors::White, Direction inversion = Direction::None);


        void DrawMirrorSprite(const Texture& texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);

        void DrawMirrorSprite(const Texture* texture, const Vector2& position, Direction mirror_axis = Direction::Horizontal | Direction::Vertical, float rad_rotation = 0, const Vector2& origin = Vector2(0,0), const Vector2& scale = Vector2(1,1), const Color4& color = Colors::White);


        void OutlineCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 16, float thickness = 1);


        void FillCircle(const Color4& color, const Vector2& center, float radius, unsigned int subdivisions = 8);


        void OutlineTriangle(const Color4& color, const Triangle2D& tri, float thickness = 1);

        void OutlineTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC, float thickness = 1);


        void FillTriangle(const Color4& color, const Triangle2D& tri);

        void FIllTriangle(const Color4& color, const Vector2& triA, const Vector2& triB, const Vector2& triC);


        void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Triangle2D& tri);

        void FillGradientTriangle(const Color4& a_color, const Color4& b_color, const Color4& c_color, const Vector2& tri_a, const Vector2& tri_b, const Vector2& tri_c);


        void DrawCubicBezierCurve(const Color4& color, const Vector2& controlA, const Vector2& pointA, const Vector2& pointB, const Vector2& controlB,

                                  int subdivisions = 10, float thickness = 1);


        // TODO: Implement OutlinePolygon overload which takes a std::vector of points as well.


        void OutlinePolygon(const Color4& color, const Vector2* points, int points_size, float thickness = 1);


        void DrawString(const Color4& color, const std::string& text, float x, float y, float scale, u32 size, const Font& font);


        void DrawArc(const Color4& color, const Vector2& center, float radius, float arc_begin, float arc_end,

                     unsigned int subdivisions, float thickness);


        void FillPolygon(const Color4& color, const std::vector<Vector2>& points);


        void OutlineEllipse(const Color4& color, const Vector2& position, float radius_x, float radius_y, float thickness = 1, int subdivisions = 8);

        void FillEllipse(const Color4& color, const Vector2& position, float radius_x, float radius_y, int subdivisions = 8);

    }


    namespace J3D {


        void Init(const Vector2 &window_size, float fov, float far_plane);


        void ChangeFOV(float fov);


        void ChangeFarPlane(float far_plane);


        void Begin();


        void End();


        void SetMatrix(const std::vector<GLfloat> &matrix, const Vector2 &window_size);


        void DrawLine(const Color4& color, const Vector3& A, const Vector3& B, float thickness = 1.f);


        void DrawCubicBezierCurve(const Color4& color, const Vector3& controlA, const Vector3& pointA, const Vector3& pointB, const Vector3& controlB,

                                  int subdivisions = 10, float thickness = 1);


        void WireframeIcosahedron(const Color4& color, const Vector3& position, float radius, float thickness = 1.f);


        void FillIcosahedron(const Color4& color, const Vector3& position, float radius);


        void WireframeSphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, uint sectors = 10, uint stacks = 10);


        void WireframeSphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, uint sectors = 10, uint stacks = 10);


        void WireframeIcosphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, unsigned int subdivisions = 10);


        void WireframeIcosphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int subdivisions = 10);


        void WireframeCubesphere(const Color4& color, const Vector3& position, float radius, float thickness = 1.f, unsigned int subdivisions = 10);


        void WireframeCubesphere(const Color4& color, const Sphere& sphere, float thickness = 1.f, unsigned int subdivisions = 10);


        void FillSphere(const Color4& color, const Vector3& position, float radius, uint sectors = 10, uint stacks = 10);


        void FillSphere(const Color4& color, const Sphere& sphere, uint sectors = 10, uint stacks = 10);


        void FillIcosphere(const Color4& color, const Vector3& position, float radius, unsigned int subdivisions = 10);


        void FillIcosphere(const Color4& color, const Sphere& sphere, unsigned int subdivisions = 10);


        void FillCubesphere(const Color4& color, const Vector3& position, float radius, unsigned int subdivisions = 10);


        void FillCubesphere(const Color4& color, const Sphere& sphere, unsigned int subdivisions = 10);


        void WireframeAABB(const Color4& color, const Vector3& pos, const Vector3& radii, float thickness = 1.f);


        void WireframeAABB(const Color4& color, const AABB& aabb, float thickness = 1.f);


        void FillAABB(const Color4& color, const Vector3& pos, const Vector3& radii);


        void FillAABB(const Color4& color, const AABB& aabb);


        void WireframeOBB(const Color4& color, const Vector3& position, const Vector3& radii, const EulerAngle& orientation, float thickness = 1.f);


        void WireframeOBB(const Color4& color, const OBB& obb, float thickness = 1.f);


        void FillOBB(const Color4& color, const Vector3& position, const Vector3& radii, const EulerAngle& orientation);


        void FillOBB(const Color4& color, const OBB& obb);


        void WireframeCylinder();

        void FillCylinder();

        void WireframePrism();

        void FillPrism();

        void WireframePipe();

        void FillPipe();

        void WireframeCone();

        void FillCone();

        void WireframeTorus();

        void FillTorus();


        void FillCapsule(const Color3& color, const Capsule& capsule);

        void WireframeCapsule(const Color3& color, const Capsule& cap, float thickness = 1.f);

        void FillTriangleMesh(const Color3& color, const TriangleMesh& mesh);

        void WireframeTriangleMesh(const Color3& color, const TriangleMesh& mesh, float thickness = 1.f);


        void DrawString(const Color4& color, const std::string& text, const Vector3& pos, float scale, u32 size, const Font& font, const EulerAngle& angle = {0, 0, 0}, bool draw_back_face = false);


        void DrawBillboardString();


        void DrawBillboardSprite();


        void DrawSprite();

        void DrawMatrixGizmo     (const Matrix3x3&, const Vector3&);

        void DrawMatrixGizmo     (const Matrix4x4&);

        void DrawAxisAngleGizmo  (const AxisAngle&,  const Vector3&);

        void DrawQuaternionGizmo (const Quaternion&, const Vector3&);

    }

}

Enums.h

Font.h

FontCache.h

render_target
JGL::RenderTarget * render_target
Definition: JGL.cpp:14

Light.h

RenderTarget.h

Texture.h

JGL::FontCache::purgeCache
void purgeCache()
Definition: FontCache.cpp:94

JGL::Font
A Font class implementation.
Definition: Font.h:22

JGL::Light
Definition: Light.h:12

JGL::RenderTarget
Definition: RenderTarget.h:13

JGL::Texture
Represents texture data loaded on the GPU. Contains a handle that can be passed to OpenGL draw calls.
Definition: Texture.h:27

JGL::J2D::FillChamferRect
void FillChamferRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float radius=5)
Draws a filled rectangle with chamfered (beveled) corners on the screen.
Definition: JGL.cpp:850

JGL::J2D::FillPolygon
void FillPolygon(const Color4 &color, const std::vector< Vector2 > &points)
TODO Implement the following. These ones are going to be extremely annoying.

JGL::J2D::DrawCubicBezierCurve
void DrawCubicBezierCurve(const Color4 &color, const Vector2 &controlA, const Vector2 &pointA, const Vector2 &pointB, const Vector2 &controlB, int subdivisions=10, float thickness=1)
Draws a smooth, curved line segment between two control points, with the curve controlled by the two ...
Definition: JGL.cpp:716

JGL::J2D::FillCircle
void FillCircle(const Color4 &color, const Vector2 &center, float radius, unsigned int subdivisions=8)
Draws a filled circle on the screen.
Definition: JGL.cpp:645

JGL::J2D::FillGradientTriangle
void FillGradientTriangle(const Color4 &a_color, const Color4 &b_color, const Color4 &c_color, const Triangle2D &tri)
Fills a triangle defined by the provided vertices with a gradient that transitions smoothly between t...
Definition: JGL.cpp:698

JGL::J2D::DrawPoint
void DrawPoint(const Color4 &color, const Vector2 &coordinates, float radius=1.f)
Plots a single pixel on the screen.
Definition: JGL.cpp:180

JGL::J2D::DrawString
void DrawString(const Color4 &color, const std::string &text, float x, float y, float scale, u32 size, const Font &font)
Draws a text string on the screen with a given point-size and font.
Definition: TextRendering.cpp:97

JGL::J2D::OutlineChamferRect
void OutlineChamferRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float radius=5, float thickness=1)
Draws an outline of a rectangle with chamfered corners onto the screen.
Definition: JGL.cpp:854

JGL::J2D::OutlinePolygon
void OutlinePolygon(const Color4 &color, const Vector2 *points, int points_size, float thickness=1)
Draws a series of points where the last point always connects to the first point.
Definition: JGL.cpp:734

JGL::J2D::Begin
void Begin(RenderTarget *render_target=nullptr, bool clear_buffers=false)
Open a 2-D rendering context with the underlying graphics system (In this case& by default OpenGL).
Definition: JGL.cpp:51

JGL::J2D::FillRect
void FillRect(const Color4 &color, const Vector2 &pos, const Vector2 &size)
Draws a filled rectangle on the screen.
Definition: JGL.cpp:245

JGL::J2D::End
void End()
Closes a 2-D rendering context with the underlying graphics system (In this case& by default OpenGL).
Definition: JGL.cpp:138

JGL::J2D::DrawPartialSprite
void DrawPartialSprite(const Texture &texture, const Vector2 &position, const Vector2 &sub_texture_position, const Vector2 &sub_texture_size, float rad_rotation=0, const Vector2 &origin=Vector2(0, 0), const Vector2 &scale=Vector2(1, 1), const Color4 &color=Colors::White, Direction inversion=Direction::None)
Draws a piece of a sprite to the screen, similar to DrawSprite.
Definition: JGL.cpp:447

JGL::J2D::FillGradientRect
void FillGradientRect(const Color4 &color1, const Color4 &color2, const Direction &gradient, const Vector2 &pos, const Vector2 &size)
Draws a filled rectangle where the color transitions across it.
Definition: JGL.cpp:256

JGL::J2D::OutlineEllipse
void OutlineEllipse(const Color4 &color, const Vector2 &position, float radius_x, float radius_y, float thickness=1, int subdivisions=8)
Definition: JGL.cpp:892

JGL::J2D::OutlineCircle
void OutlineCircle(const Color4 &color, const Vector2 &center, float radius, unsigned int subdivisions=16, float thickness=1)
Draws an outline of a circle on the screen.
Definition: JGL.cpp:618

JGL::J2D::LightArray
void LightArray(Light *, size_t size)
Provide a list of lights to be used in 2D space.

JGL::J2D::FillEllipse
void FillEllipse(const Color4 &color, const Vector2 &position, float radius_x, float radius_y, int subdivisions=8)
Definition: JGL.cpp:920

JGL::J2D::OutlineRect
void OutlineRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float thickness=1)
Draws an outline of a rectangle on the screen.
Definition: JGL.cpp:232

JGL::J2D::DrawSprite
void DrawSprite(const RenderTarget &render_target, const Vector2 &position, float rad_rotation=0, const Vector2 &origin=Vector2(0, 0), const Vector2 &scale=Vector2(1, 1), const Color4 &color=Colors::White, Direction inversion=Direction::None)
Draws a sprite (technically, actually a render target) to the screen.
Definition: JGL.cpp:348

JGL::J2D::DrawGradientLine
void DrawGradientLine(const Color4 &color_a, const Color4 &color_b, const Vector2 &A, const Vector2 &B, float thickness=1)
Draws a line with a color gradient that transitions across it.
Definition: JGL.cpp:211

JGL::J2D::OutlineRoundedRect
void OutlineRoundedRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float radius=5, float thickness=1)
Draws an outline of a rectangle with rounded corners onto the screen.
Definition: JGL.cpp:786

JGL::J2D::FIllTriangle
void FIllTriangle(const Color4 &color, const Vector2 &triA, const Vector2 &triB, const Vector2 &triC)
Definition: JGL.cpp:881

JGL::J2D::DrawMirrorSprite
void DrawMirrorSprite(const Texture &texture, const Vector2 &position, Direction mirror_axis=Direction::Horizontal|Direction::Vertical, float rad_rotation=0, const Vector2 &origin=Vector2(0, 0), const Vector2 &scale=Vector2(1, 1), const Color4 &color=Colors::White)
To save v-ram, Use if a sprite would be identical if mirrored horizontally, vertically,...
Definition: JGL.cpp:535

JGL::J2D::DrawLine
void DrawLine(const Color4 &color, const Vector2 &A, const Vector2 &B, float thickness=1)
Plots a line (segment) on the screen.
Definition: JGL.cpp:195

JGL::J2D::OutlineTriangle
void OutlineTriangle(const Color4 &color, const Triangle2D &tri, float thickness=1)
Draws an outline of a triangle on the screen.
Definition: JGL.cpp:673

JGL::J2D::FillRoundedRect
void FillRoundedRect(const Color4 &color, const Vector2 &pos, const Vector2 &size, float radius=5, unsigned int subdivisions=8)
Draws a filled rectangle with rounded corners on the screen.
Definition: JGL.cpp:289

JGL::J2D::DrawPoints
void DrawPoints(const Color4 &color, const Vector2 *points, int num_points, float radius=1.f)
Plots a series of pixel-points on the screen, in a batch.
Definition: JGL.cpp:873

JGL::J2D::DrawArc
void DrawArc(const Color4 &color, const Vector2 &center, float radius, float arc_begin, float arc_end, unsigned int subdivisions, float thickness)
Draws an Arc (section of a circle) to the screen.
Definition: JGL.cpp:753

JGL::J2D::FillTriangle
void FillTriangle(const Color4 &color, const Triangle2D &tri)
Draws a filled triangle on the screen.
Definition: JGL.cpp:686

JGL::J2D::DrawRenderTarget
void DrawRenderTarget(const RenderTarget &render_target, const Vector2 &position, float rad_rotation=0, const Vector2 &origin=Vector2(0, 0), const Vector2 &scale=Vector2(1, 1), const Color4 &color=Colors::White, Direction inversion=Direction::None)
Draws a render-target (runtime-modifiable texture) to the screen.
Definition: JGL.cpp:343

JGL::J3D::DrawString
void DrawString(const Color4 &color, const std::string &text, const Vector3 &pos, float scale, u32 size, const Font &font, const EulerAngle &angle={0, 0, 0}, bool draw_back_face=false)
Draws a string of text in 3D space, with an arbitrary rotation.
Definition: TextRendering.cpp:165

JGL::J3D::WireframeTriangleMesh
void WireframeTriangleMesh(const Color3 &color, const TriangleMesh &mesh, float thickness=1.f)

JGL::J3D::DrawCubicBezierCurve
void DrawCubicBezierCurve(const Color4 &color, const Vector3 &controlA, const Vector3 &pointA, const Vector3 &pointB, const Vector3 &controlB, int subdivisions=10, float thickness=1)
Draws a smooth, curved line segment between two control points, with the curve controlled by the two ...
Definition: JGL.cpp:1451

JGL::J3D::FillTorus
void FillTorus()

JGL::J3D::FillAABB
void FillAABB(const Color4 &color, const Vector3 &pos, const Vector3 &radii)
Draws a solid axis-aligned bounding box in 3D space.
Definition: JGL.cpp:1297

JGL::J3D::Init
void Init(const Vector2 &window_size, float fov, float far_plane)
Initializes internals for 3D rendering. Probably will be rethought later.

JGL::J3D::FillOBB
void FillOBB(const Color4 &color, const Vector3 &position, const Vector3 &radii, const EulerAngle &orientation)
Draws an outline of an oriented bounding box in 3D space.

JGL::J3D::FillIcosphere
void FillIcosphere(const Color4 &color, const Vector3 &position, float radius, unsigned int subdivisions=10)
Draws a solid Icosphere in 3D space.

JGL::J3D::FillCubesphere
void FillCubesphere(const Color4 &color, const Vector3 &position, float radius, unsigned int subdivisions=10)
Draws a solid Cubesphere in 3D space.

JGL::J3D::WireframeIcosahedron
void WireframeIcosahedron(const Color4 &color, const Vector3 &position, float radius, float thickness=1.f)
Draws the outline of an Icosahedron in 3D space.
Definition: JGL.cpp:1187

JGL::J3D::ChangeFOV
void ChangeFOV(float fov)
Helper function to conveniently change the Field-Of-View.
Definition: JGL.cpp:973

JGL::J3D::FillPrism
void FillPrism()

JGL::J3D::DrawBillboardString
void DrawBillboardString()
Draws a string of text in 3D space that is always facing the exact direction of the camera projection...

JGL::J3D::WireframeAABB
void WireframeAABB(const Color4 &color, const Vector3 &pos, const Vector3 &radii, float thickness=1.f)
Draws an outline of an axis-aligned bounding box in 3D space.
Definition: JGL.cpp:1233

JGL::J3D::FillCylinder
void FillCylinder()

JGL::J3D::Begin
void Begin()
Open a 3-D rendering context with the underlying graphics system (In this case& by default OpenGL).
Definition: JGL.cpp:981

JGL::J3D::WireframeIcosphere
void WireframeIcosphere(const Color4 &color, const Vector3 &position, float radius, float thickness=1.f, unsigned int subdivisions=10)
Draws the outline of an Icosphere in 3D space.
Definition: JGL.cpp:1113

JGL::J3D::WireframeCubesphere
void WireframeCubesphere(const Color4 &color, const Vector3 &position, float radius, float thickness=1.f, unsigned int subdivisions=10)
Draws the outline of a Cubesphere in 3D space.

JGL::J3D::WireframePipe
void WireframePipe()

JGL::J3D::FillIcosahedron
void FillIcosahedron(const Color4 &color, const Vector3 &position, float radius)
Draws a solid Icosahedron in 3D space.

JGL::J3D::WireframeOBB
void WireframeOBB(const Color4 &color, const Vector3 &position, const Vector3 &radii, const EulerAngle &orientation, float thickness=1.f)
Draws an outline of an oriented bounding box in 3D space.

JGL::J3D::WireframeTorus
void WireframeTorus()

JGL::J3D::DrawBillboardSprite
void DrawBillboardSprite()
Draws a texture sprite in 3D space that is always facing the exact direction of the camera projection...

JGL::J3D::ChangeFarPlane
void ChangeFarPlane(float far_plane)
Helper function to change the far-plane, which is the cutoff distance for rendering.
Definition: JGL.cpp:977

JGL::J3D::WireframeCone
void WireframeCone()

JGL::J3D::WireframeCapsule
void WireframeCapsule(const Color3 &color, const Capsule &cap, float thickness=1.f)

JGL::J3D::FillSphere
void FillSphere(const Color4 &color, const Vector3 &position, float radius, uint sectors=10, uint stacks=10)
Draws a solid Sphere in 3D space.
Definition: JGL.cpp:1363

JGL::J3D::FillCapsule
void FillCapsule(const Color3 &color, const Capsule &capsule)

JGL::J3D::DrawLine
void DrawLine(const Color4 &color, const Vector3 &A, const Vector3 &B, float thickness=1.f)
Draws a line in 3D space.
Definition: JGL.cpp:1055

JGL::J3D::DrawQuaternionGizmo
void DrawQuaternionGizmo(const Quaternion &, const Vector3 &)

JGL::J3D::DrawMatrixGizmo
void DrawMatrixGizmo(const Matrix3x3 &, const Vector3 &)

JGL::J3D::FillTriangleMesh
void FillTriangleMesh(const Color3 &color, const TriangleMesh &mesh)

JGL::J3D::DrawAxisAngleGizmo
void DrawAxisAngleGizmo(const AxisAngle &, const Vector3 &)

JGL::J3D::FillPipe
void FillPipe()

JGL::J3D::FillCone
void FillCone()

JGL::J3D::SetMatrix
void SetMatrix(const std::vector< GLfloat > &matrix, const Vector2 &window_size)

JGL::J3D::DrawSprite
void DrawSprite()

JGL::J3D::WireframeCylinder
void WireframeCylinder()

JGL::J3D::End
void End()
Closes a 3-D rendering context with the underlying graphics system (In this case& by default OpenGL).
Definition: JGL.cpp:1031

JGL::J3D::WireframePrism
void WireframePrism()

JGL::J3D::WireframeSphere
void WireframeSphere(const Color4 &color, const Vector3 &position, float radius, float thickness=1.f, uint sectors=10, uint stacks=10)
Draws the outline of a Sphere in 3D space.
Definition: JGL.cpp:1068

JGL
OpenGL Wrapper for rendering 2D & 3D graphics in both a 2D and 3D context.
Definition: JGL.h:31

JGL::MeetsRequirements
bool MeetsRequirements()
Returns true if the graphics driver meets the requirements (GL Version & Extensions).
Definition: JGL.cpp:42

JGL::PurgeFontCache
void PurgeFontCache()
Definition: JGL.h:38

JGL::Update
void Update(const Vector2 &window_size)
Definition: JGL.cpp:37

JGL::OpenGLPerspectiveProjectionRH
std::array< GLfloat, 16 > OpenGLPerspectiveProjectionRH(float fovY, float aspect, float z_near, float z_far)
Definition: JGL.cpp:951

JGL::Direction
Direction
Definition: Enums.h:4

JGL::Direction::Vertical
@ Vertical

JGL::Direction::None
@ None

JGL::Direction::Horizontal
@ Horizontal

JGL::fontCache
FontCache fontCache
Definition: FontCache.h:69