Class for drawing 3D objects onto a Image [MAIN CLASS FOR THE 3D API]. More...

#include <Renderer3D.h>

Public Member Functions
TGX_NOINLINE	Renderer3D (const iVec2 &viewportSize={0, 0}, Image< color_t > im=nullptr, ZBUFFER_t zbuffer=nullptr)
	Constructor. More...

Global settings.
Methods use to query and set the global parameters of the renderer: viewport size, zbuffer, projection type...
void	setViewportSize (int lx, int ly)
	Set the size of the viewport. More...

void	setViewportSize (const iVec2 &viewport_dim)
	Set the size of the viewport. More...

void	setImage (Image< color_t > *im)
	Set the image that will be drawn onto. More...

void	setOffset (int ox, int oy)
	Set the offset of the image relative to the viewport. More...

void	setOffset (const iVec2 &offset)
	Set the offset of the image relative to the viewport. More...

void	setProjectionMatrix (const fMat4 &M)
	Set the projection matrix. More...

fMat4	getProjectionMatrix () const
	Return the current projection matrix. More...

void	useOrthographicProjection ()
	Set projection mode to orthographic (ie no z-divide). More...

void	usePerspectiveProjection ()
	Set projection mode to perspective (ie with z-divide). More...

void	setOrtho (float left, float right, float bottom, float top, float zNear, float zFar)
	Set the projection matrix as an orthographic matrix. More...

void	setFrustum (float left, float right, float bottom, float top, float zNear, float zFar)
	Set the projection matrix as a perspective matrix. More...

void	setPerspective (float fovy, float aspect, float zNear, float zFar)
	Set the projection matrix as a perspective matrix. More...

void	setCulling (int w)
	Set the face culling strategy. More...

void	setZbuffer (ZBUFFER_t *zbuffer)
	Set the z-buffer. More...

void	clearZbuffer ()
	Clear the Zbuffer. More...

void	setShaders (Shader shaders)
	Set the shaders to use for subsequent drawing operations. More...

void	setTextureWrappingMode (Shader wrap_mode)
	Set the wrap mode when for texturing. More...

void	setTextureQuality (Shader quality)
	Set the texturing quality. More...

Scene related methods.
Methods related to properties specific to the scene: camera position, lightning...
void	setViewMatrix (const fMat4 &M)
	Set the view transformation matrix. More...

fMat4	getViewMatrix () const
	Return the current view matrix. More...

void	setLookAt (float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ)
	Set the view matrix so that the camera is looking at a given direction. More...

void	setLookAt (const fVec3 eye, const fVec3 center, const fVec3 up)
	Set the view matrix so that the camera is looking at a given direction. More...

fVec4	worldToNDC (fVec3 P)
	Convert from world coordinates to normalized device coordinates (NDC). More...

iVec2	worldToImage (fVec3 P)
	Convert from world coordinates to the corresponding image pixel. More...

void	setLightDirection (const fVec3 &direction)
	Set the light source direction. More...

void	setLightAmbiant (const RGBf &color)
	Set the scene ambiant light color. More...

void	setLightDiffuse (const RGBf &color)
	Set the scene diffuse light color. More...

void	setLightSpecular (const RGBf &color)
	Set the scene specular light color. More...

void	setLight (const fVec3 direction, const RGBf &ambiantColor, const RGBf &diffuseColor, const RGBf &specularColor)
	Set all the lighting parameters of the scene at once. More...

Model related methods.
Methods related to properties specific to the model being drawn: position, material properties...
void	setModelMatrix (const fMat4 &M)
	Set the model tranformation matrix. More...

fMat4	getModelMatrix () const
	Return the model tranformation matrix. More...

void	setModelPosScaleRot (const fVec3 &center=fVec3{ 0, 0, 0 }, const fVec3 &scale=fVec3(1, 1, 1), float rot_angle=0, const fVec3 &rot_dir=fVec3{ 0, 1, 0 })
	Set the model tranformation matrix to move an object to a given a given location, scale and rotation. More...

fVec4	modelToNDC (fVec3 P)
	Convert from model coordinates to normalized device coordinates (NDC). More...

iVec2	modelToImage (fVec3 P)
	Convert from model coordinates to the corresponding image pixel. More...

void	setMaterialColor (RGBf color)
	Set the object material color. More...

void	setMaterialAmbiantStrength (float strenght=0.1f)
	Set how much the object material reflects the ambient light. More...

void	setMaterialDiffuseStrength (float strenght=0.6f)
	Set how much the object material reflects the diffuse light. More...

void	setMaterialSpecularStrength (float strenght=0.5f)
	Set how much the object material reflects the specular light. More...

void	setMaterialSpecularExponent (int exponent=16)
	Set the object specular exponent. More...

void	setMaterial (RGBf color, float ambiantStrength, float diffuseStrength, float specularStrength, int specularExponent)
	Set all the object material properties at once. More...

Drawing solid geometric primitives.
Methods for drawing meshes, triangles and quads. Remarks Normal vector are mandatory when using Gouraud shadding and must be normalized (unit lenght). Texture dimension must be power of two when using flag `SHADER_TEXTURE_WRAP_POW2`. Triangle and quads must be given in the correct winding order. The 4 vertices of a quads must be co-planar. The fastest method to display 'static' geometry is to use the drawMesh() method. Other methods are slower and should be reserved for 'dynamic' geometry. Do not forget to clear the z-buffer with `clearZbuffer()` at the beggining of each new frame.
void	drawMesh (const Mesh3D< color_t > *mesh, bool use_mesh_material=true, bool draw_chained_meshes=true)
	Draw a Mesh3D object. More...

void	drawTriangle (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const fVec3 N1=nullptr, const fVec3 N2=nullptr, const fVec3 N3=nullptr, const fVec2 T1=nullptr, const fVec2 T2=nullptr, const fVec2 T3=nullptr, const Image< color_t > *texture=nullptr)
	Draw a single triangle. More...

void	drawTriangleWithVertexColor (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const RGBf &col1, const RGBf &col2, const RGBf &col3, const fVec3 N1=nullptr, const fVec3 N2=nullptr, const fVec3 *N3=nullptr)
	Draw a single triangle with a given colors on each of its vertices. More...

void	drawTriangles (int nb_triangles, const uint16_t ind_vertices, const fVec3 vertices, const uint16_t ind_normals=nullptr, const fVec3 normals=nullptr, const uint16_t ind_texture=nullptr, const fVec2 textures=nullptr, const Image< color_t > *texture_image=nullptr)
	Draw a collection of triangles. More...

void	drawQuad (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const fVec3 &P4, const fVec3 N1=nullptr, const fVec3 N2=nullptr, const fVec3 N3=nullptr, const fVec3 N4=nullptr, const fVec2 T1=nullptr, const fVec2 T2=nullptr, const fVec2 T3=nullptr, const fVec2 T4=nullptr, const Image< color_t > *texture=nullptr)
	Draw a single quad. More...

void	drawQuadWithVertexColor (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const fVec3 &P4, const RGBf &col1, const RGBf &col2, const RGBf &col3, const RGBf &col4, const fVec3 N1=nullptr, const fVec3 N2=nullptr, const fVec3 N3=nullptr, const fVec3 N4=nullptr)
	Draw a single quad with a given colors on each of its four vertices. More...

void	drawQuads (int nb_quads, const uint16_t ind_vertices, const fVec3 vertices, const uint16_t ind_normals=nullptr, const fVec3 normals=nullptr, const uint16_t ind_texture=nullptr, const fVec2 textures=nullptr, const Image< color_t > *texture_image=nullptr)
	Draw a collection of quads. More...

Drawing solid basic shapes.
Methods for drawing cube and spheres.
void	drawCube ()
	Draw the unit cube `[-1,1]^3` in model space. More...

void	drawCube (const fVec2 v_front_ABCD[4], const Image< color_t > texture_front, const fVec2 v_back_EFGH[4], const Image< color_t > texture_back, const fVec2 v_top_HADE[4], const Image< color_t > texture_top, const fVec2 v_bottom_BGFC[4], const Image< color_t > texture_bottom, const fVec2 v_left_HGBA[4], const Image< color_t > texture_left, const fVec2 v_right_DCFE[4], const Image< color_t > texture_right)
	Draw a textured unit cube `[-1,1]^3` in model space. More...

void	drawCube (const Image< color_t > texture_front, const Image< color_t > texture_back, const Image< color_t > texture_top, const Image< color_t > texture_bottom, const Image< color_t > texture_left, const Image< color_t > texture_right)
	draw a textured unit cube [-1,1]^3 (in model space) More...

void	drawSphere (int nb_sectors, int nb_stacks)
	Draw a unit radius sphere centered at the origin `S(0,1)` in model space. More...

void	drawSphere (int nb_sectors, int nb_stacks, const Image< color_t > *texture)
	Draw a textured unit radius sphere centered at the origin S(0,1) in model space. More...

void	drawAdaptativeSphere (float quality=1.0f)
	Draw a unit radius sphere centered at the origin S(0,1) in model space. More...

void	drawAdaptativeSphere (const Image< color_t > *texture, float quality=1.0f)
	Draw a textured unit radius sphere centered at the origin S(0,1) in model space. More...

Drawing wireframe geometric primitives.
Methods for drawing wireframe meshes, triangles and quads. Two versions for each method : Fast but low quality drawing. Slow but high quality drawing (adjustable thickness, alpha-blending, anti-aliasing). Remarks Wireframe methods do not take the scene lightning into account.
void	drawWireFrameMesh (const Mesh3D< color_t > *mesh, bool draw_chained_meshes=true)
	Draw a mesh in wireframe [low quality]. More...

void	drawWireFrameMesh (const Mesh3D< color_t > *mesh, bool draw_chained_meshes, float thickness, color_t color, float opacity)
	Draw a mesh in wireframe [high quality]. More...

void	drawWireFrameLine (const fVec3 &P1, const fVec3 &P2)
	Draw a wireframe line segment [low quality]. More...

void	drawWireFrameLine (const fVec3 &P1, const fVec3 &P2, float thickness, color_t color, float opacity)
	Draw a wireframe line segment [high quality]. More...

void	drawWireFrameLines (int nb_lines, const uint16_t ind_vertices, const fVec3 vertices)
	Draw a collection of wireframe line segments [low quality]. More...

void	drawWireFrameLines (int nb_lines, const uint16_t ind_vertices, const fVec3 vertices, float thickness, color_t color, float opacity)
	Draw a collection of wireframe line segments [high quality]. More...

void	drawWireFrameTriangle (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3)
	Draw a wireframe triangle [low quality]. More...

void	drawWireFrameTriangle (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, float thickness, color_t color, float opacity)
	Draw a wireframe triangle [high quality]. More...

void	drawWireFrameTriangles (int nb_triangles, const uint16_t ind_vertices, const fVec3 vertices)
	Draw a collection of wireframe triangles [low quality]. More...

void	drawWireFrameTriangles (int nb_triangles, const uint16_t ind_vertices, const fVec3 vertices, float thickness, color_t color, float opacity)
	Draw a collection of wireframe triangles [high quality]. More...

void	drawWireFrameQuad (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const fVec3 &P4)
	Draw a wireframe quad [low quality]. More...

void	drawWireFrameQuad (const fVec3 &P1, const fVec3 &P2, const fVec3 &P3, const fVec3 &P4, float thickness, color_t color, float opacity)
	Draw a wireframe quad [high quality]. More...

void	drawWireFrameQuads (int nb_quads, const uint16_t ind_vertices, const fVec3 vertices)
	Draw a collection of wireframe quads [low quality]. More...

void	drawWireFrameQuads (int nb_quads, const uint16_t ind_vertices, const fVec3 vertices, float thickness, color_t color, float opacity)
	Draw a collection of wireframe quads [high quality]. More...

Drawing basic shapes in wireframe.
Methods for drawing wireframe cubes and spheres. Two versions for each method : Fast but low quality drawing. Slow but high quality drawin (adjustable thickness, alpha-blending, anti-aliasing). Remarks Wireframe methods do not take the scene lightning into account.
void	drawWireFrameCube ()
	Draw the wireframe cube [0,1]^3 (in model space) [low quality]. More...

void	drawWireFrameCube (float thickness, color_t color, float opacity)
	Draw the wireframe cube [0,1]^3 (in model space) [high quality]. More...

void	drawWireFrameSphere (int nb_sectors, int nb_stacks)
	Draw a wireframe unit radius sphere centered at the origin (in model space) [low quality]. More...

void	drawWireFrameSphere (int nb_sectors, int nb_stacks, float thickness, color_t color, float opacity)
	Draw a wireframe unit radius sphere centered at the origin (in model space) [high quality]. More...

void	drawWireFrameAdaptativeSphere (float quality=1.0f)
	Draw a wireframe unit radius sphere centered at the origin (in model space) [low quality]. More...

void	drawWireFrameAdaptativeSphere (float quality, float thickness, color_t color, float opacity)
	Draw a wireframe unit radius sphere centered at the origin (in model space) [high quality]. More...

Drawing 3D point clouds
Methods for drawing pixels and dots. Remarks the methods do not take the scene lightning into account.
void	drawPixel (const fVec3 &pos)
	Draw a single pixel at a given position in model space. More...

void	drawPixel (const fVec3 &pos, color_t color, float opacity)
	Draw a single pixel at a given position in model space. More...

void	drawPixels (int nb_pixels, const fVec3 *pos_list)
	Draw a list of pixels at given positions in model space. More...

void	drawPixels (int nb_pixels, const fVec3 pos_list, const int colors_ind, const color_t colors, const int opacities_ind, const float *opacities)
	Draw a list of pixels at given positions in model space with different colors and opacities. More...

void	drawDot (const fVec3 &pos, int r)
	Draw a dot/circle at a given position in model space. More...

void	drawDot (const fVec3 &pos, int r, color_t color, float opacity)
	Draw a dot/circle at a given position in model space. More...

void	drawDots (int nb_dots, const fVec3 *pos_list, const int radius)
	Draw a list of dots/circles at given positions in model space. More...

void	drawDots (int nb_dots, const fVec3 pos_list, const int radius_ind, const int radius, const int colors_ind, const color_t colors, const int opacities_ind, const float *opacities)
	Draw a list of dots/circles at given positions in model space. More...

Detailed Description

template<typename color_t, Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>
class tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >

Class for drawing 3D objects onto a Image [MAIN CLASS FOR THE 3D API].

A Renderer3D objects creates a "virtual viewport" and provides a set of methods to manage a scene and draw 3D primitives onto this viewport which is then mapped to a tgx::Image.

Template Parameters

LOADED_SHADERS

list of all shaders that may be used. By default, all shaders are enabled but if is possible to select only a subset of shaders to improve rendering speed and decrease memory usage significantly. Must a | combination of the following flags:

SHADER_PERSPECTIVE: enable perspective projection
SHADER_ORTHO: enable orthographic projection
SHADER_NOZBUFFER: enable rendering without using a z-buffer
SHADER_ZBUFFER: enable rendering with a z-buffer
SHADER_FLAT: enable flat shading
SHADER_GOURAUD: enable gouraud shading
SHADER_NOTEXTURE: enable rendering without texturing
SHADER_TEXTURE_NEAREST: enable rendering with texturing using point sampling
SHADER_TEXTURE_BILINEAR: enable rendering with texturing using bilinear sampling
SHADER_TEXTURE_WRAP_POW2: texture can use 'wrap around' mode with dimensions of texture being power of two.
SHADER_TEXTURE_CLAMP: texture can use 'clamping to edge' mode.

ZBUFFER_t

: Type used for storing z-buffer values. Must be either float or uint16_t. The z-buffer must be as large as the image (but can be smaller than the viewport when using an offset).

float: higher quality but requires 4 bytes per pixel.
uint16_t : lower quality (z-fighting may occur) but only 2 bytes per pixel.

Remarks

If a drawing call is made that requires a shader that was not enabled in the template parameter LOADED_SHADERS or if the Renderer3D object state is not valid (e.g. incorrect image size, enabled but missing z-buffer...) then the operation will fails silently. In particular, if drawing without a Z-buffer is performed, the flag SHADER_NOZBUFFER must be set in LOADED_SHADERS. Similarly, if drawing without texturing is performed, the flag SHADER_NOTEXTURE must be set in LOADED_SHADERS.
Z-buffer testing is enabled as soon as a valid z-buffer is provided (with Renderer3D::setZbuffer()). Do not forget to erase the z-buffer with Renderer3D::clearZbuffer() at the start of a new frame.
Normal vectors are mandatory when using Gouraud shading and must always be normalized (unit lenght) !
Texture dimensions must be powers of two when flag SHADER_TEXTURE_WRAP_POW2 is set.
Back-face culling is set with Renderer3D::setCulling(). Triangles and quads must then be provided in the choosen winding order.
It is more efficient to use methods that draws several primitives at once rather than issuing multiple commands for drawing triangle/quads. For static geometry, Renderer3D::drawMesh() should be use whenever possible insteaed of Renderer3D::drawQuads(), Renderer3D::drawTriangles()...
Wireframe drawing with 'high quality' is (currently) very slow. Use 'low quality' drawing if speed is required.

Constructor & Destructor Documentation

◆ Renderer3D()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

TGX_NOINLINE tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::Renderer3D	(	const iVec2 &	viewportSize = `{0, 0}`,
		Image< color_t > *	im = `nullptr`,
		ZBUFFER_t *	zbuffer = `nullptr`
	)

Constructor.

Some parameters may be set right way (but they may be also set independantly later).

Parameters

viewportSize	(Optional) Size of the viewport. See `setViewportSize()`.
im	(Optional) the destination image. See `setImage()`.
zbuffer	(Optional) the Z-buffer. See `setZbuffer()`.

Member Function Documentation

◆ setViewportSize() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setViewportSize	(	int	lx,
		int	ly
	)

Set the size of the viewport.

The normalized coordinates in [-1,1]x[-1,1] are mapped to [0,lx-1]x[0,ly-1] just before rasterization.

It is possible to use a viewport larger than the image drawn onto by using an offset for the image inside the viewport in order to perform 'tile rendering'. see setOffset().

the maximum viewport size depends on TGX_RASTERIZE_SUBPIXEL_BITS which specifies the sub-pixel precision value used by the 3D rasterizer:

subpixel bits	max viewport size LX*LY
8	2048 x 2048
6	4096 x 4096
4	8192 x 8192
2	16384 x 16384

Parameters

lx,ly The viewport size.

◆ setViewportSize() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setViewportSize ( const iVec2 & viewport_dim )

Set the size of the viewport.

Same as setViewportSize(int lx, int ly).

Parameters

viewport_dim The viewport size.

◆ setImage()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setImage ( Image< color_t > * im )

Set the image that will be drawn onto.

Remarks

The image can be smaller than the viewport. In this case, use setOffset() to select the portion of the viewport that will be drawn.
Passing nullptr remove the current image (and disables all drawing operation
until a new image is inserted).

Parameters

im	the image to draw onto for subsequent renderings.

◆ setOffset() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setOffset	(	int	ox,
		int	oy
	)

Set the offset of the image relative to the viewport.

If the image has size (sx,sy), then during rasterization the portion [ox, ox + sx[x[oy, oy+sy[ of the viewport will be drawn onto the image.

By changing the offset and redrawing several times it it possible to use an image smaller than the viewport (and also save on zbuffer space).

For example, to draw a 320x240 viewport with limited amount of memory. One can use an image of size 160x120 (37.5kb) and a z-buffer of the same size (35Kb for uint16_t) and then call the drawing method 4 times with offsets (0,0), (0,120), (160,0) and (160,120) and upload the resulting images at their correct positions on the screen between each rendering.

0warning Do not forget to clear the z-buffer after changing the offset !

Parameters

ox,oy Offset of the image inside the viewport.

◆ setOffset() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setOffset ( const iVec2 & offset )

Set the offset of the image relative to the viewport.

Same as setOffset(int ox, int oy).

Parameters

offset Offset of the image inside the viewport.

◆ setProjectionMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setProjectionMatrix ( const fMat4 & M )

Set the projection matrix.

This is the matrix that is used to project coordinate from 'view space' to normalized device coordinates (NDC).

Call this method to set a "custom" projection matrix. For the usual perspective and orthographic matrices, use instead setFrustum(), setPerspective(), setOrtho().

Parameters

M	the projection matrix to use (an internal copy is made).

Remarks

When using perspective projection, the projection matrix must store -z into the w component.
In view space, the camera is assumed to be centered at the origin, looking looking toward the negative Z axis with the Y axis pointing up (as in opengl).

See also: getProjectionMatrix()

◆ getProjectionMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

fMat4 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::getProjectionMatrix ( ) const

Return the current projection matrix.

Returns: A copy ot hte current projection matrix.

◆ useOrthographicProjection()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::useOrthographicProjection ( )

Set projection mode to orthographic (ie no z-divide).

Remarks: This method is called automatically after setOrtho() so it needs only be called, when applicable, after setProjectionMatrix().

◆ usePerspectiveProjection()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::usePerspectiveProjection ( )

Set projection mode to perspective (ie with z-divide).

Remarks: This method is called automatically after setPerspective() or setFrustum() so it needs only be called, when applicable, after setProjectionMatrix().

◆ setOrtho()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setOrtho	(	float	left,
		float	right,
		float	bottom,
		float	top,
		float	zNear,
		float	zFar
	)

Set the projection matrix as an orthographic matrix.

https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glOrtho.xml

This method automatically switches to orthographic projection mode by calling useOrthographicProjection().

Remarks: In view space, the camera is assumed to be centered at the origin, looking looking toward the negative Z axis with the Y axis pointing up (as in opengl).

Parameters

left,right	coordinates for the left and right vertical clipping planes
bottom,top	coordinates for the bottom and top horizontal clipping planes.
zNear,zFar	distances to the nearer and farther depth clipping planes.

See also: setFrustum(), setPerspective(), , Mat4::setOrtho()

◆ setFrustum()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setFrustum	(	float	left,
		float	right,
		float	bottom,
		float	top,
		float	zNear,
		float	zFar
	)

Set the projection matrix as a perspective matrix.

https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml

This method automatically switches to perspective projection mode by calling usePerspectiveProjection().

Remarks: In view space, the camera is assumed to be centered at the origin, looking looking toward the negative Z axis with the Y axis pointing up (as in opengl).

Parameters

left,right	coordinates for the left and right vertical clipping planes
bottom,top	coordinates for the bottom and top horizontal clipping planes.
zNear,zFar	distances to the nearer and farther depth clipping planes.

See also: setOrtho(), setPerspective(), Mat4::setFrustum()

◆ setPerspective()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setPerspective	(	float	fovy,
		float	aspect,
		float	zNear,
		float	zFar
	)

Set the projection matrix as a perspective matrix.

https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml

This method automatically switches to perspective projection mode by calling usePerspectiveProjection().

Remarks: In view space, the camera is assumed to be centered at the origin, looking looking toward the negative Z axis with the Y axis pointing up (as in opengl).

Parameters

fovy	field of view angle, in degrees, in the y direction.
aspect	aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
zNear	distance from the viewer to the near clipping plane.
zFar	distance from the viewer to the far clipping plane.

See also: setFrustum(), setOrtho(), Mat4::setPerspective()

◆ setCulling()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setCulling ( int w )

Set the face culling strategy.

Parameters

w	Culling direction `w>0`: Vertices in front faces are ordered counter-clockwise [default]. Clockwise faces are culled. `w<0`: Vertices in front faces are ordered clockwise. Counter-clockwise faces are culled. `w=0`: Disables face culling: both clockwise and counter-clockwise faces are drawn.

Remarks

When face culling is enabled (w != 0), and when Gouraud shading is active, the normal vectors supplied for the vertices must be the normal vectors for the front side of the triangle.
When face culling is disabled (w = 0). Both faces of a triangle are drawn so there is no more notion of 'front' and 'back' face. In this case, when using Gouraud shading, by convention, the normal vector supplied must be those corresponding to the counter-clockwise face being shown (whatever this means since these normals vector are attached to vertices and not faces anyway, but still...)

◆ setZbuffer()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setZbuffer ( ZBUFFER_t * zbuffer )

Set the z-buffer.

Warning: The zbuffer must be large enough to be used with the image that is being drawn onto. This means that we must have length at least image.width()*image.height().

Parameters

zbuffer pointer to the z-buffer to use from now one (replace the previous one if any) or nullptr.

Remarks

Setting a valid zbuffer automatically turns on z-buffer depth test.
Removing the z-buffer (by setting it to nullptr) turns off the z-buffer depth test.

◆ clearZbuffer()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::clearZbuffer ( )

Clear the Zbuffer.

This method must be called before drawing a new frame to erase the previous zbuffer.

Remarks: The z-buffer is intentionally not cleared between draw() calls to enable rendering of multiple objects on the same scene.

◆ setShaders()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setShaders ( Shader shaders )

Set the shaders to use for subsequent drawing operations.

Parameters

shaders flags to use (or'ed together with |).

See enum tgx::Shader for a complete list of flags.

Main flags

SHADER_FLAT: Use flat shading (i.e. uniform color on faces). This is the fastest drawing method but it usually gives poor results when combined with texturing. Lighting transitions between bright to dark aera may appear to flicker when using color with low resolution such as RGB565.
SHADER_GOURAUD: Use gouraud shading (linear interpolation of vertex colors) This results in smoother color transitions and works well with texturing but is more CPU intensive.
SHADER_TEXTURE: enable texture mapping. A texture must be stored in an Image<color_t> object.
- wrap mode can be set with setTextureWrappingMode() or passing along either SHADER_TEXTURE_WRAP_POW2 or SHADER_TEXTURE_CLAMP.
- drawing quality can be set with setTextureQuality() or by passing along either SHADER_TEXTURE_NEAREST or SHADER_TEXTURE_BILINEAR.

Remarks

If a shader flag is set with SetShaders() but is disabled in the template parameter LOADED_SHADER, then the drawing calls will silently fail (draw nothing).
The color on the face (for flat shading) or on the vertices (for gouraud shading) is computed according to Phong's lightning https://en.wikipedia.org/wiki/Phong_reflection_model.
Texture mapping is 'perspective correct' and can be done with either SHADER_FLAT or SHADER_GOURAUD
selected. The color of a pixel is obtained by combining to texture color at that pixel with the lightning at the position according to phong's lightning model.
For large textures stored in flash memory may be VERY slow to access when the texture is not read linearly which will happens for some (bad) triangle orientations and then cache becomes useless... This problem can be somewhat mitigated by:
- splitting large textured triangles into smaller ones: then each triangle only accesses a small part of the texture. This helps a lot wich cache optimization (this is why models with thousands of faces may display faster that a simple textured cube in some cases).
- moving the image into RAM if possible. Even moving the texture from FLASH to EXTMEM (if available) will usually give a great speed boost !

◆ setTextureWrappingMode()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setTextureWrappingMode ( Shader wrap_mode )

Set the wrap mode when for texturing.

Parameters

wrap_mode

Wrapping mode flag:

SHADER_TEXTURE_WRAP_POW2: Wrap around (repeat) the texture. This is the fastest mode but the texture size must be a power of two along each dimension.
SHADER_TEXTURE_CLAMP: Clamp to the edge. A bit slower than above but the texture can be any size.

◆ setTextureQuality()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setTextureQuality ( Shader quality )

Set the texturing quality.

Parameters

quality

Texture quality flag:

SHADER_TEXTURE_NEAREST: Use simple point sampling when texturing (fastest method).
SHADER_TEXTURE_BILINEAR: Use bilinear interpolation when texturing (slower but higher quality).

◆ setViewMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setViewMatrix ( const fMat4 & M )

Set the view transformation matrix.

This matrix is used to transform vertices from 'world coordinates' to 'view coordinates' (ie from the point of view of the camera).

Changing this matrix changes the position of the camera in the world space.

Remarks: In view space (i.e. after transformation), the camera is assumed to be centered at the origin, looking toward the negative Z axis with the Y axis pointing up (as in opengl).

Parameters

M	the view matrix to use (a copy is made).

See also: getViewMatrix(), setLookAt()

◆ getViewMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

fMat4 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::getViewMatrix ( ) const

Return the current view matrix.

Returns: a copy of the view matrix.

See also: setViewMatrix(), setLookAt()

◆ setLookAt() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLookAt	(	float	eyeX,
		float	eyeY,
		float	eyeZ,
		float	centerX,
		float	centerY,
		float	centerZ,
		float	upX,
		float	upY,
		float	upZ
	)

Set the view matrix so that the camera is looking at a given direction.

https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml

Parameters

eyeX,eyeY,eyeZ	position of the camera in world space coords.
centerX,centerY,centerZ	point the camera is looking toward in world space coords.
upX,upY,upZ	vector that tells the up direction for the camera (in world space coords).

See also: setViewMatrix(), getViewMatrix(), Mat4::setLookAt()

◆ setLookAt() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLookAt	(	const fVec3	eye,
		const fVec3	center,
		const fVec3	up
	)

Set the view matrix so that the camera is looking at a given direction.

https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluLookAt.xml

Parameters

eye	position of the camera in world space coords.
center	point the camera is looking toward in world space coords.
up	vector that tells the up direction for the camera (in world space coords).

See also: setViewMatrix(), getViewMatrix(), Mat4::setLookAt()

◆ worldToNDC()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

fVec4 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::worldToNDC ( fVec3 P )

Convert from world coordinates to normalized device coordinates (NDC).

Parameters

P	Point in the word coordinate system.

Returns: the coordinates of P on the standard viewport [-1,1]^2 according to the current position of the camera.

Remarks

the model matrix is not taken into account here.
the w value returned can be used for depth testing.

◆ worldToImage()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

iVec2 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::worldToImage ( fVec3 P )

Convert from world coordinates to the corresponding image pixel.

Parameters

P	Point in the word coordinate system.

Returns: the coordinates of the associated pixel on the image.

Remarks

The position returned may be outside of the image !
Returns (0,0) if no image is inserted.

◆ setLightDirection()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLightDirection ( const fVec3 & direction )

Set the light source direction.

The 3d rendered uses a single 'directional light' i.e. a light source comming from infinity (such as the sun).

Parameters

direction The direction the light point toward given in world coordinates.

See also: setLight(), setLightAmbiant(), setLightDiffuse(), setLightSpecular()

◆ setLightAmbiant()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLightAmbiant ( const RGBf & color )

Set the scene ambiant light color.

See Phong's lightning model: https://en.wikipedia.org/wiki/Phong_reflection_model.

Parameters

color color for the ambiant light.

See also: setLight(), setLightDirection(), setLightDiffuse(), setLightSpecular()

◆ setLightDiffuse()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLightDiffuse ( const RGBf & color )

Set the scene diffuse light color.

See Phong's lightning model: https://en.wikipedia.org/wiki/Phong_reflection_model.

Parameters

color color for the difuse light.

See also: setLight(), setLightDirection(), setLightAmbiant(), setLightSpecular()

◆ setLightSpecular()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLightSpecular ( const RGBf & color )

Set the scene specular light color.

See Phong's lightning model: https://en.wikipedia.org/wiki/Phong_reflection_model.

Parameters

color color for the specular light.

See also: setLight(), setLightDirection(), setLightAmbiant(), setLightDiffuse()

◆ setLight()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setLight	(	const fVec3	direction,
		const RGBf &	ambiantColor,
		const RGBf &	diffuseColor,
		const RGBf &	specularColor
	)

Set all the lighting parameters of the scene at once.

The 3d rendered uses a single 'directional light' i.e. a light source comming from infinity (such as the sun).

See Phong's lightning model: https://en.wikipedia.org/wiki/Phong_reflection_model.

Parameters

direction	direction the light source point toward.
ambiantColor	light ambiant color.
diffuseColor	light diffuse color.
specularColor	light specular color.

See also: setLightDirection(), setLightAmbiant(), setLightDiffuse(), setLightSpecular()

◆ setModelMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setModelMatrix ( const fMat4 & M )

Set the model tranformation matrix.

This matrix describes the transformation from local object space to view space. (i.e. the matrix specifies the position of the object in world space).

Parameters

M	the new model transformation matrix (a copy is made).

See also: getModelMatrix(), setModelPosScaleRot()

◆ getModelMatrix()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

fMat4 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::getModelMatrix ( ) const

Return the model tranformation matrix.

Returns: a copy of the current model tranformation matrix.

See also: setModelMatrix(), setModelPosScaleRot()

◆ setModelPosScaleRot()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setModelPosScaleRot	(	const fVec3 &	center = `fVec3{ 0, 0, 0 }`,
		const fVec3 &	scale = `fVec3(1, 1, 1)`,
		float	rot_angle = `0`,
		const fVec3 &	rot_dir = `fVec3{ 0, 1, 0 }`
	)

Set the model tranformation matrix to move an object to a given a given location, scale and rotation.

The method is such that, if a model is initially centered around the origin in model coordinate, then it will be placed at a given position/scale/rotation in the world coordinates after multiplication by the model transformation matrix.

Transforms are done in the following order:

The model is scaled in each direction in the model coord. according to scale
The model is rotated in model coord. around direction rot_dir and with an angle rot_angle (in degree).
The model is translated to position center in the world coord.

Parameters

center	new center position after transformation.
scale	scaling factor in each direction.
rot_angle	rotation angle (in degrees).
rot_dir	rotation axis.

See also: getModelMatrix(), setModelMatrix()

◆ modelToNDC()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

fVec4 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::modelToNDC ( fVec3 P )

Convert from model coordinates to normalized device coordinates (NDC).

Parameters

P	Point given in the model coordinate system.

Returns: the projection of P on the standard viewport [-1,1]^2` according to the current position of the camera.

Remarks: the .w value can be used for depth testing.

◆ modelToImage()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

iVec2 tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::modelToImage ( fVec3 P )

Convert from model coordinates to the corresponding image pixel.

Parameters

P	Point given in the model coordinate system.

Returns: the position of the associated pixel on the image.

Remarks

The position returned may be outside of the image !
Returns (0,0) if no image is inserted.

◆ setMaterialColor()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterialColor ( RGBf color )

Set the object material color.

This is the color used to render the object when texturing is not used.

Parameters

color The material color.

See also: setMaterialAmbiantStrength(), setMaterialDiffuseStrength(), setMaterialSpecularStrength(), setMaterialSpecularExponent(), setMaterial()

◆ setMaterialAmbiantStrength()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterialAmbiantStrength ( float strenght = 0.1f )

Set how much the object material reflects the ambient light.

Parameters

strenght ambiant lightreflection strength in [0.0f,1.0f]. Default value 0.1f.

See also: setMaterialColor(), setMaterialDiffuseStrength(), setMaterialSpecularStrength(), setMaterialSpecularExponent(), setMaterial()

◆ setMaterialDiffuseStrength()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterialDiffuseStrength ( float strenght = 0.6f )

Set how much the object material reflects the diffuse light.

Parameters

strenght diffuse light reflection strength in [0.0f,1.0f]. Default value 0.6f.

See also: setMaterialColor(), setMaterialAmbiantStrength(), setMaterialSpecularStrength(), setMaterialSpecularExponent(), setMaterial()

◆ setMaterialSpecularStrength()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterialSpecularStrength ( float strenght = 0.5f )

Set how much the object material reflects the specular light.

Parameters

strenght specular light reflection strength in [0.0f,1.0f]. Default value 0.5f.

See also: setMaterialColor(), setMaterialAmbiantStrength(), setMaterialDiffuseStrength(), setMaterialSpecularExponent(), setMaterial()

◆ setMaterialSpecularExponent()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterialSpecularExponent ( int exponent = 16 )

Set the object specular exponent.

The epxonent should be range between 0 (no specular lightning) and 100 (very localized/glossy).

Parameters

exponent Specular exponent in [0,100]. Default value 16.

See also: setMaterialColor(), setMaterialAmbiantStrength(), setMaterialDiffuseStrength(), setMaterialSpecularStrength(), setMaterial()

◆ setMaterial()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::setMaterial	(	RGBf	color,
		float	ambiantStrength,
		float	diffuseStrength,
		float	specularStrength,
		int	specularExponent
	)

Set all the object material properties at once.

Parameters

color	The material color.
ambiantStrength	The ambiant light reflection strength.
diffuseStrength	The diffuse light reflection strength.
specularStrength	The specular light reflection strength.
specularExponent	The specular exponent.

See also: setMaterialColor(), setMaterialAmbiantStrength(), setMaterialDiffuseStrength(), setMaterialSpecularStrength(), setMaterialSpecularExponent(),

◆ drawMesh()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawMesh	(	const Mesh3D< color_t > *	mesh,
		bool	use_mesh_material = `true`,
		bool	draw_chained_meshes = `true`
	)

Draw a Mesh3D object.

Parameters

mesh	The mesh to draw.
use_mesh_material	True (default) to use mesh material, otherwise use the current material instead. this flag affects also all the linked meshes if `draw_chained_meshes=true`.
draw_chained_meshes	True (default) to draw also the chained meshes, in any.

Remarks

Drawing a mesh is the most effective way of drawing a 3D object (faster than drawing individual triangles/quads) so it should be the prefered method whenever working with static geometry.
The mesh can be located in any memory region (RAM, FLASH...) but using a fast memory will
improve renderin speed noticeably. The methods cacheMesh() (or copyMeshEXTMEM() on Teensy) are available to copy a mesh to a faster memory location before rendering.

◆ drawTriangle()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawTriangle	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const fVec3 *	N1 = `nullptr`,
		const fVec3 *	N2 = `nullptr`,
		const fVec3 *	N3 = `nullptr`,
		const fVec2 *	T1 = `nullptr`,
		const fVec2 *	T2 = `nullptr`,
		const fVec2 *	T3 = `nullptr`,
		const Image< color_t > *	texture = `nullptr`
	)

Draw a single triangle.

Parameters

P1,P2,P3	coordinates (in model space) of the triangle to draw
N1,N2,N3	pointers to the normals associated with `P1, P2, P3` or `nullptr` if not using Gouraud shading.
T1,T2,T3	pointer to the texture coords. `nullptr` if not using texturing.
texture	pointer to the texture image or `nullptr` if not using texturing.

Remarks

The triangle is drawn with the current color/material.
P1,P2,P3 must be in the correct winding order (c.f. setCulling()).
the normals N1,N2,N3 are mandatory with Gouraud shading and must have unit norm.

◆ drawTriangleWithVertexColor()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawTriangleWithVertexColor	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const RGBf &	col1,
		const RGBf &	col2,
		const RGBf &	col3,
		const fVec3 *	N1 = `nullptr`,
		const fVec3 *	N2 = `nullptr`,
		const fVec3 *	N3 = `nullptr`
	)

Draw a single triangle with a given colors on each of its vertices.

Parameters

P1,P2,P3	coordinates (in model space) of the triangle to draw
col1,col2,col3	color at each vertex.
N1,N2,N3	pointers to the normals associated with `P1, P2, P3` or `nullptr` if not using Gouraud shading.

Remarks

The color inside the triangle is obtained by linear interpolation.
P1,P2,P3 must be in the correct winding order (c.f. setCulling()).
the normals N1,N2,N3 are mandatory with Gouraud shading and must have unit norm.

◆ drawTriangles()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawTriangles	(	int	nb_triangles,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices,
		const uint16_t *	ind_normals = `nullptr`,
		const fVec3 *	normals = `nullptr`,
		const uint16_t *	ind_texture = `nullptr`,
		const fVec2 *	textures = `nullptr`,
		const Image< color_t > *	texture_image = `nullptr`
	)

Draw a collection of triangles.

Parameters

nb_triangles	number of triangles to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_triangles*3` and each 3 consecutive values represent a triangle.
vertices	The array of vertices (in model space).
ind_normals	Array of normal indexes. If specified, the array must have length `nb_triangles*3`.
normals	The array of normals vectors (in model space).
ind_texture	array of texture indexes. If specified, the array must have length `nb_triangles*3`.
textures	The array of texture coords.
texture_image	The texture image to use or `nullptr` if not used

Remarks

If Gouraud shading is enabled, the normal vector must all have have unit norm.
If Gouraud shading is disabled, ind_normals and normals should be set to nullptr.
If texturing is disabled, ind_texture, textures and texture_image should be set to nullptr.
If texturing is disabled, the current material color is used to draw the triangles.

◆ drawQuad()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawQuad	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const fVec3 &	P4,
		const fVec3 *	N1 = `nullptr`,
		const fVec3 *	N2 = `nullptr`,
		const fVec3 *	N3 = `nullptr`,
		const fVec3 *	N4 = `nullptr`,
		const fVec2 *	T1 = `nullptr`,
		const fVec2 *	T2 = `nullptr`,
		const fVec2 *	T3 = `nullptr`,
		const fVec2 *	T4 = `nullptr`,
		const Image< color_t > *	texture = `nullptr`
	)

Draw a single quad.

The four vertices of the quad must be co-planar !

Parameters

P1,P2,P3,P4	coordinates (in model space) of the quad to draw
N1,N2,N3,N4	pointers to the normals associated with `P1, P2, P3, P4` or `nullptr` if not using Gouraud shading.
T1,T2,T3,T4	pointer to the texture coords. `nullptr` if not using texturing.
texture	pointer to the texture image or `nullptr` if not using texturing.

Remarks

The quad is drawn with the current color/material.
P1,P2,P3,P4 must be in the correct winding order (c.f. setCulling()).
the normals N1,N2,N3,N4 are mandatory with Gouraud shading and must have unit norm.

◆ drawQuadWithVertexColor()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawQuadWithVertexColor	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const fVec3 &	P4,
		const RGBf &	col1,
		const RGBf &	col2,
		const RGBf &	col3,
		const RGBf &	col4,
		const fVec3 *	N1 = `nullptr`,
		const fVec3 *	N2 = `nullptr`,
		const fVec3 *	N3 = `nullptr`,
		const fVec3 *	N4 = `nullptr`
	)

Draw a single quad with a given colors on each of its four vertices.

The four vertices of the quad must be co-planar !

Parameters

P1,P2,P3,P4	coordinates (in model space) of the quad to draw
col1,col2,col3,col4	color at each vertex.
N1,N2,N3,N4	pointers to the normals associated with `P1, P2, P3, P4` or `nullptr` if not using Gouraud shading.

Remarks

The color inside the quad is obtained by linear interpolation.
P1,P2,P3,P4 must be in the correct winding order (c.f. setCulling()).
the normals N1,N2,N3,N4 are mandatory with Gouraud shading and must have unit norm.

◆ drawQuads()

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawQuads	(	int	nb_quads,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices,
		const uint16_t *	ind_normals = `nullptr`,
		const fVec3 *	normals = `nullptr`,
		const uint16_t *	ind_texture = `nullptr`,
		const fVec2 *	textures = `nullptr`,
		const Image< color_t > *	texture_image = `nullptr`
	)

Draw a collection of quads.

The four vertices of a quad must always be co-planar !

Parameters

nb_quads	number of quads to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_quads*4` and each 4 consecutive values represent a quad.
vertices	The array of vertices (in model space).
ind_normals	Array of normal indexes. If specified, the array must have length `nb_quads*4`.
normals	The array of normals vectors (in model space).
ind_texture	array of texture indexes. If specified, the array must have length `nb_quads*4`.
textures	The array of texture coords.
texture_image	The texture image to use or `nullptr` if not used

Remarks

If Gouraud shading is enabled, the normal vector must all have have unit norm.
If Gouraud shading is disabled, ind_normals and normals should be set to nullptr.
If texturing is disabled, ind_texture, textures and texture_image should be set to nullptr.
If texturing is disabled, the current material color is used to draw the quads.

◆ drawCube() [1/3]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawCube ( )

Draw the unit cube [-1,1]^3 in model space.

Remarks: The model transform matrix may be used to scale, rotate and position the cube anywhere in world space.

◆ drawCube() [2/3]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawCube	(	const fVec2	v_front_ABCD[4],
		const Image< color_t > *	texture_front,
		const fVec2	v_back_EFGH[4],
		const Image< color_t > *	texture_back,
		const fVec2	v_top_HADE[4],
		const Image< color_t > *	texture_top,
		const fVec2	v_bottom_BGFC[4],
		const Image< color_t > *	texture_bottom,
		const fVec2	v_left_HGBA[4],
		const Image< color_t > *	texture_left,
		const fVec2	v_right_DCFE[4],
		const Image< color_t > *	texture_right
	)

Draw a textured unit cube [-1,1]^3 in model space.

                                             H--------E
                                             |        |
                                             |  top   |
    H-------------E                          |        |
   /.            /|                 H--------A--------D--------E
  / .   top     / |                 |        |        |        |
 /  .          /  |                 |  left  | front  |  right |
A------------D    |  right          |        |        |        |
|   .        |    |                 G--------B--------C--------F
|   G .......|....F                          |        |
|  .         |   /                           | bottom |
| .  front   |  /                            |        |
|.           | /                             G--------F
B------------C                               |        |
                                             |  back  |
                                             |        |
                                             H--------E

Remarks

The model transform matrix may be used to scale, rotate and position the cube anywhere in world space.
Each face may use a different texture (or set the image to nullptr to disable texturing a face).
This method is useful for drawing a sky-box.

Parameters

v_front_ABCD	texture coords array for the front face in order ABCD
texture_front	texture for the front face
v_back_EFGH	texture coords array for the back face in order EFGH
texture_back	texture for the back face
v_top_HADE	texture coords array for the top face in order HADE
texture_top	texture for the top face
v_bottom_BGFC	texture coords array for the bottom face in order BGFC
texture_bottom	texture for the bottom face
v_left_HGBA	texture coords array for the left face in order HGBA
texture_left	texture for the left face
v_right_DCFE	texture coords array for the right face in order DCFE
texture_right	texture for the right face

◆ drawCube() [3/3]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawCube	(	const Image< color_t > *	texture_front,
		const Image< color_t > *	texture_back,
		const Image< color_t > *	texture_top,
		const Image< color_t > *	texture_bottom,
		const Image< color_t > *	texture_left,
		const Image< color_t > *	texture_right
	)

draw a textured unit cube [-1,1]^3 (in model space)

                                             H--------E
                                             |        |
                                             |  top   |
    H-------------E                          |        |
   /.            /|                 H--------A--------D--------E
  / .   top     / |                 |        |        |        |
 /  .          /  |                 |  left  | front  |  right |
A------------D    |  right          |        |        |        |
|   .        |    |                 G--------B--------C--------F
|   G .......|....F                          |        |
|  .         |   /                           | bottom |
| .  front   |  /                            |        |
|.           | /                             G--------F
B------------C                               |        |
                                             |  back  |
                                             |        |
                                             H--------E

Remarks

The model transform matrix may be used to scale, rotate and position the cube anywhere in world space.
Each face uses a 'whole' image. Set the texture image to nullptr to disable texturing a given face.
This method is useful for drawing a sky-box.

Parameters

texture_front	texture for the front face.
texture_back	texture for the back face.
texture_top	texture for the top face.
texture_bottom	texture for the bottom face.
texture_left	texture for the left face.
texture_right	texture for the right face.

◆ drawSphere() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawSphere	(	int	nb_sectors,
		int	nb_stacks
	)

Draw a unit radius sphere centered at the origin S(0,1) in model space.

Remarks

The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.
The mesh created is a UV-sphere with a given number of sector and stacks.

Parameters

nb_sectors	number of sectors of the UV sphere.
nb_stacks	number of stacks of the UV sphere.

◆ drawSphere() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawSphere	(	int	nb_sectors,
		int	nb_stacks,
		const Image< color_t > *	texture
	)

Draw a textured unit radius sphere centered at the origin S(0,1) in model space.

Remarks

The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.
The mesh created is a UV-sphere with a given number of sector and stacks.
The texture is mapped using the Mercator projection.

Parameters

nb_sectors	number of sectors of the UV sphere.
nb_stacks	number of stacks of the UV sphere.
texture	The texture (mapped via Mercoator projection)

◆ drawAdaptativeSphere() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawAdaptativeSphere ( float quality = 1.0f )

Draw a unit radius sphere centered at the origin S(0,1) in model space.

Remarks

The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.
The mesh created is a UV-sphere and the number of sector and stacks is adjusted automatically according to the apparent size on the screen.

Parameters

quality

Quality of the mesh. Should be positive, typically between 0.5f and 2.0f.

1 : default quality
>1: finer mesh. Improve quality but decrease speed.
<1: coarser mesh. Decrease quality but improve speed.

◆ drawAdaptativeSphere() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawAdaptativeSphere	(	const Image< color_t > *	texture,
		float	quality = `1.0f`
	)

Draw a textured unit radius sphere centered at the origin S(0,1) in model space.

Remarks

The model transform matrix may be used position the sphere anywhere in world space
and change it to an ellipsoid.
The mesh created is a UV-sphere and the number of sector and stacks is adjusted
automatically according to the apparent size on the screen.
The texture is mapped using the Mercator projection.

Parameters

texture	The texture image mapped via Mercator projection.
quality	(Optional) Quality of the mesh. Should be positive, typically between 0.5f and 2.0f. `1` : default quality `>1`: finer mesh. Improve quality but decrease speed. `<1`: coarser mesh. Decrease quality but improve speed.

◆ drawWireFrameMesh() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameMesh	(	const Mesh3D< color_t > *	mesh,
		bool	draw_chained_meshes = `true`
	)

Draw a mesh in wireframe [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The mesh is drawn with the current material color (not that of the mesh). This method does not require a zbuffer but back face culling is used if it is enabled.

Parameters

mesh	The mesh to draw
draw_chained_meshes	True to draw also the chained meshes.

◆ drawWireFrameMesh() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameMesh	(	const Mesh3D< color_t > *	mesh,
		bool	draw_chained_meshes,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a mesh in wireframe [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
This method does not require a zbuffer but back face culling is used if it is enabled.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

mesh	The mesh to draw
draw_chained_meshes	True to draw also the chained meshes.
thickness	thickness of the lines.
color	color to use.
opacity	opacity multiplier in [0.0f, 1.0f].

◆ drawWireFrameLine() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameLine	(	const fVec3 &	P1,
		const fVec3 &	P2
	)

Draw a wireframe line segment [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The line is drawn with the current material color.

Parameters

P1,P2 endpoints in model space.

◆ drawWireFrameLine() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameLine	(	const fVec3 &	P1,
		const fVec3 &	P2,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a wireframe line segment [high quality].

Remarks: This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

P1,P2	endpoints in model space.
thickness	thickness of the line
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameLines() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameLines	(	int	nb_lines,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices
	)

Draw a collection of wireframe line segments [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The lines are drawn with the current material color.

Parameters

nb_lines	number of lines to draw
ind_vertices	array of vertex indices. The length of the array is `nb_lines*2` and each 2 consecutive values represent a line segment.
vertices	The array of vertices in model space.

◆ drawWireFrameLines() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameLines	(	int	nb_lines,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a collection of wireframe line segments [high quality].

Remarks: This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

nb_lines	number of lines to draw
ind_vertices	array of vertex indices. The length of the array is `nb_lines*2` and each 2 consecutive values represent a line segment.
vertices	The array of vertices in model space.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameTriangle() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameTriangle	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3
	)

Draw a wireframe triangle [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The lines are drawn with the current material color.
This method does not use the z-buffer but backface culling is used if enabled.

Parameters

P1,P2,P3 the triangle vertices in model space.

◆ drawWireFrameTriangle() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameTriangle	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a wireframe triangle [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
This method does not use the z-buffer but backface culling is used if enabled.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

P1,P2,P3	triangle vertices in model space.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameTriangles() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameTriangles	(	int	nb_triangles,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices
	)

Draw a collection of wireframe triangles [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The lines are drawn with the current material color.
This method does not use the z-buffer but backface culling is used if enabled.

Parameters

nb_triangles	number of triangles to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_triangles*3` and each 3 consecutive values represent a triangle.
vertices	Array of vertices in model space.

◆ drawWireFrameTriangles() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameTriangles	(	int	nb_triangles,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a collection of wireframe triangles [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
This method does not use the z-buffer but backface culling is used if enabled.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

nb_triangles	number of triangles to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_triangles*3` and each 3 consecutive values represent a triangle.
vertices	Array of vertices in model space.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameQuad() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameQuad	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const fVec3 &	P4
	)

Draw a wireframe quad [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The lines are drawn with the current material color.
This method does not use the z-buffer but backface culling is used if enabled.
The four vertices of the quads must be co-planar.

Parameters

P1,P2,P3,P4 the quad vertices in model space.

◆ drawWireFrameQuad() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameQuad	(	const fVec3 &	P1,
		const fVec3 &	P2,
		const fVec3 &	P3,
		const fVec3 &	P4,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a wireframe quad [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
This method does not use the z-buffer but backface culling is used if enabled.
The four vertices of the quads must be co-planar.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

P1,P2,P3,P4	the quad vertices in model space.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameQuads() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameQuads	(	int	nb_quads,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices
	)

Draw a collection of wireframe quads [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The lines are drawn with the current material color.
This method does not use the z-buffer but backface culling is used if enabled.
The four vertices of the quads must be co-planar.

Parameters

nb_quads	number of quads to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_quads*4` and each 4 consecutive values represent a quad.
vertices	Array of vertices in model space.

◆ drawWireFrameQuads() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameQuads	(	int	nb_quads,
		const uint16_t *	ind_vertices,
		const fVec3 *	vertices,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a collection of wireframe quads [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
This method does not use the z-buffer but backface culling is used if enabled.
The four vertices of the quads must be co-planar.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

nb_quads	number of quads to draw.
ind_vertices	Array of vertex indexes. The length of the array is `nb_quads*4` and each 4 consecutive values represent a quad.
vertices	Array of vertices in model space.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameCube() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameCube ( )

Draw the wireframe cube [0,1]^3 (in model space) [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The model transform matrix may be used to scale, rotate and position the cube anywhere in world space.

◆ drawWireFrameCube() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameCube	(	float	thickness,
		color_t	color,
		float	opacity
	)

Draw the wireframe cube [0,1]^3 (in model space) [high quality].

Remarks

This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
The model transform matrix may be used to scale, rotate and position the cube anywhere in world space.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameSphere() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameSphere	(	int	nb_sectors,
		int	nb_stacks
	)

Draw a wireframe unit radius sphere centered at the origin (in model space) [low quality].

Remarks

Create a UV-sphere with a given number of sector and stacks.
This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.

Parameters

nb_sectors	number of sectors in the UV sphere.
nb_stacks	number of stacks in the UV sphere.

◆ drawWireFrameSphere() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameSphere	(	int	nb_sectors,
		int	nb_stacks,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a wireframe unit radius sphere centered at the origin (in model space) [high quality].

Remarks

Create a UV-sphere with a given number of sector and stacks.
This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

nb_sectors	number of sectors in the UV sphere.
nb_stacks	number of stacks in the UV sphere.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawWireFrameAdaptativeSphere() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameAdaptativeSphere ( float quality = 1.0f )

Draw a wireframe unit radius sphere centered at the origin (in model space) [low quality].

Remarks

This method use (fast) low quality drawing: no thickness, no blending, no anti-aliasing.
The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.
The mesh created is a UV-sphere and the number of sector and stacks is adjusted automatically according to the apparent size on the screen.

Parameters

quality

Quality of the mesh. Should be positive, typically between 0.5f and 2.0f.

1 : default quality
>1: finer mesh. Improve quality but decrease speed.
<1: coarser mesh. Decrease quality but improve speed.

◆ drawWireFrameAdaptativeSphere() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawWireFrameAdaptativeSphere	(	float	quality,
		float	thickness,
		color_t	color,
		float	opacity
	)

Draw a wireframe unit radius sphere centered at the origin (in model space) [high quality].

Remarks

The model transform matrix may be used position the sphere anywhere in world space and change it to an ellipsoid.
This method use high quality drawing: blending with opacity, thickness, and anti-aliasing.
The mesh created is a UV-sphere and the number of sector and stacks is adjusted automatically according to the apparent size on the screen.

Warning: This method is very slow (may be slower that solid drawing) !

Parameters

quality	Quality of the mesh. Should be positive, typically between 0.5f and 2.0f. `1` : default quality `>1`: finer mesh. Improve quality but decrease speed. `<1`: coarser mesh. Decrease quality but improve speed.
thickness	thickness of the lines
color	color to use
opacity	opacity multiplier in [0.0f, 1.0f]

◆ drawPixel() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawPixel ( const fVec3 & pos )

Draw a single pixel at a given position in model space.

Remarks

Use the material color.
The scene lightning is ignored.

Parameters

pos	Position (in model space).

◆ drawPixel() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawPixel	(	const fVec3 &	pos,
		color_t	color,
		float	opacity
	)

Draw a single pixel at a given position in model space.

Remarks

Use blending with a given color and opacity factor.
The scene lightning is ignored.

Parameters

pos	Position (in model space).
color	color to use.
opacity	opacity multiplier in `[0.0f, 1.0f]`.

◆ drawPixels() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawPixels	(	int	nb_pixels,
		const fVec3 *	pos_list
	)

Draw a list of pixels at given positions in model space.

Remarks

Use the material color for all pixels.
The scene lightning is ignored.

Parameters

nb_pixels	number of pixels to draw.
pos_list	array of positions (in model space).

◆ drawPixels() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawPixels	(	int	nb_pixels,
		const fVec3 *	pos_list,
		const int *	colors_ind,
		const color_t *	colors,
		const int *	opacities_ind,
		const float *	opacities
	)

Draw a list of pixels at given positions in model space with different colors and opacities.

Remarks

Use blending with given colors and opacities given by a palette and a list of indices.
The scene lightning is ignored.

Parameters

nb_pixels	number of pixels to draw.
pos_list	array of positions (in model space).
colors_ind	array of color indices.
colors	array of colors.
opacities_ind	array of opacities indices.
opacities	array of opacities

◆ drawDot() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawDot	(	const fVec3 &	pos,
		int	r
	)

Draw a dot/circle at a given position in model space.

Remarks

Use the the material color.
The scene lightning is ignored.

Parameters

pos	Position in model space.
r	radius in pixels (integer valued).

◆ drawDot() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawDot	(	const fVec3 &	pos,
		int	r,
		color_t	color,
		float	opacity
	)

Draw a dot/circle at a given position in model space.

Remarks

Use blending with the given color and opacity.
The scene lightning is ignored.

Parameters

pos	Position in model space.
r	radius in pixels.
color	color to use.
opacity	The opacity for blending in [0.0f, 1.0f].

◆ drawDots() [1/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawDots	(	int	nb_dots,
		const fVec3 *	pos_list,
		const int	radius
	)

Draw a list of dots/circles at given positions in model space.

Remarks

Use the material color and the same radius for every dot.
The scene lightning is ignored.

Parameters

nb_dots	number of dots to draw
pos_list	array of positions in model space.
radius	radius in pixels

◆ drawDots() [2/2]

template<typename color_t , Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float>

void tgx::Renderer3D< color_t, LOADED_SHADERS, ZBUFFER_t >::drawDots	(	int	nb_dots,
		const fVec3 *	pos_list,
		const int *	radius_ind,
		const int *	radius,
		const int *	colors_ind,
		const color_t *	colors,
		const int *	opacities_ind,
		const float *	opacities
	)

Draw a list of dots/circles at given positions in model space.

Remarks

Use a different radius and colors for every dot.
Use blending with given colors and opacities given by a palette and a list of indices.
The scene lightning is ignored.

Parameters

nb_dots	number of dots to draw.
pos_list	array of positions in model space.
radius_ind	array of radius indices.
radius	array of radiuses.
colors_ind	array of color indices.
colors	array of colors.
opacities_ind	array of opacity indices.
opacities	array of opacities value in [0.0f, 1.0f].

The documentation for this class was generated from the following file:

src/Renderer3D.h

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ Renderer3D()

Member Function Documentation

◆ setViewportSize() [1/2]

◆ setViewportSize() [2/2]

◆ setImage()

◆ setOffset() [1/2]

◆ setOffset() [2/2]

◆ setProjectionMatrix()

◆ getProjectionMatrix()

◆ useOrthographicProjection()

◆ usePerspectiveProjection()

◆ setOrtho()

◆ setFrustum()

◆ setPerspective()

◆ setCulling()

◆ setZbuffer()

◆ clearZbuffer()

◆ setShaders()

◆ setTextureWrappingMode()

◆ setTextureQuality()

◆ setViewMatrix()

◆ getViewMatrix()

◆ setLookAt() [1/2]

◆ setLookAt() [2/2]

◆ worldToNDC()

◆ worldToImage()

◆ setLightDirection()

◆ setLightAmbiant()

◆ setLightDiffuse()

◆ setLightSpecular()

◆ setLight()

◆ setModelMatrix()

◆ getModelMatrix()

◆ setModelPosScaleRot()

◆ modelToNDC()

◆ modelToImage()

◆ setMaterialColor()

◆ setMaterialAmbiantStrength()

◆ setMaterialDiffuseStrength()

◆ setMaterialSpecularStrength()

◆ setMaterialSpecularExponent()

◆ setMaterial()

◆ drawMesh()

◆ drawTriangle()

◆ drawTriangleWithVertexColor()

◆ drawTriangles()

◆ drawQuad()

◆ drawQuadWithVertexColor()

◆ drawQuads()

◆ drawCube() [1/3]

◆ drawCube() [2/3]

◆ drawCube() [3/3]

◆ drawSphere() [1/2]

◆ drawSphere() [2/2]

◆ drawAdaptativeSphere() [1/2]

◆ drawAdaptativeSphere() [2/2]

◆ drawWireFrameMesh() [1/2]

◆ drawWireFrameMesh() [2/2]

◆ drawWireFrameLine() [1/2]

◆ drawWireFrameLine() [2/2]

◆ drawWireFrameLines() [1/2]

◆ drawWireFrameLines() [2/2]

◆ drawWireFrameTriangle() [1/2]

◆ drawWireFrameTriangle() [2/2]

◆ drawWireFrameTriangles() [1/2]

◆ drawWireFrameTriangles() [2/2]

◆ drawWireFrameQuad() [1/2]

◆ drawWireFrameQuad() [2/2]

◆ drawWireFrameQuads() [1/2]

◆ drawWireFrameQuads() [2/2]

◆ drawWireFrameCube() [1/2]

◆ drawWireFrameCube() [2/2]

◆ drawWireFrameSphere() [1/2]

◆ drawWireFrameSphere() [2/2]

◆ drawWireFrameAdaptativeSphere() [1/2]

◆ drawWireFrameAdaptativeSphere() [2/2]

◆ drawPixel() [1/2]