1 files changed, 646 insertions, 0 deletions

diff --git a/src/others/mimesh/libg3d-0.0.8/plugins/import/imp_3dmf/imp_3dmf.c b/src/others/mimesh/libg3d-0.0.8/plugins/import/imp_3dmf/imp_3dmf.c
new file mode 100644
index 0000000..82a46d3
--- /dev/null
+++ b/src/others/mimesh/libg3d-0.0.8/plugins/import/imp_3dmf/imp_3dmf.c
@@ -0,0 +1,646 @@
+/* $Id$ */
+
+/*
+    libg3d - 3D object loading library
+
+    Copyright (C) 2005-2009  Markus Dahms <mad@automagically.de>
+
+    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, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <string.h>
+
+#include <g3d/types.h>
+#include <g3d/context.h>
+#include <g3d/stream.h>
+#include <g3d/object.h>
+#include <g3d/vector.h>
+#include <g3d/matrix.h>
+#include <g3d/material.h>
+#include <g3d/iff.h>
+#include <g3d/debug.h>
+
+#include "imp_3dmf_chunks.h"
+
+#define X3DMF_CHUNK_CHAR(id, shift) \
+        ((((id) >> (shift)) & 0xFF) == 0) ? \
+        ' ' : ((id) >> (shift)) & 0xFF
+
+typedef struct {
+        guint32 id;
+        guint32 offset;
+        guint32 type;
+}
+X3dmfTocEntry;
+
+typedef struct {
+        guint32 num_entries;
+        X3dmfTocEntry *entries;
+}
+X3dmfToc;
+
+
+static gboolean x3dmf_read_container(G3DStream *stream, guint32 length,
+        G3DModel *model, G3DObject *object, guint32 level, X3dmfToc *toc,
+        G3DContext *context);
+static X3dmfToc *x3dmf_read_toc(G3DStream *stream, X3dmfToc *prev_toc,
+        G3DContext *context);
+
+EAPI
+gboolean plugin_load_model_from_stream(G3DContext *context, G3DStream *stream,
+        G3DModel *model, gpointer user_data)
+{
+        guint32 id, flags, tocloc, pos;
+        gsize len;
+        guint16 ver_min, ver_maj;
+        gchar txthead[10];
+        X3dmfToc *toc = NULL;
+
+        g3d_iff_read_chunk(stream, &id, &len, 0);
+        if((id != G3D_IFF_MKID('3', 'D', 'M', 'F')) || (len != 16)) {
+                g3d_stream_seek(stream, 0, G_SEEK_SET);
+                g3d_stream_read(stream, txthead, 10);
+                if(strncmp(txthead, "3DMetafile", 10) == 0) {
+                        g_warning("file %s is an ASCII 3D Metafile (unhandled)\n",
+                                stream->uri);
+                } else {
+                        g_warning("file %s is not a 3D Metafile\n", stream->uri);
+                }
+                return FALSE;
+        }
+
+        ver_maj = g3d_stream_read_int16_be(stream);
+        ver_min = g3d_stream_read_int16_be(stream);
+
+        flags = g3d_stream_read_int32_be(stream);
+
+        g3d_stream_skip(stream, 4); /* FIXME: 64bit file offsets */
+        tocloc = g3d_stream_read_int32_be(stream);
+
+        /* read TOC if available */
+        if(tocloc > 0) {
+                pos = g3d_stream_tell(stream);
+                g3d_stream_seek(stream, tocloc, G_SEEK_SET);
+                toc = x3dmf_read_toc(stream, NULL, context);
+                g3d_stream_seek(stream, pos, G_SEEK_SET);
+        }
+
+#if DEBUG > 0
+        g_debug("3DMF: version %d.%d (0x%08x) TOC @ 0x%08x",
+                ver_maj, ver_min, flags, tocloc);
+#endif
+
+        x3dmf_read_container(stream, (guint32) -1, model, NULL, 0, toc, context);
+
+        return TRUE;
+}
+
+EAPI
+gchar *plugin_description(void)
+{
+        return g_strdup("3D Metafiles.");
+}
+
+EAPI
+gchar **plugin_extensions(void)
+{
+        return g_strsplit("b3d:3mf:3dmf", ":", 0);
+}
+
+/******************************************************************************
+ * 3DMF specific
+ */
+
+static X3dmfChunkDesc *x3dmf_get_chunk_info(guint32 id)
+{
+        gint32 i;
+
+        for(i = 0; x3dmf_chunks[i].id != 0; i ++)
+                if(x3dmf_chunks[i].id == id)
+                        return &(x3dmf_chunks[i]);
+        return NULL;
+}
+
+static X3dmfToc *x3dmf_read_toc(G3DStream *stream, X3dmfToc *prev_toc,
+        G3DContext *context)
+{
+        X3dmfToc *toc;
+        guint32 off_next_toc, typeseed, refseed, entrytype, entrysize, nentries;
+        guint32 noff, i;
+
+        if(prev_toc)
+                toc = prev_toc;
+        else
+                toc = g_new0(X3dmfToc, 1);
+
+        /* skip tag and size (FIXME) */
+        g3d_stream_skip(stream, 8);
+
+        g3d_stream_skip(stream, 4); /* FIXME: 64bit file offsets */
+        off_next_toc = g3d_stream_read_int32_be(stream);
+        typeseed = g3d_stream_read_int32_be(stream);
+        refseed = g3d_stream_read_int32_be(stream);
+        entrytype = g3d_stream_read_int32_be(stream);
+        entrysize = g3d_stream_read_int32_be(stream);
+        nentries = g3d_stream_read_int32_be(stream);
+
+        /* resize entry array */
+        noff = toc->num_entries;
+        toc->num_entries += nentries;
+        toc->entries = (X3dmfTocEntry *)g_realloc(toc->entries,
+                toc->num_entries * sizeof(X3dmfTocEntry));
+
+        /* read TOC entries */
+        for(i = 0; i < nentries; i ++) {
+                toc->entries[noff + i].id = g3d_stream_read_int32_be(stream);
+                g3d_stream_skip(stream, 4); /* FIXME: 64bit file offsets */
+                toc->entries[noff + i].offset = g3d_stream_read_int32_be(stream);
+
+                if((entrytype == 1) && (entrysize == 16)) {
+                        toc->entries[noff + i].type = g3d_stream_read_int32_be(stream);
+                }
+#if DEBUG > 0
+                g_debug("3DMF: TOC: %06d @ 0x%08x",
+                        toc->entries[noff + i].id,
+                        toc->entries[noff + i].offset);
+#endif
+        }
+
+        /* read next toc */
+        if(off_next_toc > 0) {
+                g3d_stream_seek(stream, off_next_toc, SEEK_SET);
+                toc = x3dmf_read_toc(stream, toc, context);
+        }
+
+        return toc;
+}
+
+static guint32 x3dmf_read_mesh(G3DStream *stream, G3DObject *object,
+        G3DContext *context)
+{
+        guint32 i, j, nconts, nfaces, nbytes = 0, ncverts, offv;
+        G3DFace *face;
+
+        g_return_val_if_fail(object != NULL, FALSE);
+
+        offv = object->vertex_count;
+        object->vertex_count += g3d_stream_read_int32_be(stream);
+        object->vertex_data = g_realloc(object->vertex_data,
+                object->vertex_count * 3 * sizeof(G3DFloat));
+        nbytes += 4;
+
+        for(i = offv; i < object->vertex_count; i ++) {
+                for(j = 0; j < 3; j ++)
+                        object->vertex_data[i * 3 + j] = g3d_stream_read_float_be(stream);
+                nbytes += 12;
+
+                g3d_context_update_interface(context);
+        }
+
+        nfaces = g3d_stream_read_int32_be(stream);
+        nconts = g3d_stream_read_int32_be(stream);
+        nbytes += 8;
+
+#if DEBUG > 0
+        g_debug("|%u verts, %u faces, %u conts", object->vertex_count,
+                nfaces, nconts);
+#endif
+
+        for(i = 0; i < nfaces; i ++) {
+                face = g_new0(G3DFace, 1);
+
+                face->vertex_count = g3d_stream_read_int32_be(stream);
+                nbytes += 4;
+                face->vertex_indices = g_new0(guint32, face->vertex_count);
+
+                for(j = 0; j < face->vertex_count; j ++) {
+                        face->vertex_indices[j] = offv + g3d_stream_read_int32_be(stream);
+                        nbytes += 4;
+                        if(face->vertex_indices[j] >= object->vertex_count) {
+                                g_warning("face index wrong: %u >= %u",
+                                        face->vertex_indices[j], object->vertex_count);
+                                face->vertex_indices[j] = 0;
+                        }
+                }
+
+#if DEBUG > 3
+                g_debug("|face %u: %u %u %u", i, face->vertex_indices[0],
+                        face->vertex_indices[1], face->vertex_indices[2]);
+#endif
+
+                face->material = g_slist_nth_data(object->materials, 0);
+                object->faces = g_slist_prepend(object->faces, face);
+
+                g3d_context_update_interface(context);
+        }
+
+        /* contours */
+        for(i = 0; i < nconts; i ++) {
+                ncverts = g3d_stream_read_int32_be(stream);
+                nbytes += 4;
+                for(j = 0; j < ncverts; j ++) {
+                        g3d_stream_read_int32_be(stream);
+                        nbytes += 4;
+                }
+        }
+
+        return nbytes;
+}
+
+static G3DObject *x3dmf_object_new(G3DStream *stream, G3DModel *model)
+{
+        G3DObject *object;
+        G3DMaterial *material;
+
+        object = g_new0(G3DObject, 1);
+        material = g3d_material_new();
+
+        object->name = g_strdup_printf("container @ 0x%08x",
+                (guint32)g3d_stream_tell(stream) - 8);
+        model->objects = g_slist_append(model->objects, object);
+        object->materials =     g_slist_append(object->materials, material);
+
+        return object;
+}
+
+static guint32 x3dmf_read_packed(G3DStream *stream, guint32 maxx,
+        guint32 *nread)
+{
+        if(maxx > 0xFFFE) {
+                if(nread)
+                        (*nread) += 4;
+                return g3d_stream_read_int32_be(stream);
+        } else if(maxx > 0xFE) {
+                if(nread)
+                        (*nread) += 2;
+                return g3d_stream_read_int16_be(stream);
+        } else {
+                if(nread)
+                        (*nread) += 1;
+                return g3d_stream_read_int8(stream);
+        }
+}
+
+/*
+ [tmsh] - TriMesh
+ http://developer.apple.com/documentation/QuickTime/QD3D/qd3dmetafile.33.htm
+
+ Uns32               numTriangles
+ Uns32               numTriangleAttributeTypes
+ Uns32               numEdges
+ Uns32               numEdgeAttributeTypes
+ Uns32               numPoints
+ Uns32               numVertexAttributeTypes
+ TriMeshTriangleData         triangles[numTriangles]
+ TriMeshEdgeData             edges[numEdges]
+ Point3D                     points[numPoints]
+ BoundingBox                 bBox
+*/
+
+static guint32 x3dmf_read_tmsh(G3DStream *stream, G3DObject *object,
+        G3DContext *context)
+{
+        G3DFace *face;
+        guint32 nread = 0, nfaces, nverts, nedges;
+        gint32 i, j;
+
+        nfaces = g3d_stream_read_int32_be(stream); /* numTriangles */
+        nread += 4;
+
+        g3d_stream_read_int32_be(stream); /* numTriangleAttributeTypes */
+        nread += 4;
+
+        nedges = g3d_stream_read_int32_be(stream); /* numEdges */
+        nread += 4;
+
+        g3d_stream_read_int32_be(stream); /* numEdgeAttributeTypes */
+        nread += 4;
+
+        nverts = g3d_stream_read_int32_be(stream); /* numPoints */
+        nread += 4;
+
+        g3d_stream_read_int32_be(stream); /* numVertexAttributeTypes */
+        nread += 4;
+
+#if DEBUG > 3
+        g_debug("3DMF: [tmsh] %d faces, %d edges, %d vertices",
+                nfaces, nedges, nverts);
+#endif
+
+        /* triangles */
+        for(i = 0; i < nfaces; i ++) {
+                face = g_new0(G3DFace, 1);
+
+                face->vertex_count = 3;
+                face->vertex_indices = g_new0(guint32, 3);
+                for(j = 0; j < 3; j ++) {
+                        face->vertex_indices[j] =
+                                x3dmf_read_packed(stream, nfaces, &nread);
+                        if(face->vertex_indices[j] >= nverts) {
+                                g_warning("face index error: %u >= %u",
+                                        face->vertex_indices[j], nverts);
+                                face->vertex_indices[j] = 0;
+                        }
+                }
+
+#if DEBUG > 3
+                g_debug("face %u (packed): %u %u %u", i, face->vertex_indices[0],
+                        face->vertex_indices[1], face->vertex_indices[2]);
+#endif
+
+                face->material = g_slist_nth_data(object->materials, 0);
+                object->faces = g_slist_prepend(object->faces, face);
+        }
+
+        /* edges */
+        for(i = 0; i < nedges; i ++) {
+                /* pointIndices */
+                x3dmf_read_packed(stream, nedges, &nread);
+                x3dmf_read_packed(stream, nedges, &nread);
+                /* triangleIndices */
+                x3dmf_read_packed(stream, nedges, &nread);
+                x3dmf_read_packed(stream, nedges, &nread);
+        }
+
+        /* points */
+        object->vertex_count = nverts;
+        object->vertex_data = g_new0(G3DFloat, 3 * nverts);
+        for(i = 0; i < nverts; i ++) {
+                object->vertex_data[i * 3 + 0] = g3d_stream_read_float_be(stream);
+                object->vertex_data[i * 3 + 1] = g3d_stream_read_float_be(stream);
+                object->vertex_data[i * 3 + 2] = g3d_stream_read_float_be(stream);
+                nread += 12;
+        }
+
+        /* bBox */
+        /* Point3D min */
+        g3d_stream_read_float_be(stream);
+        g3d_stream_read_float_be(stream);
+        g3d_stream_read_float_be(stream);
+        nread += 12;
+        /* Point3D max */
+        g3d_stream_read_float_be(stream);
+        g3d_stream_read_float_be(stream);
+        g3d_stream_read_float_be(stream);
+        nread += 12;
+        /* boolean isEmpty */
+        g3d_stream_read_int32_be(stream);
+        nread += 4;
+
+        return nread;
+}
+
+static gboolean x3dmf_read_rfrn(G3DStream *stream, G3DModel *model,
+        X3dmfToc *toc, G3DContext *context)
+{
+        G3DObject *object;
+        guint32 id, i, refid, savedoffset;
+        gsize len;
+        X3dmfTocEntry *tocentry = NULL;
+
+        refid = g3d_stream_read_int32_be(stream);
+        if(refid == 0) {
+                /* FIXME */
+                return FALSE;
+        }
+
+        if(toc == NULL) {
+                return FALSE;
+        }
+
+        /* find reference object */
+        for(i = 0; i < toc->num_entries; i ++)
+                if(toc->entries[i].id == refid)
+                        tocentry = &(toc->entries[i]);
+
+        g_return_val_if_fail(tocentry != NULL, FALSE);
+
+        savedoffset = g3d_stream_tell(stream);
+        g3d_stream_seek(stream, tocentry->offset, G_SEEK_SET);
+
+        object = x3dmf_object_new(stream, model);
+
+        g3d_iff_read_chunk(stream, &id, &len, 0);
+        switch(id) {
+                case G3D_IFF_MKID('c', 't', 'n', 'r'):
+                        x3dmf_read_container(stream, len, model, NULL, 0xFF, toc, context);
+                        break;
+
+                default:
+                        break;
+        }
+
+        g3d_stream_seek(stream, savedoffset, G_SEEK_SET);
+
+        return TRUE;
+}
+
+static gboolean x3dmf_read_container(G3DStream *stream, guint32 length,
+        G3DModel *model, G3DObject *object, guint32 level, X3dmfToc *toc,
+        G3DContext *context)
+{
+        G3DMaterial *material = NULL;
+        X3dmfChunkDesc *chunkdesc;
+        guint32 id, chk, i;
+        gsize len;
+        G3DFloat matrix[16];
+
+        g3d_matrix_identity(matrix);
+
+        while(length > 0) {
+                if(g3d_stream_eof(stream))
+                        break;
+
+                g3d_iff_read_chunk(stream, &id, &len, 0);
+                length -= 8;
+
+                if(id == 0)
+                        return FALSE;
+
+                chunkdesc = x3dmf_get_chunk_info(id);
+
+#if DEBUG > 0
+                g_debug("\\%s[%c%c%c%c]: %s (%d bytes)", debug_pad(level),
+                        X3DMF_CHUNK_CHAR(id, 24), X3DMF_CHUNK_CHAR(id, 16),
+                        X3DMF_CHUNK_CHAR(id, 8), X3DMF_CHUNK_CHAR(id, 0),
+                        chunkdesc ? chunkdesc->description : "unknown chunk",
+                        len);
+#endif
+                length -= len;
+
+                switch(id) {
+                        case G3D_IFF_MKID('c', 'n', 't', 'r'):
+                                /* container */
+#if DEBUG > 0
+                                g_debug("|%snew container @ 0x%x (%d bytes)",
+                                        debug_pad(level - 1),
+                                        (guint32)g3d_stream_tell(stream) - 8, len);
+#endif
+                                x3dmf_read_container(stream, len, model, object, level + 1,
+                                        toc, context);
+                                break;
+
+                        case G3D_IFF_MKID('k', 'd', 'i', 'f'):
+                                /* diffuse color */
+                                if(object) {
+#if DEBUG > 2
+                                        g_debug("3DMF: kdif: got object");
+#endif
+                                        material = g_slist_nth_data(object->materials, 0);
+                                        material->r = g3d_stream_read_float_be(stream);
+                                        material->g = g3d_stream_read_float_be(stream);
+                                        material->b = g3d_stream_read_float_be(stream);
+                                } else {
+                                        g3d_stream_skip(stream, len);
+                                }
+                                break;
+
+                        case G3D_IFF_MKID('k', 's', 'p', 'c'):
+                                /* specular color */
+                                if(object) {
+#if DEBUG > 2
+                                        g_debug("3DMF: kspc: got object");
+#endif
+                                        material = g_slist_nth_data(object->materials, 0);
+                                        material->specular[0] = g3d_stream_read_float_be(stream);
+                                        material->specular[1] = g3d_stream_read_float_be(stream);
+                                        material->specular[2] = g3d_stream_read_float_be(stream);
+                                } else {
+                                        g3d_stream_skip(stream, len);
+                                }
+                                break;
+
+                        case G3D_IFF_MKID('k', 'x', 'p', 'r'):
+                                /* transparency color */
+                                if(object) {
+                                        /* use average as alpha */
+                                        material = g_slist_nth_data(object->materials, 0);
+                                        material->a = 1.0 -
+                                                (g3d_stream_read_float_be(stream) +
+                                                g3d_stream_read_float_be(stream) +
+                                                g3d_stream_read_float_be(stream)) / 3.0;
+
+                                        if(material->a < 0.1)
+                                                material->a = 0.1;
+                                } else {
+                                        g3d_stream_skip(stream, len);
+                                }
+                                break;
+
+                        case G3D_IFF_MKID('m', 'e', 's', 'h'):
+                                /* mesh */
+                                if(object == NULL)
+                                        object = x3dmf_object_new(stream, model);
+                                material = g_slist_nth_data(object->materials, 0);
+
+                                chk = x3dmf_read_mesh(stream, object, context);
+                                g3d_object_transform(object, matrix);
+                                if(chk != len) {
+                                        g_warning("3DMF: mesh: wrong length (%u != %u)\n",
+                                                chk, (unsigned int) len);
+                                        return FALSE;
+                                }
+                                break;
+
+                        case G3D_IFF_MKID('m', 't', 'r', 'x'):
+                                /* matrix */
+                                for(i = 0; i < 16; i ++)
+                                        matrix[i] = g3d_stream_read_float_be(stream);
+                                if(object) {
+#if DEBUG > 2
+                                        g_debug("3DMF: mtrx: object is set");
+#endif
+                                        g3d_object_transform(object, matrix);
+                                }
+#if DEBUG > 3
+                                for(i = 0; i < 4; i ++)
+                                        g_debug("3DMF: mtrx: %+1.2f %+1.2f %+1.2f %+1.2f",
+                                                matrix[i * 4 + 0], matrix[i * 4 + 1],
+                                                matrix[i * 4 + 2], matrix[i * 4 + 3]);
+#endif
+                                break;
+
+                        case G3D_IFF_MKID('r', 'f', 'r', 'n'):
+                                /* reference */
+                                x3dmf_read_rfrn(stream, model, toc, context);
+                                break;
+
+                        case G3D_IFF_MKID('s', 'e', 't', ' '):
+                                /* ??: skip this cntr chunk */
+                                g3d_stream_skip(stream, length);
+                                length = 0;
+                                break;
+
+                        case G3D_IFF_MKID('t', 'm', 's', 'h'):
+                                /* triangle mesh */
+                                if(object == NULL)
+                                        object = x3dmf_object_new(stream, model);
+                                material = g_slist_nth_data(object->materials, 0);
+
+                                chk = x3dmf_read_tmsh(stream, object, context);
+                                g3d_object_transform(object, matrix);
+                                if(chk != len) {
+#if DEBUG > 0
+                                        g_debug("3DMF: tmsh: offset %d bytes", len - chk);
+#endif
+                                        g3d_stream_skip(stream, len - chk);
+                                }
+                                break;
+
+                        case G3D_IFF_MKID('t', 'r', 'n', 's'):
+                                /* translate */
+                                if(object) {
+                                        G3DFloat x,y,z;
+                                        G3DFloat matrix[16];
+
+                                        x = g3d_stream_read_float_be(stream);
+                                        y = g3d_stream_read_float_be(stream);
+                                        z = g3d_stream_read_float_be(stream);
+
+                                        g3d_matrix_identity(matrix);
+                                        g3d_matrix_translate(x, y, z, matrix);
+
+                                        g3d_object_transform(object, matrix);
+                                } else {
+#if DEBUG > 0
+                                        g_warning("3DMF: [trns] no object");
+#endif
+                                        g3d_stream_skip(stream, 12);
+                                }
+                                break;
+
+                        default:
+                                if(chunkdesc) {
+                                        g3d_stream_skip(stream, len);
+                                } else {
+#if DEBUG > 0
+                                g_warning("3DMF: Container: unknown chunk '%c%c%c%c'/"
+                                        "0x%02X%02X%02X%02X @ 0x%08x "
+                                        "(%d bytes)",
+                                        X3DMF_CHUNK_CHAR(id, 24), X3DMF_CHUNK_CHAR(id, 16),
+                                        X3DMF_CHUNK_CHAR(id, 8), X3DMF_CHUNK_CHAR(id, 0),
+                                        X3DMF_CHUNK_CHAR(id, 24), X3DMF_CHUNK_CHAR(id, 16),
+                                        X3DMF_CHUNK_CHAR(id, 8), X3DMF_CHUNK_CHAR(id, 0),
+                                        (guint32)g3d_stream_tell(stream) - 8, len);
+#endif
+                                        g3d_stream_skip(stream, len);
+                                }
+                                break;
+                }
+        }
+
+        return TRUE;
+}
+