コード例 #1
0
        public override SceneComponent GetObjectData()
        {
            var sceneData = new SceneLight();

            sceneData.type         = "Light";
            sceneData.lightType    = "Point";
            sceneData.color        = unityLight.color;
            sceneData.range        = unityLight.range;
            sceneData.castsShadows = (unityLight.shadows != LightShadows.None);
            sceneData.realtime     = true;

            SerializedObject   serial       = new SerializedObject(unityLight);
            SerializedProperty lightmapProp = serial.FindProperty("m_Lightmapping");

            if (lightmapProp.intValue != 0)
            {
                // not a realtime light
                sceneData.realtime = false;
            }
            return(sceneData);
        }
コード例 #2
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);
        }