CopperLicht:: OBJ Loader

//--------------------------------------------------------------------------------------------------------------------------
//                                      ObjLoaderNode
//--------------------------------------------------------------------------------------------------------------------------

        // our own scene node implementation
        ObjLoaderNode = function()
        {
            this.init();
            this.Box = new CL3D.Box3d();
            this.DoesCollision = false;
            this.OwnedMesh = null;
            this.BuildMesh = new CL3D.Mesh();
            this.ReadOnlyMaterials = true;
            this.Selector = null

            // create a 3d mesh with one mesh buffer
            this.VertexBuffer = new CL3D.MeshBuffer();
            this.BuildMesh.AddMeshBuffer(this.VertexBuffer);
        }
        ObjLoaderNode.prototype = new CL3D.MeshSceneNode(); // derive from SceneNode

        ObjLoaderNode.prototype.load = function(engine, filename, scale) {

            if (scale == null) scale = 0.05;

            var a = new CL3D.CCFileLoader(filename);

            var loaderNode = this;

            a.load(function (data) {
                data = data.split("\n");
                var vertices = [];
                var vertdata = [];
                var texdata = [];
                var normdata = [];

                // helper function for quickly creating a 3d vertex from 3d position and texture coodinates
                createVertex = function(x, y, z, s, t, nx, ny, nz)
                {
                    var vtx = new CL3D.Vertex3D(true);
                    vtx.Pos.X = x;
                    vtx.Pos.Y = y;
                    vtx.Pos.Z = z;
                    vtx.TCoords.X = s;
                    vtx.TCoords.Y = t;
                    vtx.Normal.X = nx;
                    vtx.Normal.Y = ny;
                    vtx.Normal.Z = nz;
                    return vtx;
                }

                function getvertex(desc) {
                    if (vertices[desc] == null) {
                        var desc = desc.split("/");
                        var x = vertdata[desc[0]].x;
                        var y = vertdata[desc[0]].y;
                        var z = vertdata[desc[0]].z;
                        var u = ((desc[1] != null)?texdata[desc[1]].u:0);
                        var v = ((desc[1] != null)?texdata[desc[1]].v:0);
                        var nx = ((desc[2] != null)?normdata[desc[2]].nx:0);
                        var ny = ((desc[2] != null)?normdata[desc[2]].ny:0);
                        var nz = ((desc[2] != null)?normdata[desc[2]].nz:1);
                        vertices[desc] = loaderNode.VertexBuffer.Vertices.push(createVertex( x, y, z,  u, v,  nx, ny, nz) )-1;
                    }
                    return vertices[desc];
                }

                var vertindex = 1;
                var texindex = 1;
                var normindex = 1;

                loaderNode.VertexBuffer.Vertices = [];
                loaderNode.VertexBuffer.Indices = [];

                for (var i=0; i<data.length; i++) {
                    data[i] = data[i].replace("  ", " ");
                    var line = data[i].split(" ");
                    if (line.length > 0) {
                        switch (line[0]) {
                            case "v":
                                var x = parseFloat(line[1])*scale;
                                var y = parseFloat(line[2])*scale;
                                var z = parseFloat(line[3])*scale;
                                vertdata[vertindex] = { x:x, y:y, z:z };
                                vertindex ++;
                                break;
                            case "vn":
                                var nx = parseFloat(line[1]);
                                var ny = parseFloat(line[2]);
                                var nz = parseFloat(line[3]);
                                normdata[normindex] = { nx:nx, ny:ny, nz:nz };
                                normindex ++;
                                break;
                            case "vt":
                                var u = parseFloat(line[1]);
                                var v = parseFloat(line[2]);
                                texdata[texindex] = { u:u, v:v };
                                texindex ++;
                                break;
                            case "f":
                                var a = getvertex(line[1]);
                                var b = getvertex(line[2]);
                                for (var it=3; it<line.length-1;it++) {
                                    var c = getvertex(line[it]);
                                    loaderNode.VertexBuffer.Indices.push(a); loaderNode.VertexBuffer.Indices.push(b); loaderNode.VertexBuffer.Indices.push(c);
                                    b = c;
                                }
                        }
                    }
                }
                loaderNode.VertexBuffer.update(true);
                //loaderNode.VertexBuffer.Mat.Tex1 = engine.getTextureManager().getTexture("wood_texture.jpg", true); //<-----------texture
                loaderNode.setMesh(loaderNode.BuildMesh);
            })

        }