Mesh3Dv2.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_MESH3DV2_H_
#define _TGX_MESH3DV2_H_
 
// only C++, no plain C
#ifdef __cplusplus
 
 
#include "Misc.h"
#include "Vec2.h"
#include "Vec3.h"
#include "Vec4.h"
#include "Box3.h"
#include "Color.h"
#include "Image.h"
 
#include <stdint.h>
 
 
namespace tgx
{
 
 
    template<typename color_t>
    struct MeshMaterial3Dv2
        {
        // make sure right away that the template parameter is admissible to prevent cryptic error message later.
        static_assert(is_color<color_t>::value, "color_t must be one of the color types defined in Color.h");
 
        const Image<color_t>* texture;  
 
        RGBf color;                     
 
        float ambiant_strength;         
        float diffuse_strength;         
        float specular_strength;        
        int specular_exponent;          
        };
 
 
    template<typename color_t>
    struct MeshMaterialExtra3Dv2
        {
        // make sure right away that the template parameter is admissible to prevent cryptic error message later.
        static_assert(is_color<color_t>::value, "color_t must be one of the color types defined in Color.h");
 
        RGBf emissive_color;                       
        float emissive_strength;                   
        const Image<color_t>* emissive_texture;    
        uint32_t flags;                            
        };
 
 
    struct Meshlet3Dv2
        {
        int16_t sphere_center[3];  
        int16_t cone_dir[3];       
 
        uint16_t sphere_radius;    
        int16_t cone_cos;          
 
        uint32_t payload_offset32; 
 
        uint8_t nb_vertices;       
        uint8_t nb_normals;        
        uint8_t nb_texcoords;      
        uint8_t material_index;    
        };
 
 
    template<typename color_t>
    struct Mesh3Dv2
        {
        static_assert(is_color<color_t>::value, "color_t must be one of the color types defined in Color.h");
 
        int32_t id;                                         
 
        uint16_t nb_meshlets;                               
        uint16_t nb_materials;                              
 
        const MeshMaterial3Dv2<color_t>* materials;      
        const Meshlet3Dv2* meshlets;                     
        const uint32_t* payload;                            
 
        fBox3 bounding_box;                                 
 
        const char* name;                                   
 
        const MeshMaterialExtra3Dv2<color_t>* material_extras; 
        };
 
 
    template<typename color_t> const Mesh3Dv2<color_t>* cacheMesh(const Mesh3Dv2<color_t>* mesh,
                                                                  void* ram1_buffer, size_t ram1_size,
                                                                  void* ram2_buffer, size_t ram2_size,
                                                                  const char* copy_order = "PLMI",
                                                                  size_t* ram1_used = nullptr,
                                                                  size_t* ram2_used = nullptr);
 
 
    template<typename color_t> const Mesh3Dv2<color_t>* cacheMesh(const Mesh3Dv2<color_t>* mesh,
                                                                  void* ram_buffer, size_t ram_size,
                                                                  const char* copy_order = "PLMI",
                                                                  size_t* ram_used = nullptr);
 
 
#if defined(ARDUINO_TEENSY41)
 
    template<typename color_t> Mesh3Dv2<color_t>* copyMeshEXTMEM(const Mesh3Dv2<color_t>* mesh,
                                                                 bool copy_payload = false,
                                                                 bool copy_meshlets = false,
                                                                 bool copy_materials = false,
                                                                 bool copy_textures = true,
                                                                 size_t* extmem_used = nullptr);
 
 
    template<typename color_t> void freeMeshEXTMEM(Mesh3Dv2<color_t>* mesh);
 
#endif
 
 
}
 
 
#include "Mesh3Dv2.inl"
 
 
#endif
 
#endif