1 files changed, 396 insertions, 0 deletions

diff --git a/src/others/mimesh/mimesh.cpp b/src/others/mimesh/mimesh.cpp
new file mode 100644
index 0000000..e710c4c
--- /dev/null
+++ b/src/others/mimesh/mimesh.cpp
@@ -0,0 +1,396 @@
+/*
+    This is a wrapper around the libg3d mesh loading library.
+
+    Copyright (c) 2010, Dawid Seikel.
+
+    This program 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; version 2 of the License.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "linden_common.h"
+#include "m3math.h"
+#include "m4math.h"
+#include "llcamera.h"
+#include "llpartdata.h"
+#include "lldrawable.h"
+#include "llface.h"
+#include "llvovolume.h"
+#include "pipeline.h"
+#include "glib.h"       // For G_BEGIN_DECLS
+#include "gl.h"
+#include "mimesh.h"
+#include "g3d/plugins.h"
+
+void cmdline_printchat(std::string message);
+
+
+G3DContext* mimesh::context;
+
+void mimesh::startup(void)
+{
+    GSList *item;
+   
+    context = g3d_context_new();
+
+    // Print the details.
+    for (item = context->plugins; item != NULL; item = item->next)
+    {
+        G3DPlugin *plugin = (G3DPlugin *) item->data;
+        gchar **pext = plugin->extensions;
+        std::string message;
+
+        if (plugin->type == G3D_PLUGIN_IMPORT)
+            message = "Model";
+        else
+            message = "Image";
+        message += " loader " + std::string(plugin->name) + " - " + std::string(plugin->desc_func(context)) + "\n  For file extensions : ";
+
+        while(*pext)
+        {
+            message += std::string(*pext) + " ";
+            pext ++;
+        }
+        LL_WARNS("startup") << message << LL_ENDL;
+        cmdline_printchat(message);
+    }
+}
+
+void mimesh::load(LLViewerObject* object, std::string URL)
+{
+    if ((URL.substr(0, 7).compare("file://") == 0) || (URL.substr(0, 7).compare("http://") == 0))
+    {
+        if ((NULL == object->mimeshModel) || (0 != object->mimeshURL.compare(URL)))
+        {
+            // Also check if it's not been moved to the volume.
+            if (object->getVolume() && (object->getVolume()->mimeshModel))
+            {
+                if (0 == object->mimeshURL.compare(URL))
+                    return;
+            }
+            object->mimeshURL = URL;
+            std::string temp_URL = URL;
+            if (temp_URL.substr(0, 7).compare("file://") == 0)
+                temp_URL = temp_URL.substr(6);
+            if (NULL != context)
+            {
+                G3DModel* model;
+
+                model = g3d_model_load(context, temp_URL.c_str());
+                if (model)
+                {
+                    texture_load_all_textures(model);
+                    cmdline_printchat("Loaded model " + temp_URL);
+                    if (object->mimeshModel)
+                    {
+                        cmdline_printchat("Freeing old  model.");
+                        g3d_model_free(object->mimeshModel);
+                    }
+                    // OK, this is BEFORE the volume is set in the VeiwerObject.  Grumble.
+                    object->mimeshModel = model;
+                }
+                else
+                    cmdline_printchat("Failed to load model "  + URL);
+            }
+            else
+                cmdline_printchat("No G3D context!");
+        }
+    }
+    else
+        object->mimeshURL.clear();
+}
+
+
+/*
+    What to do with the data?
+
+LLVeiwerObject contains a pointer to a LLDrawable
+
+LLDrawable has our LLVOVolume
+    contains a LLViewerObject, which apparently can be cast to a LLVOVolume
+        LLVOVolume  inherits from LLViewerObject <- LLPrimitive <- LLXform
+        LLVOAvataer inherits from LLViewerObject and LLCharacter
+            LLPrimitive contains a protected pointer to LLVolume mVolumep, with a public getVolume().
+
+LLVOVolume->mVolumeChanged = TRUE;
+
+LLVOVolume::processUpdateMesssages calls the parent (LLViewerObject) version first.
+    THAT loads our model.
+Modified LLVOVolume::processUpdateMesssages to stuff the model into llVolumeParams.
+    Which calls LLVOVolume::setVolume()
+        Which calls LLPrimitive::setVolume() only thing that does outside of LLPrimitive (oh and llvotextbubble).
+        Then for sculpties it calls LLVOVolume->sculpt() which does the actual work.
+
+We want to intercept LLVolume->sculpt() to load our mesh data instead.
+Actually load our mesh data before sculpt(), then disable that from ever being called.
+
+LLVolumeParams::mSculptID is the sculptie map texture UUID.
+
+LLVolume->mMesh gets the original prim and sculpty data.
+llmath/LLVolume->mMesh is -     std::vector<Point> mMesh;  // Can treat it like an array.
+mMesh is protected.
+Point contains a LLVector3 -    Point->mPos (-0.5 to 0.5)
+LLVolumeFace->mVertices gets a copy.
+LLFace->mVertexBuffer gets a copy.
+    Does the actual drawing (pushing vertices and such to GL).
+    Has pointers to LLDrawable and LLViewerObject.
+
+Hmmm, does everything assume that a LLVolume has a path and a profile?
+
+G3DModel
+    gint32 glflags = 
+        // G3D_FLAG_GL_SPECULAR |
+        G3D_FLAG_GL_SHININESS |
+        G3D_FLAG_GL_ALLTWOSIDE |
+        G3D_FLAG_GL_TEXTURES;
+
+    for(f = 1.0; f >= 0.0; f -= 0.2)
+    {
+        G3DFloat min_a = f, max_a = f + 0.2;
+        gl_draw_objects(glflags, model->objects, min_a, max_a);
+
+            GSList *olist = model->objects;
+            while(olist != NULL)
+            {
+                int i;
+                G3DObject object = (G3DObject *) olist->data;
+                olist = olist->next;
+                dont_render = FALSE;
+                // don't render invisible objects.
+                if(object->hide) continue;
+
+                for(i = 0; i < object->_num_faces; i++)
+                {
+                    gl_draw_face(glflags, object, i, min_a, max_a, &dont_render, &init);
+
+                        // draw triangles
+                        for(j = 0; j < 3; j++)
+                        {
+                            if((glflags & G3D_FLAG_GL_TEXTURES) && (object->_flags[i] & G3D_FLAG_FAC_TEXMAP))
+                            {
+                                glTexCoord2f(   object->_tex_coords[(i * 3 + j) * 2 + 0],
+                                                object->_tex_coords[(i * 3 + j) * 2 + 1]);
+                            }
+
+                            glNormal3f( object->_normals[(i * 3 + j) * 3 + 0],
+                                        object->_normals[(i * 3 + j) * 3 + 1],
+                                        object->_normals[(i * 3 + j) * 3 + 2]);
+                            glVertex3f( object->vertex_data[object->_indices[i * 3 + j] * 3 + 0],
+                                        object->vertex_data[object->_indices[i * 3 + j] * 3 + 1],
+                                        object->vertex_data[object->_indices[i * 3 + j] * 3 + 2]);
+                        } // 1 .. 3 
+                } // all faces.
+
+                // handle sub-objects recursively.
+                gl_draw_objects(glflags, object->objects, min_a, max_a);
+            }
+    }
+*/
+
+
+static int countTriangles(GSList *objects)
+{
+    int result = 0;
+
+    while(objects != NULL)
+    {
+        G3DObject *object = (G3DObject *) objects->data;
+
+        objects = objects->next;
+        if (object->hide) continue;
+        result += object->_num_faces;
+        result += countTriangles(object->objects);
+    }
+    return result;
+}
+
+
+static void getVerticesAndStuff(GSList *objects, std::vector<LLVolume::Point> mesh, LLVolumeFace& vf, int *i, LLVector3& face_min, LLVector3& face_max)
+{
+    while(objects != NULL)
+    {
+        G3DObject *object = (G3DObject *) objects->data;
+        int j, k;
+        int count = object->_num_faces;
+
+        objects = objects->next;
+        if (object->hide) continue;
+
+        for (k = 0 ; k < count; k++)
+        {
+            for (j = 0; j < 3; j++)
+            {
+//              mesh[*i].mPos.mV[0] = object->vertex_data[      object->_indices        [k * 3 + j] * 3 + 0];
+//              mesh[*i].mPos.mV[1] = object->vertex_data[      object->_indices        [k * 3 + j] * 3 + 1];
+//              mesh[*i].mPos.mV[2] = object->vertex_data[      object->_indices        [k * 3 + j] * 3 + 2];
+                mesh[*i].mPos = LLVector3(                      object->vertex_data     [(k * 3 + j) * 3 + 0],  // F64() = G3DFloat() 
+                                                                object->vertex_data     [(k * 3 + j) * 3 + 1],
+                                                                object->vertex_data     [(k * 3 + j) * 3 + 2]);
+
+                vf.mVertices[*i].mPosition = mesh[*i].mPos;
+//              vf.mVertices[*i].mTexCoord = LLVector2(         object->_tex_coords     [(k * 3 + j) * 2 + 0],  // F32() = G3DFloat()
+//                                                              object->_tex_coords     [(k * 3 + j) * 2 + 1]);
+
+                vf.mVertices[*i].mNormal = LLVector3(           object->_normals        [(k * 3 + j) * 3 + 0],  // F64() = G3DFloat()
+                                                                object->_normals        [(k * 3 + j) * 3 + 1],
+                                                                object->_normals        [(k * 3 + j) * 3 + 2]);
+
+                vf.mVertices[*i].mBinormal = LLVector3(0,0,0);  // Um, do we have binormals?  Viewer does not seem to have them either.  shrugs
+
+                if (0 == *i)
+                {
+                        face_min = face_max = mesh[*i].mPos;
+                }
+                else
+                {
+                        update_min_max(face_min, face_max, mesh[*i].mPos);
+                }
+
+                // Damn, at this point viewer wants quads, but the library uses triangles.
+                // Those few times when the library deals with quads, the forth is just the next index.
+                // No idea what the edges are for.  -1 seems to mean no edge, so go with that for now.
+                vf.mIndices     [(*i) * 6 + j] = object->_indices[k * 3 + j];
+                vf.mEdge        [(*i) * 6 + j] = -1;
+            }
+            vf.mIndices         [(*i) * 6 + 3] = object->_indices[k * 3 + 0];   // U16 = guint32 
+            vf.mIndices         [(*i) * 6 + 4] = object->_indices[k * 3 + 3];
+            vf.mIndices         [(*i) * 6 + 5] = object->_indices[k * 3 + 1];
+            vf.mEdge            [(*i) * 6 + 3] = -1;                            // S32 = Fucked if I know.
+            vf.mEdge            [(*i) * 6 + 4] = -1;
+            vf.mEdge            [(*i) * 6 + 5] = -1;
+            (*i)++;
+        }
+
+        getVerticesAndStuff(object->objects, mesh, vf, i, face_min, face_max);
+    }
+}
+
+
+void mimesh::getData(LLVolume* volume)
+{
+    G3DModel *model = volume->mimeshModel;
+    if ((model) && (model->objects))
+    {
+        int vertices = countTriangles(model->objects) * 3;
+        int index = 0;
+
+        LL_WARNS("getData") << "Transferring model data for " << std::string(model->filename) << " with " << vertices << " vertices." << LL_ENDL;
+
+        /*
+        sculpt_calc_mesh_resolution(sculpt_width, sculpt_height, sculpt_type, sculpt_detail, requested_sizeS, requested_sizeT);
+                vertices = T * S / 4         = faces / 16 * 16 / 4   = T
+                ratio = T / S                = faces / 16 / 16       = faces / 256
+                s = sqrt(vertices / ratio)   = T / faces / 256      = faces / 16 / faces / 256   = 16 (sqrt = 4)
+                s = llmax(s, 4);              // no degenerate sizes, please  = 4
+                t = vertices / s;                                             = T / 4  = faces / 64
+                t = llmax(t, 4);              // no degenerate sizes, please
+                s = vertices / t;                                             = T / s   = faces / 16 / s
+        */
+        S32 requested_sizeS = llmax (((int) sqrt(vertices)), 4);
+        S32 requested_sizeT = llmax(vertices / requested_sizeS, 4);
+        // create meshes with high LOD always
+        F32 sculpt_detail = 4.0;
+
+LL_WARNS("getData") << "mimesh 0" << LL_ENDL;
+        volume->mPathp->generate(volume->mParams.getPathParams(), sculpt_detail, 0, TRUE, requested_sizeS);
+        volume->mProfilep->generate(volume->mParams.getProfileParams(), volume->mPathp->isOpen(), sculpt_detail, 0, TRUE, requested_sizeT);
+
+        S32 sizeS = volume->mPathp->mPath.size();         // we requested a specific size, now see what we really got
+        S32 sizeT = volume->mProfilep->mProfile.size();   // we requested a specific size, now see what we really got
+
+LL_WARNS("getData") << "mimesh 1   S " << requested_sizeS << "->" << sizeS << " T " << requested_sizeT << "->" << sizeT << " = " << (sizeS * sizeT) << LL_ENDL;
+        volume->sNumMeshPoints -= volume->mMesh.size();
+        volume->mMesh.resize(sizeS * sizeT);
+        volume->sNumMeshPoints += volume->mMesh.size();
+LL_WARNS("getData") << "mimesh 2" << LL_ENDL;
+        volume->mFaceMask = LLVolumeFace::SIDE_MASK | LLVolumeFace::OUTER_MASK;  // Seems to be the default.
+        volume->mSculptLevel = -2;
+        volume->mimeshNeedData = FALSE;
+
+LL_WARNS("getData") << "mimesh 3" << LL_ENDL;
+        // Delete any existing faces so that they get regenerated
+        volume->mVolumeFaces.clear();
+LL_WARNS("getData") << "mimesh 4" << LL_ENDL;
+//      volume->createVolumeFaces();
+        S32 num_faces = volume->mProfilep->mFaces.size();
+        volume->mVolumeFaces.resize(num_faces);
+
+LL_WARNS("getData") << "mimesh 5    " << num_faces << LL_ENDL;
+        // It's pretending to be a sculpty, so only one "face / side".
+        // Initialize volume faces with parameter data
+        for (S32 i = 0; i < num_faces; i++)
+        {
+LL_WARNS("getData") << "mimesh 5.0 " << LL_ENDL;
+            LLVolumeFace& vf = volume->mVolumeFaces[i];
+            LLProfile::Face& face = volume->mProfilep->mFaces[i];
+            LLVector3& face_min = vf.mExtents[0];
+            LLVector3& face_max = vf.mExtents[1];
+
+            vf.mTypeMask        = volume->mFaceMask;
+            vf.mBeginS          = face.mIndex;
+            vf.mNumS            = face.mCount;
+            vf.mBeginT          = 0;
+            vf.mNumT            = volume->getPath().mPath.size();
+            vf.mID              = i;
+
+            // Just to confuse matters, S and T are reversed from what it is above.  Blame LL.
+LL_WARNS("getData") << "mimesh 5.1   S " << vf.mBeginS << "->" << vf.mNumS << " T " << vf.mBeginT << "->" << vf.mNumT << LL_ENDL;
+//          vf.create(volume, FALSE);
+            S32 num_vertices = vf.mNumS * vf.mNumT;
+            S32 num_indices = (vf.mNumS - 1) * (vf.mNumT - 1) * 6;
+
+LL_WARNS("getData") << "mimesh 5.2 " << LL_ENDL;
+            vf.mVertices.resize(vertices);
+            vf.mIndices.resize(num_indices);
+            vf.mEdge.resize(num_indices);
+
+LL_WARNS("getData") << "mimesh 5.3 " << LL_ENDL;
+            vf.mCenter.clearVec();
+
+LL_WARNS("getData") << "mimesh 5.4 " << LL_ENDL;
+            getVerticesAndStuff(model->objects, volume->mMesh, vf, &index, face_min, face_max);
+
+LL_WARNS("getData") << "mimesh 5.5 " << LL_ENDL;
+            vf.mCenter = (face_min + face_max) * 0.5f;
+
+LL_WARNS("getData") << "mimesh 5.6 " << LL_ENDL;
+        }
+LL_WARNS("getData") << "mimesh 6" << LL_ENDL;
+    }
+LL_WARNS("getData") << "mimesh 7" << LL_ENDL;
+}
+
+
+void mimesh::render(LLViewerObject* object)
+{
+    gl_draw_model(object->mimeshModel);
+}
+
+void mimesh::unload(LLViewerObject* object)
+{
+    cmdline_printchat("VO Deleting model data for " + std::string(object->mimeshModel->filename));
+    g3d_model_free(object->mimeshModel);
+    object->mimeshModel = NULL;
+    object->mimeshURL.clear();
+}
+
+void mimesh::unload(LLVolume* volume)
+{
+    cmdline_printchat("V  Deleting model data for " + std::string(volume->mimeshModel->filename));
+    g3d_model_free(volume->mimeshModel);
+    volume->mimeshModel = NULL;
+}
+
+void mimesh::shutdown(void)
+{
+    g3d_context_free(context);
+}