material_data.cpp File Reference

#include <cstdio>
#include <algorithm>
#include "image_io.h"
#include "texture.h"
#include "material_data.h"
#include "mesh_data.h"

Go to the source code of this file.

Classes
struct	TextureData

Functions
int	read_textures (std::vector< MaterialData > &materials, const size_t max_size)
	charge les textures associees a un ensemble de matieres, sans depasser une limite de taille, 1Go par defaut.
void	release_textures (std::vector< MaterialData > &materials)
	detruit les textures.

---

Class Documentation

TextureData

struct TextureData

Definition at line 12 of file material_data.cpp.

Class Members
ImageData	diffuse_image
bool	use_diffuse = false
ImageData	ns_image
bool	use_ns = false

Function Documentation

read_textures()

int read_textures	(	std::vector< MaterialData > &	materials,
		const size_t	max_size )

charge les textures associees a un ensemble de matieres, sans depasser une limite de taille, 1Go par defaut.

Definition at line 92 of file material_data.cpp.

{
    std::vector<TextureData> textures;
    
    // evalue la taille totale occuppee par toutes les images / textures
    size_t total_size= 0;
    for(int i= 0; i < (int) materials.size(); i++)
    {
        const MaterialData &material= materials[i];
        TextureData data;
        
        if(!material.diffuse_filename.empty())
        {
            data.use_diffuse= true;
            data.diffuse_image= read_image_data(material.diffuse_filename.c_str());
            total_size= total_size + data.diffuse_image.width * data.diffuse_image.height * data.diffuse_image.channels * data.diffuse_image.size;
        }
        if(!material.ns_filename.empty())
        {
            data.use_ns= true;
            data.ns_image= read_image_data(material.ns_filename.c_str());
            total_size= total_size + data.ns_image.width * data.ns_image.height * data.ns_image.channels * data.ns_image.size;
        }
        
        if(total_size > max_size)
        {
            // ne stocke plus les images apres avoir depasse la limite de taille
            std::vector<unsigned char>().swap(data.diffuse_image.pixels);
            std::vector<unsigned char>().swap(data.ns_image.pixels);
        }
        
        textures.emplace_back(data);
    }
    
    printf("using %dMB / %dMB\n", int(total_size / 1024 / 1024), int(max_size / 1024 / 1024));
    
    // reduit les dimensions des images / textures jusqu'a respecter la limite de taille
    int lod= 0;
    for(; total_size > max_size ; lod++)
    {
        total_size= 0;
        for(int i= 0; i < (int) textures.size(); i++)
        {
            if(textures[i].use_diffuse)
                total_size= total_size + miplevel_size(textures[i].diffuse_image, lod);
            if(textures[i].use_ns)
                total_size= total_size + miplevel_size(textures[i].ns_image, lod);
        }
    }
    
    printf("  lod %d, %dMB\n", lod, int(total_size / 1024 / 1024));
    
    // charge une texture par defaut, en cas d'erreur de chargement
    GLuint default_texture= read_texture(0, "data/grid.png");
    
    printf("resizing textures...\n");
    // construit les textures a la bonne resolution
    for(int i= 0;  i < (int) textures.size(); i++)
    {
        TextureData& data= textures[i]; 
        MaterialData& material= materials[i]; 
        
        if(data.use_diffuse && data.diffuse_image.width > 0)
        {
            if(data.diffuse_image.pixels.empty())
            {
                // recharge l'image, si necessaire
                data.diffuse_image= read_image_data(material.diffuse_filename.c_str());
                assert(data.diffuse_image.width > 0);
            }
            
            ImageData level= mipmap_resize(data.diffuse_image, lod);
            material.diffuse_texture= make_texture(0, level);
            
            material.diffuse_texture_color= average_color(level);
        }
        else
            material.diffuse_texture= default_texture;
        
        if(data.use_ns && data.ns_image.width > 0)
        {
            if(data.ns_image.pixels.empty())
            {
                // recharge l'image, si necessaire
                data.ns_image= read_image_data(material.ns_filename.c_str());
                assert(data.ns_image.width > 0);
            }
            
            ImageData level= mipmap_resize(data.ns_image, lod);
            material.ns_texture= make_texture(0, level);
        }
        else
            material.ns_texture= default_texture;
        
        // nettoyage, les images ne sont plus necessaires
        std::vector<unsigned char>().swap(data.diffuse_image.pixels);
        std::vector<unsigned char>().swap(data.ns_image.pixels);
    }
    
    return total_size;
}

release_textures()

void release_textures

(

std::vector< MaterialData > &

materials

)

detruit les textures.

Definition at line 194 of file material_data.cpp.

{
    for(int i= 0; i < (int) materials.size(); i++)
    {
        const MaterialData& material= materials[i];
        
        if(material.diffuse_texture > 0)
            glDeleteTextures(1, &material.diffuse_texture);
        if(material.ns_texture > 0)
            glDeleteTextures(1, &material.ns_texture);
    }
}