Exemplo n.º 1
0
        public static string ExportGeometry(ref SceneData sceneData, ref SceneMeshRenderer smr,
                                            ref SceneMesh mesh, string spaces)
        {
            string osgData = spaces + "useDisplayList TRUE\n"
                             + spaces + "useVertexBufferObjects FALSE\n";

            if (smr != null)
            {
                osgData += MaterialExporter.ExportStateSet(ref sceneData, ref smr, spaces);
            }
            osgData += ExportGeometryData(ref sceneData, ref mesh, spaces);
            return(osgData);
        }
Exemplo n.º 2
0
        public SceneData GetSceneData()
        {
            var sceneData = new SceneData();

            sceneData.name      = sceneName;
            sceneData.resources = BundleResource.GetObjectData();
            sceneData.hierarchy = new List <SceneGameObject>();

            foreach (var go in rootGameObjects)
            {
                sceneData.hierarchy.Add(go.GetObjectData());
            }
            return(sceneData);
        }
Exemplo n.º 3
0
        public static SceneData GenerateSceneData(bool onlySelected)
        {
            // reset the exporter in case there was an error, Unity doesn't cleanly load/unload editor assemblies
            reset();

            BundleScene.sceneName = Path.GetFileNameWithoutExtension(EditorSceneManager.GetActiveScene().name);
            BundleScene scene = BundleScene.TraverseScene(onlySelected);

            scene.Preprocess();
            scene.Process();
            scene.PostProcess();

            SceneData sceneData = scene.GetSceneData() as SceneData;

            reset();
            return(sceneData);
        }
Exemplo n.º 4
0
        public static string ExportParticle(ref SceneData sceneData, ref SceneParticleSystem sps, string spaces)
        {
            string osgData = spaces + "Duration " + sps.duration + "\n"
                             + spaces + "Playing " + sps.playingSpeed + " " + (sps.isLooping ? 1 : 0)
                             + " " + (sps.isAutoStarted ? 1 : 0) + "\n"
                             + spaces + "MaxParticles " + sps.maxParticles + "\n"
                             + spaces + "Gravity " + sps.gravity.x + " " + sps.gravity.y + " " + sps.gravity.z + "\n"
                             + spaces + "Rotation " + sps.rotation.x + " " + sps.rotation.y + " " + sps.rotation.z + "\n"
                             + spaces + "StartAttributes " + sps.startAttributes.x + " " + sps.startAttributes.y + " "
                             + sps.startAttributes.z + " " + sps.startAttributes.w + "\n"
                             + spaces + "StartColor " + sps.startColor.r + " " + sps.startColor.g + " "
                             + sps.startColor.b + " " + sps.startColor.a + "\n";

            for (int i = 0; i < sps.enabledModules.Length; ++i)
            {
                string moduleName = sps.enabledModules[i];
                osgData += spaces + moduleName + " {\n";
                if (moduleName == "Emission")
                {
                    osgData += spaces + "  Type " + sps.emissionType + "\n"
                               + spaces + "  Rate " + sps.emissionRate.Length + " {\n";
                    for (int j = 0; j < sps.emissionRate.Length; ++j)
                    {
                        Vector4 v = sps.emissionRate[j];
                        osgData += spaces + "    " + v.x + " " + v.y + " " + v.z + " " + v.w + "\n";
                    }
                    osgData += spaces + "  }\n";
                }
                else if (moduleName == "TextureSheetAnimation")
                {
                    osgData += spaces + "  Type " + sps.tsaAnimationType + "\n"
                               + spaces + "  Tiles " + sps.tsaNumTiles.x + " " + sps.tsaNumTiles.y + "\n"
                               + spaces + "  CycleCount " + sps.tsaCycleCount + "\n"
                               + spaces + "  FrameOverTime " + sps.tsaFrameOverTime.Length + " {\n";
                    for (int j = 0; j < sps.tsaFrameOverTime.Length; ++j)
                    {
                        Vector4 v = sps.tsaFrameOverTime[j];
                        osgData += spaces + "    " + v.x + " " + v.y + " " + v.z + " " + v.w + "\n";
                    }
                    osgData += spaces + "  }\n";
                }
                else if (moduleName == "Renderer")
                {
                    osgData += spaces + "  ShapeMode " + sps.renderShapeMode + "\n"
                               + spaces + "  SortMode " + sps.renderSortMode + "\n"
                               + spaces + "  Attributes " + sps.renderAttributes.x + " " + sps.renderAttributes.y + " "
                               + sps.renderAttributes.z + " " + sps.renderAttributes.w + "\n";

                    SceneMaterial material = sceneData.resources.GetMaterial(sps.renderMaterial);
                    osgData += spaces + "  Material " + material.textureIDs.Length + " {\n";
                    for (int j = 0; j < material.textureIDs.Length; ++j)
                    {
                        SceneTexture texture = sceneData.resources.GetTexture(material.textureIDs[j], false);
                        if (texture == null)
                        {
                            continue;
                        }

                        Vector4 off = material.textureTilingOffsets[j];
                        osgData += spaces + "    Texture" + j + " \"" + texture.name + "\""
                                   + " \"" + texture.path + "\"\n"
                                   + spaces + "    TilingOffset" + j + " " + off.x + " " + off.y
                                   + " " + off.z + " " + off.w + "\n";
                    }
                    osgData += spaces + "  }\n";
                }
                osgData += spaces + "}\n";
            }
            return(osgData);
        }
Exemplo n.º 5
0
        private static string ExportGeometryData(ref SceneData sceneData, ref SceneMesh mesh, string spaces)
        {
            // Add all primitive sets
            string osgData = spaces + "PrimitiveSets " + mesh.subMeshCount + " {\n";

            for (int i = 0; i < mesh.subMeshCount; ++i)
            {
                int numElements = mesh.triangles[i].Length;
                osgData += spaces + "  DrawElements" + (numElements < 65535 ? "UShort" : "UInt")
                           + " TRIANGLES " + numElements + " {\n";
                for (int j = 0; j < numElements; j += 3)
                {
                    osgData += spaces + "    " + mesh.triangles[i][j] + " "
                               + mesh.triangles[i][j + 1] + " " + mesh.triangles[i][j + 2] + "\n";
                }
                osgData += spaces + "  }\n";
            }
            osgData += spaces + "}\n";

            // Add all vertices
            osgData += spaces + "VertexArray Vec3Array " + mesh.vertexCount + " {\n";
            for (int i = 0; i < mesh.vertexCount; ++i)
            {
                Vector3 v = mesh.vertexPositions[i];
                osgData += spaces + "  " + v.x + " " + v.y + " " + v.z + "\n";
            }
            osgData += spaces + "}\n";

            // Add all normals
            if (mesh.vertexNormals.Length > 0)
            {
                osgData += spaces + "NormalBinding PER_VERTEX\n"
                           + spaces + "NormalArray Vec3Array " + mesh.vertexCount + " {\n";
                for (int i = 0; i < mesh.vertexCount; ++i)
                {
                    Vector3 v = mesh.vertexNormals[i];
                    osgData += spaces + "  " + v.x + " " + v.y + " " + v.z + "\n";
                }
                osgData += spaces + "}\n";
            }

            // Add all UVs
            if (mesh.vertexUV.Length > 0)
            {
                osgData += spaces + "TexCoordArray 0 Vec2Array " + mesh.vertexCount + " {\n";
                for (int i = 0; i < mesh.vertexCount; ++i)
                {
                    Vector2 v = mesh.vertexUV[i];
                    osgData += spaces + "  " + v.x + " " + v.y + "\n";
                }
                osgData += spaces + "}\n";
            }

            if (mesh.vertexUV2.Length > 0)
            {
                osgData += spaces + "TexCoordArray 1 Vec2Array " + mesh.vertexCount + " {\n";
                for (int i = 0; i < mesh.vertexCount; ++i)
                {
                    Vector2 v = mesh.vertexUV2[i];
                    osgData += spaces + "  " + v.x + " " + v.y + "\n";
                }
                osgData += spaces + "}\n";
            }

            // TODO: tangents & bones
            return(osgData);
        }
Exemplo n.º 6
0
        public static string ExportTerrain(ref SceneData sceneData, ref SceneTerrain st, string spaces)
        {
            string osgData = spaces + "Size " + st.size.x + " " + st.size.y + " " + st.size.z + "\n";

            // Handle heightmap data
            osgData += spaces + "HeightMap " + st.heightmapWidth + " " + st.heightmapHeight + " {\n";
            byte[] heightData            = System.Convert.FromBase64String(st.heightmapTexture.base64PNG);
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int y = 0; y < st.heightmapHeight; y++)
            {
                sb.Append(spaces + "  ");
                for (int x = 0; x < st.heightmapWidth; x++)
                {
                    int index = (y * st.heightmapWidth) + x;
                    sb.Append(System.BitConverter.ToSingle(heightData, index * 4) + " ");
                }
                sb.Append("\n");
            }
            osgData += sb.ToString() + spaces + "}\n";

            // Handle alphamap layers
            osgData += spaces + "AlphaMap " + st.alphamapWidth + " " + st.alphamapHeight
                       + " " + st.alphamapLayers + " {\n";
            byte[] alphaData = System.Convert.FromBase64String(st.alphamapTexture.base64PNG);
            System.Text.StringBuilder sb2 = new System.Text.StringBuilder();
            for (int i = 0; i < st.alphamapLayers; i++)
            {
                sb2.Append(spaces + "  Layer " + i + " {\n");
                for (int y = 0; y < st.alphamapHeight; y++)
                {
                    sb2.Append(spaces + "    ");
                    for (int x = 0; x < st.alphamapWidth; x++)
                    {
                        int index = i * (st.alphamapHeight * st.alphamapWidth) + (y * st.alphamapWidth) + x;
                        sb2.Append(System.BitConverter.ToSingle(alphaData, index * 4) + " ");
                    }
                    sb2.Append("\n");
                }
                sb2.Append(spaces + "  }\n");
            }
            osgData += sb2.ToString() + spaces + "}\n";

            // Handle all splat textures
            for (int i = 0; i < st.textureIDs.Length; i++)
            {
                int          texID   = st.textureIDs[i];
                SceneTexture texture = sceneData.resources.GetTexture(texID, false);
                if (texture == null)
                {
                    continue;
                }

                Vector4 off = st.textureTilingOffsets[i];
                osgData += spaces + "Splat" + i + " \"" + texture.name + "\""
                           + " \"" + texture.path + "\"\n";
                osgData += spaces + "SplatTilingOffset" + i + " "
                           + off.x + " " + off.y + " " + off.z + " " + off.w + "\n";
            }

            // Handle lightmaps
            if (st.lightmapIndex >= 0)
            {
                SceneTexture texture = sceneData.resources.lightmaps[st.lightmapIndex];
                if (texture != null)
                {
                    osgData += spaces + "Lightmap \"" + texture.name + "\""
                               + " \"" + texture.path + "\"\n";
                    osgData += spaces + "LightmapTilingOffset " + st.lightmapTilingOffset.x + " "
                               + st.lightmapTilingOffset.y + " " + st.lightmapTilingOffset.z + " "
                               + st.lightmapTilingOffset.w + "\n";
                }
            }
            return(osgData);
        }
Exemplo n.º 7
0
        private static string ExportHierarchy(ref SceneData sceneData, SceneGameObject gameObj,
                                              int indent, float progressStart, float progressAll)
        {
            int needGlobalNodeType = -1;

            if (gameObj.components.Count <= 0)
            {
                return("");
            }

            string osgData = "", osgSubData = "", spaces = "";

            for (int i = 0; i < indent; ++i)
            {
                spaces += " ";
            }

            // Check the main component type as the node type
            SceneComponent mainComponent = gameObj.components[0];

            if (mainComponent.type == "Transform")
            {
                SceneTransform st = (SceneTransform)mainComponent;
                osgData = spaces + "MatrixTransform {\n"
                          + spaces + "  referenceFrame RELATIVE\n"
                          + spaces + "  Matrix {\n";
                needGlobalNodeType = 0;

                // FIXME: hould convert left-handed to right-handed coordinates
                Matrix4x4 m = Matrix4x4.TRS(st.localPosition, st.localRotation, st.localScale);
                osgData += spaces + "    " + m[0, 0] + " " + m[1, 0] + " " + m[2, 0] + " " + m[3, 0] + "\n"
                           + spaces + "    " + m[0, 1] + " " + m[1, 1] + " " + m[2, 1] + " " + m[3, 1] + "\n"
                           + spaces + "    " + m[0, 2] + " " + m[1, 2] + " " + m[2, 2] + " " + m[3, 2] + "\n"
                           + spaces + "    " + m[0, 3] + " " + m[1, 3] + " " + m[2, 3] + " " + m[3, 3] + "\n"
                           + spaces + "  }\n";
            }
            else
            {
                Debug.LogWarning("[UnityToSceneBundle] Unknown main component type: " + mainComponent.type);
            }

            if (needGlobalNodeType < 0)
            {
                osgData = spaces + "Node {\n";
            }
            osgData += ExportCommonAttr(gameObj.name, spaces, true)
                       + spaces + "  num_children ";

            // Traverse all components to add them to main component type
            string subSpaces             = spaces + "    ";
            int    numChildren           = gameObj.children.Count;

            for (int i = 1; i < gameObj.components.Count; ++i)
            {
                SceneComponent component = gameObj.components[i];
                if (component.type == "Light")
                {
                    SceneLight sl = (SceneLight)component;
                    osgSubData += spaces + "  nwTools::LightData {\n"
                                  + subSpaces + "Type " + sl.lightType + "\n"
                                  + subSpaces + "Color " + sl.color.r + " " + sl.color.g + " " + sl.color.b + "\n"
                                  + subSpaces + "Range " + sl.range + "\n"
                                  + subSpaces + "Realtime " + (sl.realtime ? 1 : 0) + " " + (sl.castsShadows ? 1 : 0) + "\n"
                                  + spaces + "  }\n";
                    numChildren++;
                }
                else if (component.type == "Camera")
                {
                    SceneCamera sc = (SceneCamera)component;
                    osgSubData += spaces + "  nwTools::CameraData {\n"
                                  // TODO
                                  + spaces + "  }\n";
                    numChildren++;
                }
                else if (component.type == "BoxCollider")
                {
                    //SceneBoxCollider sbc = (SceneBoxCollider)component;
                    // TODO
                }
                else if (component.type == "MeshCollider")
                {
                    //SceneMeshCollider smc = (SceneMeshCollider)component;
                    // TODO
                }
                else if (component.type == "ParticleSystem")
                {
                    SceneParticleSystem sps = (SceneParticleSystem)component;
                    osgSubData += spaces + "  nwTools::ParticleSystem {\n"
                                  + ExportCommonAttr(sps.type, spaces + "  ", false)
                                  + ParticleExporter.ExportParticle(ref sceneData, ref sps, subSpaces)
                                  + spaces + "  }\n";
                    numChildren++;
                }
                else if (component.type == "Terrain")
                {
                    SceneTerrain st = (SceneTerrain)component;
                    osgSubData += spaces + "  Geode {\n"
                                  + ExportCommonAttr(st.type, spaces + "  ", true)
                                  + subSpaces + "num_drawables 1\n";
                    osgSubData += subSpaces + "nwTools::Terrain {\n"
                                  + TerrainExporter.ExportTerrain(ref sceneData, ref st, subSpaces + "  ")
                                  + subSpaces + "}\n";
                    osgSubData += spaces + "  }\n";
                    numChildren++;
                }
                else if (component.type == "MeshRenderer")
                {
                    SceneMeshRenderer smr = (SceneMeshRenderer)component;
                    osgSubData += spaces + "  Geode {\n"
                                  + ExportCommonAttr(smr.type, spaces + "  ", true)
                                  + subSpaces + "num_drawables 1\n";

                    SceneMesh mesh = sceneData.resources.GetMesh(smr.mesh);
                    osgSubData += subSpaces + "Geometry {\n"
                                  + MeshExporter.ExportGeometry(ref sceneData, ref smr, ref mesh, subSpaces + "  ")
                                  + subSpaces + "}\n";
                    osgSubData += spaces + "  }\n";
                    numChildren++;
                }
                else if (component.type == "SkinnedMeshRenderer")
                {
                    SceneSkinnedMeshRenderer smr = (SceneSkinnedMeshRenderer)component;
                    osgSubData += spaces + "  Geode {\n"
                                  + ExportCommonAttr(smr.type, spaces + "  ", true)
                                  + subSpaces + "num_drawables 1\n";

                    SceneMesh mesh = sceneData.resources.GetMesh(smr.mesh);
                    osgSubData += subSpaces + "Geometry {\n"
                                  + MeshExporter.ExportSkinnedGeometry(ref sceneData, ref smr, ref mesh, subSpaces + "  ")
                                  + subSpaces + "}\n";
                    osgSubData += spaces + "  }\n";
                    numChildren++;
                }
                else
                {
                    Debug.LogWarning("[UnityToSceneBundle] Unknown sub-component type: " + component.type);
                }
            }
            osgData += numChildren + "\n" + osgSubData;

            // Traverse all child objects
            float numHierarchy = (float)gameObj.children.Count, numDone = 0.0f;

            foreach (SceneGameObject childObj in gameObj.children)
            {
                osgData += ExportHierarchy(ref sceneData, childObj, indent + 2, 0.0f, 0.0f); numDone += 1.0f;
                if (progressAll > 0.0f)
                {
                    float progress = (progressStart + numDone / numHierarchy) / progressAll;
                    EditorUtility.DisplayProgressBar("Scene Bundler", "Exporting hierarchy...", progress);
                }
            }
            osgData += spaces + "}\n";
            return(osgData);
        }
Exemplo n.º 8
0
        public static string ExportStateSet(ref SceneData sceneData, ref SceneMeshRenderer smr, string spaces)
        {
            string osgData = spaces + "StateSet {\n" + ExportStateSetAttr(false, spaces);

            for (int i = 0; i < smr.materials.Length; ++i)
            {
                SceneMaterial material = sceneData.resources.GetMaterial(smr.materials[i]);
                if (material.textureIDs == null)
                {
                    continue;
                }

                string shaderData = spaces + "  nwTools::ShaderData {\n"
                                    + spaces + "    ShaderName \"" + material.shader + "\"\n";
                for (int j = 0; j < material.textureIDs.Length; ++j)
                {
                    int          texID = material.textureIDs[j], unit = material.textureUnits[j];
                    SceneTexture texture = sceneData.resources.GetTexture(texID, false);
                    if (texture == null || unit < 0)
                    {
                        continue;
                    }

                    shaderData += spaces + "    Texture" + unit + " \"" + texture.name + "\""
                                  + " \"" + texture.path + "\"\n";
                    if (i > 0)
                    {
                        continue;     // For multi-material case, record more materials to ShaderData
                    }
                    // Handle texture tiling and offset
                    osgData += spaces + "  textureUnit " + unit + " {\n"
                               + spaces + "    GL_TEXTURE_2D ON\n";
                    if (material.textureTilingOffsets[j] != indentityTilingOffsetVector)
                    {
                        Vector4   off = material.textureTilingOffsets[j];
                        Matrix4x4 m   = Matrix4x4.TRS(new Vector3(off.z, off.w, 0.0f), Quaternion.identity,
                                                      new Vector3(off.x, off.y, 1.0f));
                        osgData += spaces + "    TexMat {\n"
                                   + spaces + "      " + m[0, 0] + " " + m[1, 0] + " " + m[2, 0] + " " + m[3, 0] + "\n"
                                   + spaces + "      " + m[0, 1] + " " + m[1, 1] + " " + m[2, 1] + " " + m[3, 1] + "\n"
                                   + spaces + "      " + m[0, 2] + " " + m[1, 2] + " " + m[2, 2] + " " + m[3, 2] + "\n"
                                   + spaces + "      " + m[0, 3] + " " + m[1, 3] + " " + m[2, 3] + " " + m[3, 3] + "\n"
                                   + spaces + "    }\n";
                    }

                    // Handle texture
                    if (sharedTextureNames.ContainsKey(texID))
                    {
                        osgData += spaces + "    Use " + sharedTextureNames[texID] + "\n";
                    }
                    else
                    {
                        sharedTextureNames[texID] = "Texture_" + texID;
                        osgData += spaces + "    Texture2D {\n"
                                   + spaces + "      UniqueID Texture_" + texID + "\n"
                                   + ExportTextureAttr(ref texture, spaces + "    ")
                                   + spaces + "    }\n";
                    }
                    osgData += spaces + "  }\n";
                }

                // Save shader data for use
                if (material.shaderKeywords != null)
                {
                    shaderData += spaces + "    Keywords ";
                    for (int k = 0; k < material.shaderKeywords.Length; ++k)
                    {
                        shaderData += material.shaderKeywords[k]
                                      + ((k < material.shaderKeywords.Length - 1) ? " " : "\n");
                    }
                }
                osgData += shaderData + spaces + "  }\n";
            }

            // Handle lightmaps
            if (smr.lightmapIndex >= 0)
            {
                SceneTexture texture = sceneData.resources.lightmaps[smr.lightmapIndex];
                if (texture != null)
                {
                    osgData += spaces + "  textureUnit 1 {\n" // FIXME: always 1?
                               + spaces + "    GL_TEXTURE_2D ON\n";

                    // Handle lightmap tiling and offset
                    if (smr.lightmapTilingOffset != indentityTilingOffsetVector)
                    {
                        Vector4   off = smr.lightmapTilingOffset;
                        Matrix4x4 m   = Matrix4x4.TRS(new Vector3(off.z, off.w, 0.0f), Quaternion.identity,
                                                      new Vector3(off.x, off.y, 1.0f));
                        osgData += spaces + "    TexMat {\n"
                                   + spaces + "      " + m[0, 0] + " " + m[1, 0] + " " + m[2, 0] + " " + m[3, 0] + "\n"
                                   + spaces + "      " + m[0, 1] + " " + m[1, 1] + " " + m[2, 1] + " " + m[3, 1] + "\n"
                                   + spaces + "      " + m[0, 2] + " " + m[1, 2] + " " + m[2, 2] + " " + m[3, 2] + "\n"
                                   + spaces + "      " + m[0, 3] + " " + m[1, 3] + " " + m[2, 3] + " " + m[3, 3] + "\n"
                                   + spaces + "    }\n";
                    }

                    // Handle texture
                    if (sharedTextureNames.ContainsKey(texture.uniqueID))
                    {
                        osgData += spaces + "    Use " + sharedTextureNames[texture.uniqueID] + "\n";
                    }
                    else
                    {
                        sharedTextureNames[texture.uniqueID] = "Texture_" + texture.uniqueID;
                        osgData += spaces + "    Texture2D {\n"
                                   + spaces + "      UniqueID Texture_" + texture.uniqueID + "\n"
                                   + ExportTextureAttr(ref texture, spaces + "    ")
                                   + spaces + "    }\n";
                    }
                    osgData += spaces + "  }\n";
                }
            }
            osgData += spaces + "}\n";
            return(osgData);
        }