triloader.cpp

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Sheep 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "triloader.h"  // include first
#include "common/misc/progressmonitor.h"
#include "common/misc/stringutils.h"
#include "common/misc/types.h"

#include <cctype>
#include <IL/il.h>

//#define VERBOSE

#ifdef VERBOSE
#include <iostream>
#endif  // VERBOSE

using namespace sheep;
using namespace std;

TRILoader::TRILoader() {}

void TRILoader::Load(const string &filename,
                     IMeshBuilder &builder,
                     int option_mask /*= DEFAULT_CONFIGURATION_BIT*/,
                     ProgressMonitor *progmon /*= 0*/)
{
    m_path = StringUtils::GetPath(filename);
    m_texture_filename =
        StringUtils::RemoveExtension(StringUtils::GetFilename(filename)) + ".png";

    m_geombuilder = builder.GeometryBuilder();
    m_matbuilder = builder.MaterialBuilder();

    m_option_mask = option_mask;

    m_progmon = progmon;

    m_comment_ptr = 0;  // no texture coordinates yet

    open_geometry_file(filename);
    open_texture_file(m_texture_filename);

    if(m_progmon) {
        m_stream.Seek(0, BinaryStream::SeekFromEnd);
        m_progmon->StartJob(0, m_stream.Tell());
        m_stream.Seek(0, BinaryStream::SeekFromBeginning);
    }

    read_geometry_file();

    if(m_progmon)
        m_progmon->Done();

    close_texture_file();
    close_geometry_file();
}

void TRILoader::read_error() {
    //!\todo Close files and free resources.
    throw ReadingException(m_offset);
}

void TRILoader::open_geometry_file(const string &filename) {
    m_stream.Open(filename, BinaryStream::InputStream);

    if(!m_stream.IsOpen())
        throw FileNotFoundException(filename);

    m_offset = 0;
}

void TRILoader::read_geometry_file() {
    // Read endian order.

    char endian[2];

    m_stream.Read(&endian[0]);
    m_stream.Read(&endian[1]);

    if(!((endian[0] == 'B' || endian[0] == 'L') && endian[1] == 'E'))
        read_error();

    if(endian[0] == 'B')
        m_stream.SetEndianness(BinaryStream::BigEndian);
    else m_stream.SetEndianness(BinaryStream::LittleEndian);

    // Read the number of vertices.
    int32 nvertices;
    m_stream.Read(&nvertices);

    // Read the number of faces.
    int32 nfaces;
    m_stream.Read(&nfaces);

    // Skip reserved bytes.
    for(int i = 0; i < 4; ++i) {
        char dummy;
        m_stream.Read(&dummy);
    }

    m_geombuilder->BeginSubMesh("");

    // Read vertices.
    for(int i = 0; i < nvertices; ++i) {
        float32 x, y, z;
        m_stream.Read(&x);
        m_stream.Read(&y);
        m_stream.Read(&z);

        m_vertex_id[i] = m_geombuilder->AppendVertex(Vector3(x, y, z));

        if(m_progmon) {
            //!\todo Fine tune the number of items to read between progress updates.
            if((i & 4095) == 0)
                m_progmon->SetJobProgress(m_stream.Tell());
        }
    }

    // Read faces.
    for(int i = 0; i < nfaces; ++i) {
        uint32 v0, v1, v2;
        m_stream.Read(&v0);
        m_stream.Read(&v1);
        m_stream.Read(&v2);

        IMeshBuilder::FeatureId vertex_id[3];
        vertex_id[0] = m_vertex_id[v0];
        vertex_id[1] = m_vertex_id[v1];
        vertex_id[2] = m_vertex_id[v2];

        const IMeshBuilder::FeatureId face_id = m_geombuilder->AppendFace(3, vertex_id);

        if(m_comment_ptr) {
            IMeshBuilder::FeatureId texcood_id[3];

            for(int i = 0; i < 3; ++i) {
                const int u = strtol(m_comment_ptr, &m_comment_ptr, 10);
                const int v = strtol(m_comment_ptr, &m_comment_ptr, 10);

                Vector2 vt;
                vt.m_x = (static_cast<Real>(u) + 0.5) / m_texture_width;
                vt.m_y = (static_cast<Real>(v) + 0.5) / m_texture_height;

                texcood_id[i] = m_geombuilder->AppendTexCoord(vt);
            }

            m_geombuilder->SetFaceTexCoords(face_id, 3, texcood_id);
        }

        if(m_progmon) {
            //!\todo Fine tune the number of items to read between progress updates.
            if((i & 4095) == 0)
                m_progmon->SetJobProgress(m_stream.Tell());
        }
    }

    if(m_matbuilder && m_comment_ptr) {
        ILuint image_id;

        ilGenImages(1, &image_id);
        ilBindImage(image_id);

        if(TryLoadingImage(m_path, m_texture_filename)) {
            const int w = ilGetInteger(IL_IMAGE_WIDTH);
            const int h = ilGetInteger(IL_IMAGE_HEIGHT);

            unsigned char *texels = new unsigned char[w * h * 3];

            ilCopyPixels(0, 0, 0, w, h, 1, IL_RGB, IL_UNSIGNED_BYTE, texels);
            ilDeleteImages(1, &image_id);

            assert(m_matbuilder);

            const IMeshBuilder::FeatureId material_id = m_matbuilder->BeginMaterial("");
            m_matbuilder->SetTexture(w, h, texels);
            m_matbuilder->EndMaterial();

            m_geombuilder->SetMaterial(material_id);
        } else {
            //!\todo Close files and free resources.

            // There is no distinction between a missing texture file
            // and an invalid texture file.
            if(m_option_mask & STOP_ON_MISSING_FILE_BIT)
                throw FileNotFoundException(m_texture_filename);

            // Ignore invalid or missing texture file.
        }
    }

    m_geombuilder->EndSubMesh();
}

void TRILoader::close_geometry_file() {
    m_stream.Close();
}

void TRILoader::open_texture_file(const string &filename) {
    const int PNG_BYTES_TO_CHECK = 8;
    png_byte header[PNG_BYTES_TO_CHECK];

    FILE *f = TryOpeningFile(m_path, filename, "rb");

    if(!f) {
        if(m_option_mask & STOP_ON_MISSING_FILE_BIT) {
            //!\todo Close files and free resources.
            throw FileNotFoundException(filename);
        } else return;  // ignore missing material file
    }

    if(fread(header, 1, PNG_BYTES_TO_CHECK, f) < PNG_BYTES_TO_CHECK)
        read_error();

    if(png_sig_cmp(header, 0, PNG_BYTES_TO_CHECK))
        read_error();

    m_png_ptr = png_create_read_struct(
        PNG_LIBPNG_VER_STRING,
        NULL,
        NULL,
        NULL);

    if(!m_png_ptr) {
        fclose(f);
        read_error();
    }

    m_info_ptr = png_create_info_struct(m_png_ptr);

    if(!m_info_ptr) {
        png_destroy_read_struct(
            &m_png_ptr,
            NULL,
            NULL);
        fclose(f);
        read_error();
    }

    m_end_info = png_create_info_struct(m_png_ptr);

    if(!m_end_info) {
        png_destroy_read_struct(
            &m_png_ptr,
            &m_info_ptr,
            NULL);
        fclose(f);
        read_error();
    }

    png_init_io(m_png_ptr, f);
    png_set_sig_bytes(m_png_ptr, PNG_BYTES_TO_CHECK);
    png_read_info(m_png_ptr, m_info_ptr);

    fclose(f);

    m_texture_width = png_get_image_width(m_png_ptr, m_info_ptr);
    m_texture_height = png_get_image_height(m_png_ptr, m_info_ptr);

    png_textp text_ptr;
    int ncomments;

    png_get_text(m_png_ptr, m_info_ptr, &text_ptr, &ncomments);

    if(ncomments < 1) {
        png_destroy_read_struct(
            &m_png_ptr,
            &m_info_ptr,
            &m_end_info);
        read_error();
    }

    if(strcmp(text_ptr[0].key, "uv") != 0) {
        png_destroy_read_struct(
            &m_png_ptr,
            &m_info_ptr,
            &m_end_info);
        read_error();
    }

    m_comment_ptr = text_ptr[0].text;
    assert(m_comment_ptr);
}

void TRILoader::close_texture_file() {
    if(m_comment_ptr) {
        png_destroy_read_struct(
            &m_png_ptr,
            &m_info_ptr,
            &m_end_info);
        m_comment_ptr = 0;
    }
}

---