Renderer3D.h

Go to the documentation of this file.

 
//
// Copyright 2020 Arvind Singh
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
//version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _TGX_RENDERER3D_H_
#define _TGX_RENDERER3D_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
#include "Misc.h"
#include "Color.h"
#include "Vec2.h"
#include "Vec3.h"
#include "Vec4.h"
#include "Box2.h"
#include "Box3.h"
#include "Mat4.h"
#include "Image.h"
 
#include "Shaders.h"
#include "Rasterizer.h"
 
#include "Mesh3D.h"
#include "Mesh3Dv2.h"
 
namespace tgx
{
 
    // forward declaration for the vertices and faces of the unit cube [-1,1]^3
 
    extern const tgx::fVec3 UNIT_CUBE_VERTICES[8];
    extern const tgx::fVec3 UNIT_CUBE_NORMALS[6];
    extern const uint16_t UNIT_CUBE_FACES[6*4];
    extern const uint16_t UNIT_CUBE_FACES_NORMALS[6 * 4];
 
 
    template<typename color_t, Shader LOADED_SHADERS = TGX_SHADER_MASK_ALL, typename ZBUFFER_t = float, int MAX_DIRECTIONAL_LIGHTS = 1, int MAX_SPOT_LIGHTS = 0>
    class Renderer3D
    {
 
 
        static constexpr int MAXVIEWPORTDIMENSION = 2048 * (1 << ((8 - TGX_RASTERIZE_SUBPIXEL_BITS) >> 1)); 
 
        static_assert(is_color<color_t>::value, "color_t must be one of the color types defined in color.h");
        static_assert((std::is_same<ZBUFFER_t, float>::value) || (std::is_same<ZBUFFER_t, uint16_t>::value), "The Z-buffer type must be either float or uint16_t");
        static_assert(MAX_DIRECTIONAL_LIGHTS >= 1, "MAX_DIRECTIONAL_LIGHTS must be at least 1");
        static_assert(MAX_SPOT_LIGHTS >= 0, "MAX_SPOT_LIGHTS must be non-negative");
 
        // true if some kind of texturing may be used.
        static constexpr int ENABLE_TEXTURING = (TGX_SHADER_HAS_ONE_FLAG(LOADED_SHADERS , (SHADER_TEXTURE | SHADER_TEXTURE_AFFINE | TGX_SHADER_MASK_TEXTURE_MODE | TGX_SHADER_MASK_TEXTURE_QUALITY)));
        static constexpr int EXPLICIT_TEXTURE_MODE = (TGX_SHADER_HAS_TEXTURING_ENABLED(LOADED_SHADERS));
        static constexpr Shader DEFAULT_TEXTURE_MODE = EXPLICIT_TEXTURE_MODE ? (Shader)0 : SHADER_TEXTURE;
 
        static constexpr Shader ENABLED_SHADERS = LOADED_SHADERS | (ENABLE_TEXTURING ? DEFAULT_TEXTURE_MODE : SHADER_NOTEXTURE); // enable perspective texturing by default when only texturing options are set
        // check that disabled shaders do not completely disable all drawing operations.
        static_assert(TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS,TGX_SHADER_MASK_PROJECTION), "At least one of the two shaders SHADER_PERSPECTIVE or SHADER_ORTHO must be enabled");
        static_assert(TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS,TGX_SHADER_MASK_ZBUFFER), "At least one of the two shaders SHADER_NOZBUFFER or SHADER_ZBUFFER must be enabled");
        static_assert(TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS,TGX_SHADER_MASK_SHADING), "At least one of the shaders SHADER_UNLIT, SHADER_FLAT or SHADER_GOURAUD must be enabled");
        static_assert(TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS,TGX_SHADER_MASK_TEXTURE), "At least one of the shaders SHADER_NOTEXTURE, SHADER_TEXTURE or SHADER_TEXTURE_AFFINE must be enabled");
        static_assert((!TGX_SHADER_HAS_TEXTURING_ENABLED(ENABLED_SHADERS)) || (TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS,TGX_SHADER_MASK_TEXTURE_QUALITY)),"When using texturing, at least one of the two shaders SHADER_TEXTURE_BILINEAR or SHADER_TEXTURE_NEAREST must be enabled");
        static_assert((!TGX_SHADER_HAS_TEXTURING_ENABLED(ENABLED_SHADERS)) || (TGX_SHADER_HAS_ONE_FLAG(ENABLED_SHADERS, TGX_SHADER_MASK_TEXTURE_MODE)), "When using texturing, at least one of the two shaders SHADER_TEXTURE_WRAP_POW2 or SHADER_TEXTURE_CLAMP must be enabled");
 
 
 
       public:
 
 
        TGX_NOINLINE Renderer3D(const iVec2& viewportSize = {0,0}, Image<color_t> * im = nullptr, ZBUFFER_t * zbuffer = nullptr);
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
        void setViewportSize(int lx, int ly);
 
 
        void setViewportSize(const iVec2& viewport_dim);
 
 
        void setImage(Image<color_t>* im);
 
 
        void setOffset(int ox, int oy);
 
 
        void setOffset(const iVec2& offset);
 
 
        void setProjectionMatrix(const fMat4& M);
 
 
        fMat4 getProjectionMatrix() const;
 
 
        void useOrthographicProjection();
 
 
        void usePerspectiveProjection();
 
 
        void setOrtho(float left, float right, float bottom, float top, float zNear, float zFar);
 
 
        void setFrustum(float left, float right, float bottom, float top, float zNear, float zFar);
 
 
        void setPerspective(float fovy, float aspect, float zNear, float zFar);
 
 
        void setCulling(int w);
 
 
        void setZbuffer(ZBUFFER_t* zbuffer);
 
 
        void clearZbuffer();
 
 
        void setShaders(Shader shaders);
 
 
        void setTextureWrappingMode(Shader wrap_mode);
 
 
        void setTextureQuality(Shader quality);
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void setViewMatrix(const fMat4& M);
 
 
        fMat4 getViewMatrix() const;
 
 
        void setLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ);
 
 
        void setLookAt(const fVec3 eye, const fVec3 center, const fVec3 up);
 
 
        fVec4 worldToNDC(fVec3 P);
 
 
        iVec2 worldToImage(fVec3 P);
 
 
 
        void setLightAmbiant(const RGBf& color);
 
        void setLightDirection(const fVec3& direction);
 
 
 
 
        void setLightDiffuse(const RGBf& color);
 
 
        void setLightSpecular(const RGBf& color);
 
 
        void setLight(const fVec3 direction, const RGBf& ambiantColor, const RGBf& diffuseColor, const RGBf& specularColor);
 
 
        void setDirectionalLightCount(int count);
 
 
        int directionalLightCount() const;
 
 
        static constexpr int maxDirectionalLightCount() { return MAX_DIRECTIONAL_LIGHTS; }
 
 
        void setDirectionalLightAmbiant(const RGBf& color);
 
 
        void setDirectionalLightDirection(int index, const fVec3& direction);
 
 
        void setDirectionalLightDiffuse(int index, const RGBf& color);
 
 
        void setDirectionalLightSpecular(int index, const RGBf& color);
 
 
        void setDirectionalLight(int index, const fVec3& direction, const RGBf& diffuseColor, const RGBf& specularColor);
 
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void setModelMatrix(const fMat4& M);
 
 
        fMat4  getModelMatrix() const;
 
 
        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 });
 
 
        fVec4 modelToNDC(fVec3 P);
 
 
        iVec2 modelToImage(fVec3 P);
 
 
        void setMaterialColor(RGBf color);
 
 
        void setMaterialAmbiantStrength(float strenght = 0.1f);
 
 
        void setMaterialDiffuseStrength(float strenght = 0.6f);
 
 
        void setMaterialSpecularStrength(float strenght = 0.5f);
 
 
        void setMaterialSpecularExponent(int exponent = 16);
 
 
        void setMaterial(RGBf color, float ambiantStrength, float diffuseStrength, float specularStrength, int specularExponent);
 
 
 
 
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void drawMesh(const Mesh3D<color_t>* mesh, bool use_mesh_material = true, bool draw_chained_meshes = true);
 
 
        void drawMesh(const Mesh3Dv2<color_t>* mesh, bool use_mesh_material = true);
 
 
        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);
 
 
        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);
 
 
        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);
 
 
        void drawTriangleStrip(int nb_indices,
                               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);
 
 
 
        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);
 
 
 
        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);
 
 
 
 
        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);
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void drawCube();
 
 
        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
            );
 
 
        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
            );
 
 
        void drawSkyBox(
            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,
            float rot_angle_y = 0.0f,
            float reference_height = 0.0f,
            float skybox_radius = 32768.0f,
            Shader texture_quality = SHADER_TEXTURE_NEAREST,
            Shader texture_mode = SHADER_TEXTURE_CLAMP
            );
 
 
        void drawSkyBox(
            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,
            float rot_angle_y = 0.0f,
            float reference_height = 0.0f,
            float skybox_radius = 32768.0f,
            Shader texture_quality = SHADER_TEXTURE_NEAREST,
            Shader texture_mode = SHADER_TEXTURE_CLAMP
            );
 
 
 
        void drawSphere(int nb_sectors, int nb_stacks);
 
 
        void drawSphere(int nb_sectors, int nb_stacks, const Image<color_t>* texture);
 
 
        void drawAdaptativeSphere(float quality = 1.0f);
 
 
        void drawAdaptativeSphere(const Image<color_t>* texture, float quality = 1.0f);
 
 
 
 
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void drawWireFrameMesh(const Mesh3D<color_t>* mesh, bool draw_chained_meshes = true);
 
 
        void drawWireFrameMesh(const Mesh3Dv2<color_t>* mesh);
 
 
        void drawWireFrameMeshAA(const Mesh3D<color_t>* mesh, bool draw_chained_meshes = true);
 
 
        void drawWireFrameMeshAA(const Mesh3Dv2<color_t>* mesh);
 
 
        void drawWireFrameMesh(const Mesh3D<color_t>* mesh, bool draw_chained_meshes, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameMesh(const Mesh3Dv2<color_t>* mesh, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameLine(const fVec3& P1, const fVec3& P2);
 
 
        void drawWireFrameLineAA(const fVec3& P1, const fVec3& P2);
 
 
        void drawWireFrameLine(const fVec3& P1, const fVec3& P2, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameLines(int nb_lines, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameLinesAA(int nb_lines, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameLines(int nb_lines, const uint16_t* ind_vertices, const fVec3* vertices, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameTriangle(const fVec3& P1, const fVec3& P2, const fVec3& P3);
 
 
        void drawWireFrameTriangleAA(const fVec3& P1, const fVec3& P2, const fVec3& P3);
 
 
        void drawWireFrameTriangle(const fVec3& P1, const fVec3& P2, const fVec3& P3, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameTriangles(int nb_triangles, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameTrianglesAA(int nb_triangles, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameTriangles(int nb_triangles, const uint16_t* ind_vertices, const fVec3* vertices, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameTriangleStrip(int nb_indices, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameTriangleStripAA(int nb_indices, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameTriangleStrip(int nb_indices, const uint16_t* ind_vertices, const fVec3* vertices, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameQuad(const fVec3& P1, const fVec3& P2, const fVec3& P3, const fVec3& P4);
 
 
        void drawWireFrameQuadAA(const fVec3& P1, const fVec3& P2, const fVec3& P3, const fVec3& P4);
 
 
        void drawWireFrameQuad(const fVec3& P1, const fVec3& P2, const fVec3& P3, const fVec3& P4, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameQuads(int nb_quads, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameQuadsAA(int nb_quads, const uint16_t* ind_vertices, const fVec3* vertices);
 
 
        void drawWireFrameQuads(int nb_quads, const uint16_t* ind_vertices, const fVec3* vertices, float thickness, color_t color, float opacity);
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
        void drawWireFrameCube();
 
 
        void drawWireFrameCubeAA();
 
 
        void drawWireFrameCube(float thickness, color_t color, float opacity);
 
 
        void drawWireFrameSphere(int nb_sectors, int nb_stacks);
 
 
        void drawWireFrameSphereAA(int nb_sectors, int nb_stacks);
 
 
        void drawWireFrameSphere(int nb_sectors, int nb_stacks, float thickness, color_t color, float opacity);
 
 
        void drawWireFrameAdaptativeSphere(float quality = 1.0f);
 
 
        void drawWireFrameAdaptativeSphereAA(float quality = 1.0f);
 
 
        void drawWireFrameAdaptativeSphere(float quality, float thickness, color_t color, float opacity);
 
 
 
 
 
        /*****************************************************************************************
        *****************************************************************************************/
        /*****************************************************************************************
        ******************************************************************************************/
 
 
 
        void drawPixel(const fVec3& pos);
 
 
        void drawPixel(const fVec3& pos, color_t color, float opacity);
 
 
        void drawPixels(int nb_pixels, const fVec3* pos_list);
 
 
        void drawPixels(int nb_pixels, const fVec3* pos_list, const int* colors_ind, const color_t* colors, const int* opacities_ind, const float* opacities);
 
 
        void drawDot(const fVec3& pos, int r);
 
 
 
        void drawDot(const fVec3& pos, int r, color_t color, float opacity);
 
 
        void drawDots(int nb_dots, const fVec3* pos_list, const int radius);
 
 
        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);
 
 
 
 
 
 
 
 
 
 
    private:
 
 
 
        /*****************************************************************************************
        ******************************************************************************************
        *
        * BE CAREFUL PAST THIS POINT... FOR HERE BE DRAGONS !
        *
        ******************************************************************************************
        ******************************************************************************************/
 
 
        TGX_INLINE float _clipbound_xy() const
            {
            return (256 + 3*((MAXVIEWPORTDIMENSION * 256) / ((_lx > _ly) ? _lx : _ly))) / 1024.0f; // use integer computation up to the last divide
            //return (1.0f + 3.0f * (((float)MAXVIEWPORTDIMENSION) / ((_lx > _ly) ? _lx : _ly))) / 4.0f;
            }
 
 
        TGX_INLINE bool _validDraw() const
            {
            return ((_lx > 0) && (_ly > 0) && (_uni.im != nullptr) && (_uni.im->isValid()));
            }
 
 
        TGX_NOINLINE void _recompute_wa_wb();
 
 
        /***********************************************************
        * Making sure shader flags are coherent
        ************************************************************/
 
        TGX_NOINLINE void _rectifyShaderOrtho();
 
 
        TGX_NOINLINE void _rectifyShaderZbuffer();
 
 
        TGX_NOINLINE void _rectifyShaderShading(Shader new_shaders);
 
 
        TGX_NOINLINE void _rectifyShaderTextureMode();
 
 
        TGX_NOINLINE void _rectifyShaderTextureWrapping();
 
 
        TGX_NOINLINE void _rectifyShaderTextureQuality();
 
 
       /***********************************************************
        * DRAWING STUFF
        ************************************************************/
 
 
        void _drawTriangleClipped(const int RASTER_TYPE,
            const fVec4* Q0, const fVec4* Q1, const fVec4* Q2,
            const fVec3* N0, const fVec3* N1, const fVec3* N2,
            const fVec2* T0, const fVec2* T1, const fVec2* T2,
            const RGBf& Vcol0, const RGBf& Vcol1, const RGBf& Vcol2);
 
 
        void _drawTriangleClippedSub(const int RASTER_TYPE, const int plane,
            const RasterizerVec4& P1, const RasterizerVec4& P2, const RasterizerVec4& P3);
 
 
        void _drawTriangle(const int RASTER_TYPE,
            const fVec3* P0, const fVec3* P1, const fVec3* P2,
            const fVec3* N0, const fVec3* N1, const fVec3* N2,
            const fVec2* T0, const fVec2* T1, const fVec2* T2,
            const RGBf& Vcol0, const RGBf& Vcol1, const RGBf& Vcol2);
 
 
        void _drawTriangleStrip(const int RASTER_TYPE, int nb_indices,
            const uint16_t* ind_vertices, const fVec3* vertices,
            const uint16_t* ind_normals, const fVec3* normals,
            const uint16_t* ind_texture, const fVec2* textures);
 
 
        void _drawQuad(const int RASTER_TYPE,
            const fVec3* P0, const fVec3* P1, const fVec3* P2, const fVec3* P3,
            const fVec3* N0, const fVec3* N1, const fVec3* N2, const fVec3* N3,
            const fVec2* T0, const fVec2* T1, const fVec2* T2, const fVec2* T3,
            const RGBf& Vcol0, const RGBf& Vcol1, const RGBf& Vcol2, const RGBf& Vcol3);
 
        template<bool TEXTURE_BILINEAR, bool TEXTURE_WRAP>
        void _rasterizeSkyBoxTriangle(const RasterizerVec4& V0, const RasterizerVec4& V1, const RasterizerVec4& V2);
 
        void _rasterizeSkyBoxTriangle(const RasterizerVec4& V0, const RasterizerVec4& V1, const RasterizerVec4& V2,
            Shader texture_quality, Shader texture_mode);
 
        void _drawSkyBoxTriangleClippedSub(const int plane,
            const RasterizerVec4& P1, const RasterizerVec4& P2, const RasterizerVec4& P3,
            Shader texture_quality, Shader texture_mode);
 
        void _drawSkyBoxTriangleClipped(
            const fVec4* Q0, const fVec4* Q1, const fVec4* Q2,
            const fVec2* T0, const fVec2* T1, const fVec2* T2,
            Shader texture_quality, Shader texture_mode);
 
        void _drawSkyBoxQuad(
            const fVec4* P0, const fVec4* P1, const fVec4* P2, const fVec4* P3,
            const fVec2* T0, const fVec2* T1, const fVec2* T2, const fVec2* T3,
            Shader texture_quality, Shader texture_mode);
 
        void _drawSkyBoxFace(const fVec4 skybox_vertices[8], const uint16_t* face, const fVec2 texture_coords[4], const Image<color_t>* texture,
            Shader texture_quality, Shader texture_mode);
 
 
        void _drawMesh(const int RASTER_TYPE, const Mesh3D<color_t>* mesh);
 
        void _drawMesh(const int RASTER_TYPE, const Mesh3Dv2<color_t>* mesh, bool use_mesh_material);
 
        TGX_INLINE inline bool _discardMeshlet16b(const fVec3& sphere_center, float sphere_radius, const fVec3& cone_dir, float cone_cos) const
            {
            if (cone_cos <= -1.0f) return false;
 
            const fVec4 D = _r_modelViewM.mult0(cone_dir);
            const float dd = D.x * D.x + D.y * D.y + D.z * D.z;
            if (dd <= 1.0e-20f) return false;
 
            float dot;
            float len2;
            if (_ortho)
                {
                dot = D.z; // object-to-camera direction is +Z in view space.
                len2 = dd;
                }
            else
                {
                const fVec3 anchor = sphere_center - (cone_dir * sphere_radius);
                const fVec4 A = _r_modelViewM.mult1(anchor);
                dot = -(D.x * A.x + D.y * A.y + D.z * A.z);
                const float aa = A.x * A.x + A.y * A.y + A.z * A.z;
                if (aa <= 1.0e-20f) return false;
                len2 = dd * aa;
                }
 
            const float c2len2 = cone_cos * cone_cos * len2;
            const float dot2 = dot * dot;
            return (cone_cos >= 0.0f) ? ((dot < 0.0f) || (dot2 < c2len2))
                                      : ((dot < 0.0f) && (dot2 > c2len2));
            }
 
 
 
        /***********************************************************
        * Drawing wireframe
        ************************************************************/
 
        inline void _drawWireFrameLineFast(iVec2 P0, iVec2 P1, color_t color);
 
        template<bool CHECK_NEIGHBOR> inline void _drawWireFrameLineAAFast(const fVec2& P0, const fVec2& P1, color_t color, int32_t op);
 
        template<int MODE> void _drawWireFrameMesh(const Mesh3D<color_t>* mesh, bool draw_chained_meshes, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameMesh(const Mesh3Dv2<color_t>* mesh, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameLine(const fVec3& P1, const fVec3& P2, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameLines(int nb_lines, const uint16_t* ind_vertices, const fVec3* vertices, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameTriangle(const fVec3& P1, const fVec3& P2, const fVec3& P3, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameTriangles(int nb_triangles, const uint16_t* ind_vertices, const fVec3* vertices, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameTriangleStrip(int nb_indices, const uint16_t* ind_vertices, const fVec3* vertices, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameQuad(const fVec3& P1, const fVec3& P2, const fVec3& P3, const fVec3& P4, color_t color, float opacity, float thickness);
 
        template<int MODE> void _drawWireFrameQuads(int nb_quads, const uint16_t* ind_vertices, const fVec3* vertices, color_t color, float opacity, float thickness);
 
 
 
 
        /***********************************************************
        * Simple geometric objects
        ************************************************************/
 
 
        template<bool USE_BLENDING> void _drawPixel(const fVec3& pos, color_t color, float opacity);
 
 
        template<bool USE_COLORS, bool USE_BLENDING> void _drawPixels(int nb_pixels, const fVec3* pos_list, const int* colors_ind, const color_t* colors, const int* opacities_ind, const float* opacities);
 
 
        template<bool USE_BLENDING> void _drawDot(const fVec3& pos, int r, color_t color, float opacity);
 
 
        template<bool USE_RADIUS, bool USE_COLORS, bool USE_BLENDING> 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);
 
 
 
        template<bool CHECKRANGE, bool USE_BLENDING> TGX_INLINE inline void drawPixelZbuf(int x, int y, color_t color, float opacity, float z)
            {
            if (CHECKRANGE && ((x < 0) || (x >= _uni.im->lx()) || (y < 0) || (y >= _uni.im->ly()))) return;
            ZBUFFER_t& W = _uni.zbuf[x + _uni.im->lx() * y];
            const ZBUFFER_t aa =  (std::is_same<ZBUFFER_t, uint16_t>::value) ? ((ZBUFFER_t)(z * _uni.wa + _uni.wb)) : ((ZBUFFER_t)z);
            if (W < aa)
                {
                W = aa;
                if (USE_BLENDING) _uni.im->template drawPixel<false>({ x, y }, color, opacity); else _uni.im->template drawPixel<false>({ x, y }, color);
                }
            }
 
 
        template<bool CHECKRANGE, bool USE_BLENDING> TGX_INLINE inline void drawHLineZbuf(int x, int y, int w, color_t color, float opacity, float z)
            {
            if (CHECKRANGE) // optimized away at compile time
                {
                const int lx = _uni.im->lx();
                const int ly = _uni.im->ly();
                if ((y < 0) || (y >= ly) || (x >= lx)) return;
                if (x < 0) { w += x; x = 0; }
                if (x + w > lx) { w = lx - x; }
                if (w <= 0) return;
                }
            while(w--) drawPixelZbuf<CHECKRANGE, USE_BLENDING>(x++, y, color, opacity, z);
            }
 
 
        template<bool CHECKRANGE, bool USE_BLENDING> void _drawCircleZbuf(int xm, int ym, int r, color_t color, float opacity, float z);
 
 
        float _unitSphereScreenDiameter();
 
 
        template<bool WIREFRAME, int MODE> void _drawSphere(int nb_sectors, int nb_stacks, const Image<color_t>* texture, float thickness, color_t color, float opacity);
 
 
 
        /***********************************************************
        * CLIPPING
        ************************************************************/
 
 
        TGX_INLINE inline void _clip(int & fl, const fVec4 & P, float bx, float Bx, float by, float By)
            {
            if (P.x >= bx) { fl &= (~(1)); }
            if (P.x <= Bx) { fl &= (~(2)); }
            if (P.y >= by) { fl &= (~(4)); }
            if (P.y <= By) { fl &= (~(8)); }
            if ((P.z >= -1.0f)&&(P.w > 0)) { fl &= (~(16)); }
            if (P.z <= +1.0f) { fl &= (~(32)); }
            }
 
 
        TGX_INLINE inline void _clip(int & fl, const fVec3 & P, float bx, float Bx, float by, float By, const fMat4 & M)
            {
            fVec4 S = M.mult1(P);
            if (!_ortho) S.zdivide();
            return _clip(fl, S, bx, Bx, by, By);
            }
 
 
        /* test if a box is outside the image and should be discarded.
           transform the box coords with M then z-divide. */
        bool _discardBox(const fBox3 & bb, const fMat4 & M)
            {
            if ((bb.minX == 0) && (bb.maxX == 0) && (bb.minY == 0) && (bb.maxY == 0) && (bb.minZ == 0) && (bb.maxZ == 0))
                return false; // do not discard if the bounding box is uninitialized.
 
            const float bx = (_ox - 1) * _ilx - 1.0f;
            const float Bx = (_ox + _uni.im->width() + 1) * _ilx - 1.0f;
            const float by = (_oy - 1) * _ily - 1.0f;
            const float By = (_oy + _uni.im->height() + 1) * _ily - 1.0f;
 
            int fl = 63; // every bit set
            _clip(fl, fVec3(bb.minX, bb.minY, bb.minZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.minX, bb.minY, bb.maxZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.minX, bb.maxY, bb.minZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.minX, bb.maxY, bb.maxZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.maxX, bb.minY, bb.minZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.maxX, bb.minY, bb.maxZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.maxX, bb.maxY, bb.minZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            _clip(fl, fVec3(bb.maxX, bb.maxY, bb.maxZ), bx, Bx, by, By, M);
            if (fl == 0) return false;
            return true;
            }
 
 
        /* test if a triangle is completely outside the image and should be discarded.
         * coords are given after z-divide. */
        bool _discardTriangle(const fVec4 & P1, const fVec4 & P2, const fVec4 & P3)
            {
            const float bx = (_ox - 1) * _ilx - 1.0f;
            const float Bx = (_ox + _uni.im->width() + 1) * _ilx - 1.0f;
            const float by = (_oy - 1) * _ily - 1.0f;
            const float By = (_oy + _uni.im->height() + 1) * _ily - 1.0f;
 
            int fl = 63; // every bit set
            _clip(fl, P1, bx, Bx, by, By);
            if (fl == 0) return false;
            _clip(fl, P2, bx, Bx, by, By);
            if (fl == 0) return false;
            _clip(fl, P3, bx, Bx, by, By);
            if (fl == 0) return false;
            return true;
            }
 
 
        bool _clip2(float clipboundXY, const fVec3 & P, const fMat4 & M)
            {
            fVec4 S = M.mult1(P);
            if (!_ortho)
                {
                S.zdivide();
                if (S.w <= 0) S.z = -2;
                }
            return ((S.x <= -clipboundXY) || (S.x >= clipboundXY)
                 || (S.y <= -clipboundXY) || (S.y >= clipboundXY)
                 || (S.z <= -1) || (S.z >= 1));
            }
 
 
        bool _clipTestNeeded(float clipboundXY, const fBox3 & bb, const fMat4 & M)
            {
            return (_clip2(clipboundXY, fVec3(bb.minX, bb.minY, bb.minZ), M)
                 || _clip2(clipboundXY, fVec3(bb.minX, bb.minY, bb.maxZ), M)
                 || _clip2(clipboundXY, fVec3(bb.minX, bb.maxY, bb.minZ), M)
                 || _clip2(clipboundXY, fVec3(bb.minX, bb.maxY, bb.maxZ), M)
                 || _clip2(clipboundXY, fVec3(bb.maxX, bb.minY, bb.minZ), M)
                 || _clip2(clipboundXY, fVec3(bb.maxX, bb.minY, bb.maxZ), M)
                 || _clip2(clipboundXY, fVec3(bb.maxX, bb.maxY, bb.minZ), M)
                 || _clip2(clipboundXY, fVec3(bb.maxX, bb.maxY, bb.maxZ), M));
            }
 
 
        bool _wireFrameAANeighborCheckNeeded(const fBox3& bb, const fMat4& proj_modelview)
            {
            if ((_uni.im == nullptr) || (_uni.im->lx() <= 2) || (_uni.im->ly() <= 2)) return true;
 
            const float bx = (_ox + 1.0f) * _ilx - 1.0f;
            const float Bx = (_ox + (float)(_uni.im->lx() - 2)) * _ilx - 1.0f;
            const float by = (_oy + 1.0f) * _ily - 1.0f;
            const float By = (_oy + (float)(_uni.im->ly() - 2)) * _ily - 1.0f;
 
            const fVec3 C[8] = {
                fVec3(bb.minX, bb.minY, bb.minZ),
                fVec3(bb.minX, bb.minY, bb.maxZ),
                fVec3(bb.minX, bb.maxY, bb.minZ),
                fVec3(bb.minX, bb.maxY, bb.maxZ),
                fVec3(bb.maxX, bb.minY, bb.minZ),
                fVec3(bb.maxX, bb.minY, bb.maxZ),
                fVec3(bb.maxX, bb.maxY, bb.minZ),
                fVec3(bb.maxX, bb.maxY, bb.maxZ)
                };
 
            for (int i = 0; i < 8; i++)
                {
                fVec4 P = proj_modelview.mult1(C[i]);
                if (!_ortho)
                    {
                    if (P.w <= 0) return true;
                    P.zdivide();
                    }
                if ((P.z < -1.0f) || (P.z > 1.0f)) return true;
                if ((P.x < bx) || (P.x > Bx) || (P.y < by) || (P.y > By)) return true;
                }
            return false;
            }
 
 
#if TGX_MESHLET_SPHERE_CLIP
        TGX_INLINE inline void _meshletClipPlanes(float clipboundXY, const fMat4& M, fVec4* planes, float* plane_norms) const
            {
            const float cx = clipboundXY;
            planes[0] = fVec4(M.M[0] + cx * M.M[3], M.M[4] + cx * M.M[7], M.M[8] + cx * M.M[11], M.M[12] + cx * M.M[15]);
            planes[1] = fVec4(-M.M[0] + cx * M.M[3], -M.M[4] + cx * M.M[7], -M.M[8] + cx * M.M[11], -M.M[12] + cx * M.M[15]);
            planes[2] = fVec4(M.M[1] + cx * M.M[3], M.M[5] + cx * M.M[7], M.M[9] + cx * M.M[11], M.M[13] + cx * M.M[15]);
            planes[3] = fVec4(-M.M[1] + cx * M.M[3], -M.M[5] + cx * M.M[7], -M.M[9] + cx * M.M[11], -M.M[13] + cx * M.M[15]);
            planes[4] = fVec4(M.M[2] + M.M[3], M.M[6] + M.M[7], M.M[10] + M.M[11], M.M[14] + M.M[15]);
            planes[5] = fVec4(-M.M[2] + M.M[3], -M.M[6] + M.M[7], -M.M[10] + M.M[11], -M.M[14] + M.M[15]);
            for (int i = 0; i < 6; i++)
                {
                const fVec4& P = planes[i];
                plane_norms[i] = sqrtf(P.x * P.x + P.y * P.y + P.z * P.z);
                }
            }
 
 
        TGX_INLINE inline int _meshletSphereClip(const fVec3& center, float radius, const fVec4* planes, const float* plane_norms) const
            {
            bool intersects = false;
            for (int i = 0; i < 6; i++)
                {
                const fVec4& P = planes[i];
                const float d = P.x * center.x + P.y * center.y + P.z * center.z + P.w;
                const float r = radius * plane_norms[i];
                if (d < -r) return -1;
                if (d < r) intersects = true;
                }
            return intersects ? 1 : 0;
            }
#endif
 
 
 
 
        /***********************************************************
        * TRIANGLE CLIPPING AGAINST A CLIP-PLANE
        ************************************************************/
 
        inline float _cpdist(const tgx::fVec4& CP, float off, const tgx::fVec4& P)
            {
            return (CP.x * P.x) + (CP.y * P.y) + (CP.z * P.z) + (CP.w * P.w) + off;
            }
 
        inline float _cpfactor(const tgx::fVec4& CP, const float sdistA, const float sdistB)
            {
            return sdistA / (sdistA - sdistB);
            }
 
 
        void _triangleClip1in(int shader, tgx::fVec4 CP,
            float cp1, float cp2, float cp3,
            const RasterizerVec4& P1, const RasterizerVec4& P2, const RasterizerVec4& P3,
            RasterizerVec4& nP1, RasterizerVec4& nP2, RasterizerVec4& nP3, RasterizerVec4& nP4);
 
 
        void _triangleClip2in(int shader, tgx::fVec4 CP,
            float cp1, float cp2, float cp3,
            const RasterizerVec4& P1, const RasterizerVec4& P2, const RasterizerVec4& P3,
            RasterizerVec4& nP1, RasterizerVec4& nP2, RasterizerVec4& nP3, RasterizerVec4& nP4);
 
 
        int _triangleClip(int shader, tgx::fVec4 CP, float off,
            const RasterizerVec4 & P1, const RasterizerVec4 & P2, const RasterizerVec4 & P3,
            RasterizerVec4 & nP1, RasterizerVec4 & nP2, RasterizerVec4 & nP3, RasterizerVec4 & nP4);
 
 
 
        /***********************************************************
        * PHONG LIGHTNING
        ************************************************************/
 
        static const int _POWTABSIZE = 32;      // number of entries in the precomputed power table for specular exponent.
        int _currentpow;                        // exponent for the currently computed table (<0 if table not yet computed)
        float _powmax;                          // used to compute exponent
        float _fastpowtab[_POWTABSIZE];         // the precomputed power table.
 
        TGX_INLINE inline void _precomputeSpecularTable(int exponent)
            {
            if (_currentpow == exponent) return;
            _precomputeSpecularTable2(exponent);
            }
 
        TGX_NOINLINE void _precomputeSpecularTable2(int exponent);
 
 
        TGX_INLINE inline float _powSpecular(float x) const
            {
            const float indf = (_powmax - x) * _POWTABSIZE;
            const int indi = max(0,(int)indf);
            return (indi >= (_POWTABSIZE - 1)) ? 0.0f : (_fastpowtab[indi] + (indf - indi) * (_fastpowtab[indi + 1] - _fastpowtab[indi]));;
            }
 
 
 
 
        TGX_INLINE inline void _updateDirectionalLightTransform(int index)
            {
            _r_light[index] = _viewM.mult0(_light[index]);
            _r_light[index] = -_r_light[index];
            _r_light[index].normalize();
            _r_light_inorm[index] = _r_light[index] * _r_inorm;
            _r_H[index] = fVec3(0, 0, 1); // cheating: should use the normalized current vertex position (but this is faster with almost the same result)...
            _r_H[index] += _r_light[index];
            _r_H[index].normalize();
            _r_H_inorm[index] = _r_H[index] * _r_inorm;
            }
 
 
        TGX_INLINE inline void _updateActiveDirectionalLightInorms()
            {
            for (int i = 0; i < _directionalLightCount; i++)
                {
                _r_light_inorm[i] = _r_light[i] * _r_inorm;
                _r_H_inorm[i] = _r_H[i] * _r_inorm;
                }
            }
 
 
        TGX_INLINE inline void _updateActiveDirectionalLightTransforms()
            {
            for (int i = 0; i < _directionalLightCount; i++)
                {
                _updateDirectionalLightTransform(i);
                }
            }
 
 
        TGX_INLINE inline void _setRuntimeMaterialLighting(float ambiantStrength, float diffuseStrength, float specularStrength)
            {
            _r_ambiantColor = _ambiantColor * ambiantStrength;
            for (int i = 0; i < _directionalLightCount; i++)
                {
                _r_diffuseColor[i] = _diffuseColor[i] * diffuseStrength;
                _r_specularColor[i] = _specularColor[i] * specularStrength;
                }
            }
 
 
        TGX_INLINE inline void _updateDirectionalLightColor(int index)
            {
            _r_diffuseColor[index] = _diffuseColor[index] * _diffuseStrength;
            _r_specularColor[index] = _specularColor[index] * _specularStrength;
            }
 
 
 
            //
        
 
        template<bool TEXTURE> TGX_INLINE inline RGBf _shadeVertex(const float icu, const fVec3 & N) const
            {
            RGBf col = _r_ambiantColor;
            if constexpr (MAX_DIRECTIONAL_LIGHTS == 1)
                {
                col += _r_diffuseColor[0] * max(icu * dotProduct(N, _r_light_inorm[0]), 0.0f);
                col += _r_specularColor[0] * _powSpecular(icu * dotProduct(N, _r_H_inorm[0]));
                }
            else
                {
                for (int i = 0; i < _directionalLightCount; i++)
                    {            
                    col += _r_diffuseColor[i] * max(icu * dotProduct(N, _r_light_inorm[i]), 0.0f);
                    col += _r_specularColor[i] * _powSpecular(icu * dotProduct(N, _r_H_inorm[i]));
                    }
                }
            if (!(TEXTURE)) col *= _r_objectColor;
            col.clamp();
            return col;
            }
 
 
        TGX_INLINE inline RGBf _shadeVertex(const float icu, const fVec3 & N, const RGBf & color) const
            {
            RGBf col = _r_ambiantColor;
            if constexpr (MAX_DIRECTIONAL_LIGHTS == 1)
                {
                col += _r_diffuseColor[0] * max(icu * dotProduct(N, _r_light_inorm[0]), 0.0f);
                col += _r_specularColor[0] * _powSpecular(icu * dotProduct(N, _r_H_inorm[0]));
                }
            else
                {
                for (int i = 0; i < _directionalLightCount; i++)
                    {            
                    col += _r_diffuseColor[i] * max(icu * dotProduct(N, _r_light_inorm[i]), 0.0f);
                    col += _r_specularColor[i] * _powSpecular(icu * dotProduct(N, _r_H_inorm[i]));
                    }
                }
 
            col *= color;
            col.clamp();
            return col;
            }
 
 
        template<bool TEXTURE> TGX_INLINE inline RGBf _shadeFace(const float icu, const fVec3 & N) const
            {
            RGBf col = _r_ambiantColor;
            if constexpr (MAX_DIRECTIONAL_LIGHTS == 1)
                {
                col += _r_diffuseColor[0] * max(icu * dotProduct(N,  _r_light[0]), 0.0f);
                col += _r_specularColor[0] * _powSpecular(icu * dotProduct(N, _r_H[0]));
                }
            else
                {
                for (int i = 0; i < _directionalLightCount; i++)
                    {            
                    col += _r_diffuseColor[i] * max(icu * dotProduct(N,  _r_light[i]), 0.0f);
                    col += _r_specularColor[i] * _powSpecular(icu * dotProduct(N, _r_H[i]));
                    }
                }
            if (!(TEXTURE)) col *= _r_objectColor;
            col.clamp();
            return col;
            }
 
 
        TGX_INLINE inline void _setFlatOrUnlitFaceColor(int raster_type, bool texture, fVec3& faceN, float cu)
            {
            if constexpr (TGX_SHADER_HAS_UNLIT(ENABLED_SHADERS))
                {
                if (TGX_SHADER_HAS_UNLIT(raster_type))
                    {
                    _uni.facecolor = texture ? RGBf(1.0f, 1.0f, 1.0f) : _r_objectColor;
                    return;
                    }
                }
 
            const float icu = ((cu > 0) ? -1.0f : 1.0f); // -1 if we need to reverse the face normal.
            faceN.normalize_fast();
            if (texture)
                _uni.facecolor = _shadeFace<true>(icu, faceN);
            else
                _uni.facecolor = _shadeFace<false>(icu, faceN);
            }
 
 
 
        /***********************************************************
        * MEMBER VARIABLES
        ************************************************************/
 
        // *** general parameters ***
 
        int     _lx, _ly;           // viewport dimension
        float   _ilx, _ily;         // inverse viewport dimension
 
        int     _ox, _oy;           // image offset w.r.t. the viewport
 
        bool    _ortho;             // true to use orthographic projection and false for perspective projection
 
        fMat4   _projM;             // projection matrix
 
        RasterizerParams<color_t, color_t,ZBUFFER_t>  _uni; // rasterizer param (contain the image pointer and the zbuffer pointer).
 
        float _culling_dir;         // culling direction postive/negative or 0 to disable back face culling.
 
        int   _shaders;             // the shaders to use.
        int   _texture_mode;        // texture mapping mode (perspective-correct or affine)
        int   _texture_wrap_mode;   // wrapping mode (wrap_pow2 or clamp)
        int   _texture_quality;     // texturing quality (nearest or bilinear)
 
        // *** scene parameters ***
 
        fMat4   _viewM;             // view transform matrix
 
        fVec3   _light[MAX_DIRECTIONAL_LIGHTS];         // directional light directions
        RGBf    _ambiantColor;      // light ambiant color
        RGBf    _diffuseColor[MAX_DIRECTIONAL_LIGHTS];  // directional light diffuse colors
        RGBf    _specularColor[MAX_DIRECTIONAL_LIGHTS]; // directional light specular colors
        int     _directionalLightCount; // number of active directional lights
 
 
        // *** model specific parameters ***
 
        fMat4   _modelM;            // model transform matrix
 
        // material parameters
        RGBf    _color;             // model color (use when texturing is disabled)
        float   _ambiantStrength;   // ambient light reflection strength
        float   _diffuseStrength;   // diffuse light reflection strength
        float   _specularStrength;  // specular light reflection strength
        int     _specularExponent;  // specular exponent
 
 
        // *** pre-computed values ***
        fMat4 _r_modelViewM;        // model-view matrix
        float _r_inorm;             // Fast normal scaling for lighting. Assumes rotation/uniform scale;
                                    // Gouraud lighting is approximate with non-uniform model scaling.
        fVec3 _r_light[MAX_DIRECTIONAL_LIGHTS];         // light vectors in view space (inverted and normalized)
        fVec3 _r_light_inorm[MAX_DIRECTIONAL_LIGHTS];   // same as above but already multiplied by inorm
        fVec3 _r_H[MAX_DIRECTIONAL_LIGHTS];             // halfway vectors.
        fVec3 _r_H_inorm[MAX_DIRECTIONAL_LIGHTS];       // same as above but already multiplied by inorm
        RGBf _r_ambiantColor;       // ambient color multiplied by object ambient strength
        RGBf _r_diffuseColor[MAX_DIRECTIONAL_LIGHTS];   // diffuse colors multiplied by object diffuse strength
        RGBf _r_specularColor[MAX_DIRECTIONAL_LIGHTS];  // specular colors multiplied by object specular strength
        RGBf _r_objectColor;        // color to use for drawing the object (either _color or mesh->color).
 
 
        struct ExtVec4 : public RasterizerVec4
            {
            fVec4 P;       // after model-view matrix multiplication
            fVec4 N;       // normal vector after model-view matrix multiplication
            bool missedP;  // true if the attributes should be computed
            int indn;      // index for normal vector in array
            int indt;      // index for texture vector in array
            };
 
 
    };
 
 
 
}
 
 
 
 
#include "Renderer3D.inl"
 
 
#endif
 
#endif