Пример #1
1
        public void Export(string filePath)
        {
            PalletProperties palletProperties = _palletSolution.Analysis.PalletProperties;

            COLLADA model = new COLLADA();
            // asset
            model.asset = new asset()
            {
                created = DateTime.Now,
                modified = DateTime.Now
            };
            model.asset.keywords = "StackBuilder Pallet Case";
            model.asset.title = _palletSolution.Title;
            model.asset.unit = new assetUnit() { name = "millimeters", meter = 0.001 };
            model.asset.up_axis = UpAxisType.Z_UP;

            library_images images = new library_images();
            library_materials materials = new library_materials();
            library_effects effects = new library_effects();
            library_geometries geometries = new library_geometries();
            library_nodes nodes = new library_nodes();
            library_cameras cameras = new library_cameras();
            library_animations animations = new library_animations();
            library_visual_scenes scenes = new library_visual_scenes();

            COLLADAScene colladaScene = new COLLADAScene();

            model.Items = new Object[] { images, materials, effects, geometries, nodes, cameras, animations, scenes };
            model.scene = colladaScene;

            // colors and materials
            List<effect> listEffects = new List<effect>();
            List<material> listMaterials = new List<material>();
            List<image> listImages = new List<image>();

            // effects
            effect effectPallet;
            material materialPallet;
            CreateMaterial(palletProperties.Color, null, null, "Pallet", out effectPallet, out materialPallet);
            listEffects.Add(effectPallet);
            listMaterials.Add(materialPallet);

            Box box = new Box(0, _palletSolution.Analysis.BProperties);

            // build list of effects / materials / images
            uint faceIndex = 0;
            foreach (Face face in box.Faces)
            {
                // build texture image if any
                string textureName = null;
                if (face.HasBitmap)
                {
                    textureName = string.Format("textureFace_{0}", faceIndex);
                    string texturePath = System.IO.Path.Combine(
                        System.IO.Path.GetDirectoryName(filePath)
                        , textureName + ".jpg");

                    double dimX = 0.0, dimY = 0.0;

                    switch (faceIndex)
                    {
                        case 0: dimX = box.Width; dimY = box.Height; break;
                        case 1: dimX = box.Width; dimY = box.Height; break;
                        case 2: dimX = box.Length; dimY = box.Height; break;
                        case 3: dimX = box.Length; dimY = box.Height; break;
                        case 4: dimX = box.Length; dimY = box.Width; break;
                        case 5: dimX = box.Length; dimY = box.Width; break;
                        default: break;
                    }
                    face.ExtractFaceBitmap(dimX, dimY, _bmpWidth, texturePath);
                    // create image
                    listImages.Add(
                        new image()
                        {
                            id = textureName + ".jpg",
                            name = textureName + ".jpg",
                            Item = @".\" + textureName + @".jpg"
                        }
                    );
                }
                material materialCase;
                effect effectCase;
                CreateMaterial(face.ColorFill, textureName, "0", string.Format("Case{0}", faceIndex), out effectCase, out materialCase);
                listEffects.Add(effectCase);
                listMaterials.Add(materialCase);

                ++faceIndex;
            }

            // add to image list
            images.image = listImages.ToArray();

            // case lines material
            effect effectCaseLines;
            material materialCaseLines;
            CreateMaterial(Color.Black, null, null, "CaseLines", out effectCaseLines, out materialCaseLines);
            listEffects.Add(effectCaseLines);
            listMaterials.Add(materialCaseLines);
            effects.effect = listEffects.ToArray();
            materials.material = listMaterials.ToArray();

            // geometries
            geometry geomPallet = new geometry() { id = "palletGeometry", name = "palletGeometry" };
            geometry geomCase = new geometry() { id = "caseGeometry", name = "caseGeometry" };
            geometries.geometry = new geometry[] { geomPallet, geomCase };
            // pallet
            mesh meshPallet = CreatePalletMesh(palletProperties);
            geomPallet.Item = meshPallet;
            // case
            mesh meshCase = CreateCaseMesh(_palletSolution.Analysis.BProperties as BoxProperties);
            geomCase.Item = meshCase;
            // library_animations
            animation animationMain = new animation() { id = "animationMain_ID", name = "animationMain" };
            animations.animation = new animation[] { animationMain };

            List<object> listAnimationSource = new List<object>();

            // library_visual_scenes
            visual_scene mainScene = new visual_scene() { id = "MainScene", name = "MainScene" };
            scenes.visual_scene = new visual_scene[] { mainScene };

            List<node> sceneNodes = new List<node>();
            sceneNodes.Add(new node()
            {
                id = "PalletNode",
                name = "PalletNode",
                instance_geometry = new instance_geometry[]
                {
                    new instance_geometry()
                    {
                        url = "#palletGeometry",
                        bind_material = new bind_material()
                        {
                            technique_common = new instance_material[]
                            {
                                new instance_material()
                                {
                                    symbol="materialPallet",
                                    target=string.Format("#{0}", materialPallet.id)
                                }
                            }
                        }
                    }
                }
            });
            uint caseIndex = 0;
            foreach (ILayer layer in _palletSolution)
            {
                BoxLayer bLayer = layer as BoxLayer;
                if (null == bLayer) continue;

                foreach (BoxPosition bp in bLayer)
                {
                    Vector3D translation = bp.Position;
                    Vector3D rotations = bp.Transformation.Rotations;

                    node caseNode = new node()
                    {
                        id = string.Format("CaseNode_{0}_ID", caseIndex),
                        name = string.Format("CaseNode_{0}", caseIndex),
                        ItemsElementName = new ItemsChoiceType2[]
                        {
                            ItemsChoiceType2.translate,
                            ItemsChoiceType2.rotate,
                            ItemsChoiceType2.rotate,
                            ItemsChoiceType2.rotate
                        },
                        Items = new object[]
                        {
                            new TargetableFloat3()
                            {
                                Values = new double[] { translation.X, translation.Y, translation.Z },
                                sid = "t",
                            },
                            new rotate()
                            {
                                Values = new double[] { 1.0, 0.0, 0.0, rotations.X },
                                sid = "rx"
                            },
                            new rotate()
                            {
                                Values = new double[] { 0.0, 1.0, 0.0, rotations.Y },
                                sid = "ry"
                            },
                            new rotate()
                            {
                                Values = new double[] { 0.0, 0.0, 1.0, rotations.Z },
                                sid = "rz"
                            } 
                        },

                        instance_geometry = new instance_geometry[]
                        {
                            new instance_geometry()
                            {
                                url="#caseGeometry",
                                bind_material = new bind_material()
                                {
                                    technique_common = new instance_material[]
                                    {
                                        new instance_material() { symbol="materialCase0", target="#material_Case0_ID" },
                                        new instance_material() { symbol="materialCase1", target="#material_Case1_ID" },
                                        new instance_material() { symbol="materialCase2", target="#material_Case2_ID" },
                                        new instance_material() { symbol="materialCase3", target="#material_Case3_ID" },
                                        new instance_material() { symbol="materialCase4", target="#material_Case4_ID" },
                                        new instance_material() { symbol="materialCase5", target="#material_Case5_ID" },
                                        new instance_material() { symbol="materialCaseLines", target="#material_CaseLines_ID"}
                                    }
                                }
                            }
                        }
                    };
                    sceneNodes.Add(caseNode);

                    // animations
                    CreateAnimation(caseIndex, (uint)_palletSolution.CaseCount, listAnimationSource, bp);

                    // increment case index
                    ++caseIndex;
                }
            }

            // add nodes
            mainScene.node = sceneNodes.ToArray();

            animationMain.Items = listAnimationSource.ToArray();

            // library_cameras
            camera cameraCamera = new camera() { id = "Camera-Camera", name = "Camera-Camera" };
            cameraOpticsTechnique_commonPerspective cameraPerspective = new cameraOpticsTechnique_commonPerspective()
            {
                znear = new TargetableFloat() { sid = "znear", Value = 1.0 },
                zfar = new TargetableFloat() { sid = "zfar", Value = 10000.0 }
            };
            cameraCamera.optics = new cameraOptics() { technique_common = new cameraOpticsTechnique_common() { Item = cameraPerspective } };
            cameras.camera = new camera[] { cameraCamera };

            // colladaScene
            colladaScene.instance_visual_scene = new InstanceWithExtra() { url = "#MainScene" };

            model.Save(filePath);
            model.Save(System.IO.Path.ChangeExtension(filePath, "xml"));
        }
Пример #2
0
        static ColladaGeometry GetGeometry(CL.UpAxisType up, CL.geometry geo, CL.library_materials matlib, CL.library_effects fxlib)
        {
            var conv = new ColladaGeometry()
            {
                FVF = D3DFVF.XYZ
            };

            conv.Name = string.IsNullOrEmpty(geo.name) ? geo.id : geo.name;
            var msh = geo.Item as CL.mesh;

            if (msh == null)
            {
                return(null);
            }
            List <VertexPositionNormalDiffuseTextureTwo> vertices = new List <VertexPositionNormalDiffuseTextureTwo>();
            List <int>             hashes                    = new List <int>();
            List <ushort>          indices                   = new List <ushort>();
            List <ColladaDrawcall> drawcalls                 = new List <ColladaDrawcall>();
            Dictionary <string, GeometrySource> sources      = new Dictionary <string, GeometrySource>();
            Dictionary <string, float[]>        arrays       = new Dictionary <string, float[]>();
            Dictionary <string, GeometrySource> verticesRefs = new Dictionary <string, GeometrySource>();
            int placeHolderIdx = 0;

            //Get arrays
            foreach (var acc in msh.source)
            {
                var arr = acc.Item as CL.float_array;
                arrays.Add(arr.id, FloatArray(arr.Text));
            }
            //Accessors
            foreach (var acc in msh.source)
            {
                sources.Add(acc.id, new GeometrySource(acc, arrays));
            }
            //Process geometry
            foreach (var item in msh.Items)
            {
                if (!(item is CL.triangles || item is CL.polylist || item is CL.polygons))
                {
                    FLLog.Warning("Collada", "Ignoring " + item.GetType().Name + " element.");
                }
            }
            int totalTriangles = 0;

            foreach (var item in msh.Items.Where(x => x is CL.triangles || x is CL.polylist || x is CL.polygons))
            {
                if (item is CL.triangles)
                {
                    totalTriangles += (int)((CL.triangles)item).count;
                }
                else if (item is CL.polylist plist)
                {
                    totalTriangles += (int)plist.count;
                }
                else
                {
                    totalTriangles += (int)((CL.polygons)item).count;
                }
            }
            if (totalTriangles > 21845)
            {
                throw new Exception(string.Format(
                                        "Overflow!\nCollada geometry {0} has {1} triangles\nVMeshData has limit of 21845",
                                        string.IsNullOrEmpty(geo.name) ? geo.id : geo.name,
                                        totalTriangles));
            }
            foreach (var item in msh.Items.Where(x => x is CL.triangles || x is CL.polylist || x is CL.polygons))
            {
                CL.InputLocalOffset[] inputs;
                int[]           pRefs;
                int             indexCount;
                string          materialRef;
                ColladaMaterial material;
                if (item is CL.triangles)
                {
                    var triangles = (CL.triangles)item;
                    indexCount  = (int)(triangles.count * 3);
                    pRefs       = IntArray(triangles.p);
                    inputs      = triangles.input;
                    materialRef = triangles.material;
                }
                else if (item is CL.polygons polygons)
                {
                    indexCount = (int)(polygons.count * 3);
                    int j = 0;
                    pRefs = new int[indexCount];
                    foreach (var arr in polygons.Items)
                    {
                        if (!(arr is string))
                        {
                            throw new Exception("Polygons: ph element unsupported");
                        }
                        var ints = IntArray((string)arr);
                        if (ints.Length != 3)
                        {
                            throw new Exception("Polygons: non-triangle geometry not supported");
                        }
                        pRefs[j]     = ints[0];
                        pRefs[j + 1] = ints[1];
                        pRefs[j + 2] = ints[2];
                        j           += 3;
                    }
                    inputs      = polygons.input;
                    materialRef = polygons.material;
                }
                else
                {
                    var plist = (CL.polylist)item;
                    pRefs = IntArray(plist.p);
                    foreach (var c in IntArray(plist.vcount))
                    {
                        if (c != 3)
                        {
                            throw new Exception("Polylist: non-triangle geometry");
                        }
                    }
                    materialRef = plist.material;
                    inputs      = plist.input;
                    indexCount  = (int)(plist.count * 3);
                }
                if (indexCount == 0)
                {
                    continue;                  //Skip empty
                }
                material = ParseMaterial(materialRef, matlib, fxlib);
                int pStride = 0;
                foreach (var input in inputs)
                {
                    pStride = Math.Max((int)input.offset, pStride);
                }
                pStride++;
                GeometrySource sourceXYZ = null; int offXYZ = int.MinValue;
                GeometrySource sourceNORMAL = null; int offNORMAL = int.MinValue;
                GeometrySource sourceCOLOR = null; int offCOLOR = int.MinValue;
                GeometrySource sourceUV1 = null; int offUV1 = int.MinValue;
                GeometrySource sourceUV2 = null; int offUV2 = int.MinValue;
                int            texCount = 0;
                int            startIdx = indices.Count;
                foreach (var input in inputs)
                {
                    switch (input.semantic)
                    {
                    case SEM_VERTEX:
                        if (CheckURI(input.source) != msh.vertices.id)
                        {
                            throw new Exception("VERTEX doesn't match mesh vertices");
                        }
                        foreach (var ip2 in msh.vertices.input)
                        {
                            switch (ip2.semantic)
                            {
                            case SEM_POSITION:
                                offXYZ    = (int)input.offset;
                                sourceXYZ = sources[CheckURI(ip2.source)];
                                break;

                            case SEM_NORMAL:
                                offNORMAL    = (int)input.offset;
                                sourceNORMAL = sources[CheckURI(ip2.source)];
                                conv.FVF    |= D3DFVF.NORMAL;
                                break;

                            case SEM_COLOR:
                                offCOLOR    = (int)input.offset;
                                sourceCOLOR = sources[CheckURI(ip2.source)];
                                conv.FVF   |= D3DFVF.DIFFUSE;
                                break;

                            case SEM_TEXCOORD:
                                if (texCount == 2)
                                {
                                    throw new Exception("Too many texcoords!");
                                }
                                if (texCount == 1)
                                {
                                    offUV2    = (int)input.offset;
                                    sourceUV2 = sources[CheckURI(ip2.source)];
                                    conv.FVF &= ~D3DFVF.TEX1;
                                    conv.FVF |= D3DFVF.TEX2;
                                }
                                else
                                {
                                    offUV1    = (int)input.offset;
                                    sourceUV1 = sources[CheckURI(ip2.source)];
                                    if ((conv.FVF & D3DFVF.TEX2) != D3DFVF.TEX2)
                                    {
                                        conv.FVF |= D3DFVF.TEX1;
                                    }
                                }
                                texCount++;
                                break;
                            }
                        }
                        break;

                    case SEM_POSITION:
                        offXYZ    = (int)input.offset;
                        sourceXYZ = sources[CheckURI(input.source)];
                        break;

                    case SEM_NORMAL:
                        offNORMAL    = (int)input.offset;
                        sourceNORMAL = sources[CheckURI(input.source)];
                        conv.FVF    |= D3DFVF.NORMAL;
                        break;

                    case SEM_COLOR:
                        offCOLOR    = (int)input.offset;
                        sourceCOLOR = sources[CheckURI(input.source)];
                        conv.FVF   |= D3DFVF.DIFFUSE;
                        break;

                    case SEM_TEXCOORD:
                        if (texCount == 2)
                        {
                            throw new Exception("Too many texcoords!");
                        }
                        if (texCount == 1)
                        {
                            offUV2    = (int)input.offset;
                            sourceUV2 = sources[CheckURI(input.source)];
                            conv.FVF &= ~D3DFVF.TEX1;
                            conv.FVF |= D3DFVF.TEX2;
                        }
                        else
                        {
                            offUV1    = (int)input.offset;
                            sourceUV1 = sources[CheckURI(input.source)];
                            if ((conv.FVF & D3DFVF.TEX2) != D3DFVF.TEX2)
                            {
                                conv.FVF |= D3DFVF.TEX1;
                            }
                        }
                        texCount++;
                        break;
                    }
                }
                int vertexOffset = vertices.Count;
                for (int i = 0; i < indexCount; i++)
                {
                    int idx  = i * pStride;
                    var vert = new VertexPositionNormalDiffuseTextureTwo(
                        VecAxis(up, sourceXYZ.GetXYZ(pRefs[idx + offXYZ])),
                        offNORMAL == int.MinValue ? Vector3.Zero : VecAxis(up, sourceNORMAL.GetXYZ(pRefs[idx + offNORMAL])),
                        offCOLOR == int.MinValue ? (uint)Color4.White.ToRgba() : (uint)sourceCOLOR.GetColor(pRefs[idx + offCOLOR]).ToRgba(),
                        offUV1 == int.MinValue ? Vector2.Zero : sourceUV1.GetUV(pRefs[idx + offUV1]),
                        offUV2 == int.MinValue ? Vector2.Zero : sourceUV2.GetUV(pRefs[idx + offUV2])
                        );
                    var hash    = HashVert(ref vert);
                    var vertIdx = FindDuplicate(hashes, vertices, vertexOffset, ref vert, hash);
                    if (indices.Count >= ushort.MaxValue)
                    {
                        throw new Exception("Too many indices");
                    }
                    if (vertIdx == -1)
                    {
                        if (vertices.Count + 1 >= ushort.MaxValue)
                        {
                            throw new Exception("Too many vertices");
                        }
                        indices.Add((ushort)(vertices.Count - vertexOffset));
                        vertices.Add(vert);
                        hashes.Add(hash);
                    }
                    else
                    {
                        indices.Add((ushort)(vertIdx - vertexOffset));
                    }
                }
                drawcalls.Add(new ColladaDrawcall()
                {
                    StartIndex  = startIdx,
                    StartVertex = vertexOffset,
                    EndVertex   = vertices.Count - 1,
                    TriCount    = (indices.Count - startIdx) / 3,
                    Material    = material
                });
            }
            conv.Indices   = indices.ToArray();
            conv.Vertices  = vertices.ToArray();
            conv.Drawcalls = drawcalls.ToArray();
            conv.CalculateDimensions();
            return(conv);
        }
Пример #3
0
        static ColladaMaterial ParseMaterial(string name, CL.library_materials matlib, CL.library_effects fxlib)
        {
            if (matlib == null)
            {
                return new ColladaMaterial()
                       {
                           Dc   = Color4.Red,
                           Name = name
                       }
            }
            ;
            var src = matlib.material.FirstOrDefault(mat => mat.id.Equals(name, StringComparison.InvariantCulture));

            if (src == null)
            {
                return new ColladaMaterial()
                       {
                           Dc   = Color4.Red,
                           Name = name
                       }
            }
            ;
            var output = new ColladaMaterial()
            {
                Dc = Color4.Red
            };

            output.Name = string.IsNullOrWhiteSpace(src.name) ? name : src.name;
            if (src.instance_effect == null)
            {
                return(output);
            }
            if (fxlib == null)
            {
                return(output);
            }
            var fx = fxlib.effect.FirstOrDefault(fx =>
                                                 fx.id.Equals(CheckURI(src.instance_effect.url), StringComparison.InvariantCulture));

            if (fx != null)
            {
                var profile = fx.Items.FirstOfType <CL.effectFx_profile_abstractProfile_COMMON>();
                if (profile == null)
                {
                    return(output);
                }
                if (profile.technique == null)
                {
                    return(output);
                }
                switch (profile.technique.Item)
                {
                case CL.effectFx_profile_abstractProfile_COMMONTechniquePhong phong:
                    SetDc(output, phong.diffuse);
                    break;

                case CL.effectFx_profile_abstractProfile_COMMONTechniqueBlinn blinn:
                    SetDc(output, blinn.diffuse);
                    break;

                case CL.effectFx_profile_abstractProfile_COMMONTechniqueConstant constant:
                    output.Dc = Color4.White;
                    break;

                case CL.effectFx_profile_abstractProfile_COMMONTechniqueLambert lambert:
                    SetDc(output, lambert.diffuse);
                    break;
                }
            }
            return(output);
        }
Пример #4
0
        static ColladaObject ProcessNode(CL.UpAxisType up, CL.library_geometries geom, CL.node n, CL.library_materials matlib, CL.library_effects fxlib)
        {
            var obj = new ColladaObject();

            obj.Name = n.name;
            obj.ID   = n.id;
            if (n.instance_geometry != null && n.instance_geometry.Length > 0)
            {
                //Geometry object
                if (n.instance_geometry.Length != 1)
                {
                    throw new Exception("How to handle multiple geometries/node?");
                }
                var uri = CheckURI(n.instance_geometry[0].url);
                var g   = geom.geometry.Where((x) => x.id == uri).First();
                if (g.Item is CL.mesh)
                {
                    obj.Geometry = GetGeometry(up, g, matlib, fxlib);
                }
                else if (g.Item is CL.spline)
                {
                    obj.Spline = GetSpline(up, g);
                }
            }
            if (n.Items.OfType <CL.matrix>().Any())
            {
                var tr = n.Items.OfType <CL.matrix>().First();
                obj.Transform = GetMatrix(up, tr.Text);
            }
            else
            {
                Matrix4x4 mat = Matrix4x4.Identity;
                foreach (var item in n.Items)
                {
                    if (item is CL.TargetableFloat3)
                    {
                        //var float3 =
                    }
                }
                obj.Transform = mat;
            }
            if (n.node1 != null && n.node1.Length > 0)
            {
                foreach (var node in n.node1)
                {
                    obj.Children.Add(ProcessNode(up, geom, node, matlib, fxlib));
                }
            }
            return(obj);
        }
Пример #5
0
        public override ModelBase LoadModel(Vector3 scale)
        {
            foreach (var item in m_COLLADAModel.Items)
            {
                if (item.GetType().Equals(typeof(library_images))) this.library_images = item as library_images;
                if (item.GetType().Equals(typeof(library_effects))) this.library_effects = item as library_effects;
                if (item.GetType().Equals(typeof(library_materials))) this.library_materials = item as library_materials;
                if (item.GetType().Equals(typeof(library_geometries))) this.library_geometries = item as library_geometries;
                if (item.GetType().Equals(typeof(library_controllers))) this.library_controllers = item as library_controllers;
                if (item.GetType().Equals(typeof(library_visual_scenes))) this.library_visual_scenes = item as library_visual_scenes;
                if (item.GetType().Equals(typeof(library_animations))) this.library_animations = item as library_animations;
            }

            ReadMaterials();

            ReadVisualScenes();

            ReadAnimations();

            m_Model.ScaleModel(scale);
            m_Model.ScaleAnimations(scale);

            return m_Model;
        }
Пример #6
0
        public static void ExportCollada(CmpFile cmp, ResourceManager resources, string output)
        {
            //Build tree
            InputModel        rootModel    = null;
            List <InputModel> parentModels = new List <InputModel>();

            foreach (var p in cmp.Parts)
            {
                if (p.Construct == null)
                {
                    rootModel = new InputModel()
                    {
                        Transform = Matrix4x4.Identity,
                        Model     = p.Model,
                        Con       = "Root"
                    };
                    break;
                }
            }
            parentModels.Add(rootModel);
            var q = new Queue <Part>(cmp.Parts);
            int infiniteDetect = 0;

            while (q.Count > 0)
            {
                var part = q.Dequeue();
                if (part.Construct == null)
                {
                    continue;
                }
                bool enqueue = true;
                foreach (var mdl in parentModels)
                {
                    if (part.Construct.ParentName == mdl.Con)
                    {
                        var child = new InputModel()
                        {
                            Transform = part.Construct.Rotation * Matrix4x4.CreateTranslation(part.Construct.Origin),
                            Model     = part.Model,
                            Con       = part.Construct.ChildName
                        };
                        mdl.Children.Add(child);
                        parentModels.Add(child);
                        enqueue = false;
                        break;
                    }
                }
                if (enqueue)
                {
                    q.Enqueue(part);
                }
                infiniteDetect++;
                if (infiniteDetect > 200000000)
                {
                    throw new Exception("Infinite cmp loop detected");
                }
            }

            //Build collada
            var dae    = NewCollada();
            var efx    = new CL.library_effects();
            var mats   = new CL.library_materials();
            var geos   = new CL.library_geometries();
            var scenes = new CL.library_visual_scenes();
            var vscene = new CL.visual_scene();

            vscene.name                     = vscene.id = "main-scene";
            scenes.visual_scene             = new CL.visual_scene[] { vscene };
            dae.scene                       = new CL.COLLADAScene();
            dae.scene.instance_visual_scene = new CL.InstanceWithExtra()
            {
                url = "#main-scene"
            };
            var glist   = new List <CL.geometry>();
            var mlist   = new List <string>();
            var matlist = new List <ExportMaterial>();

            BuildModel(resources, rootModel, glist, mlist, matlist);
            geos.geometry = glist.ToArray();
            mats.material = mlist.Select((x) => new CL.material()
            {
                name            = x,
                id              = x + "-material",
                instance_effect = new CL.instance_effect()
                {
                    url = "#" + x + "-effect"
                }
            }).ToArray();
            efx.effect = matlist.Select((x) => new CL.effect()
            {
                id    = x.Name + "-effect",
                Items = new[]
                {
                    new CL.effectFx_profile_abstractProfile_COMMON()
                    {
                        technique = new CL.effectFx_profile_abstractProfile_COMMONTechnique()
                        {
                            id   = "common",
                            Item = new CL.effectFx_profile_abstractProfile_COMMONTechniquePhong()
                            {
                                ambient             = ColladaColor("ambient", Color4.Black),
                                emission            = ColladaColor("emmision", Color4.Black),
                                diffuse             = ColladaColor("diffuse", x.Dc),
                                specular            = ColladaColor("specular", new Color4(0.25f, 0.25f, 0.25f, 1f)),
                                shininess           = ColladaFloat("shininess", 50),
                                index_of_refraction = ColladaFloat("index_of_refraction", 1)
                            }
                        }
                    }
                }
            }).ToArray();
            var rootNodes = new List <CL.node>();

            BuildNodes(rootModel, rootNodes);
            vscene.node = rootNodes.ToArray();
            dae.Items   = new object[] { efx, mats, geos, scenes };
            using (var stream = File.Create(output))
                ColladaSupport.XML.Serialize(stream, dae);
        }
Пример #7
0
        public static void ExportCollada(ModelFile mdl, ResourceManager resources, string output)
        {
            var dae    = NewCollada();
            var mats   = new CL.library_materials();
            var efx    = new CL.library_effects();
            var geos   = new CL.library_geometries();
            var scenes = new CL.library_visual_scenes();
            var vscene = new CL.visual_scene();

            vscene.name                     = vscene.id = "main-scene";
            scenes.visual_scene             = new CL.visual_scene[] { vscene };
            dae.scene                       = new CL.COLLADAScene();
            dae.scene.instance_visual_scene = new CL.InstanceWithExtra()
            {
                url = "#main-scene"
            };
            var exported = ProcessModel(mdl, resources);

            geos.geometry = exported.Geometries.ToArray();
            mats.material = exported.Materials.Select((x) => new CL.material()
            {
                name            = x.Name,
                id              = x.Name + "-material",
                instance_effect = new CL.instance_effect()
                {
                    url = "#" + x.Name + "-effect"
                }
            }).ToArray();
            efx.effect = exported.Materials.Select((x) => new CL.effect()
            {
                id    = x.Name + "-effect",
                Items = new[]
                {
                    new CL.effectFx_profile_abstractProfile_COMMON()
                    {
                        technique = new CL.effectFx_profile_abstractProfile_COMMONTechnique()
                        {
                            id   = "common",
                            Item = new CL.effectFx_profile_abstractProfile_COMMONTechniquePhong()
                            {
                                ambient             = ColladaColor("ambient", Color4.Black),
                                emission            = ColladaColor("emmision", Color4.Black),
                                diffuse             = ColladaColor("diffuse", x.Dc),
                                specular            = ColladaColor("specular", new Color4(0.25f, 0.25f, 0.25f, 1f)),
                                shininess           = ColladaFloat("shininess", 50),
                                index_of_refraction = ColladaFloat("index_of_refraction", 1)
                            }
                        }
                    }
                }
            }).ToArray();
            var nodes = new List <CL.node>();

            for (int i = 0; i < exported.Geometries.Count; i++)
            {
                nodes.Add(exported.GetNode(i, Matrix4x4.Identity, mdl.Path));
            }
            vscene.node = nodes.ToArray();
            dae.Items   = new object[] { efx, mats, geos, scenes };
            using (var stream = File.Create(output))
                ColladaSupport.XML.Serialize(stream, dae);
        }