예제 #1
0
        public new SceneMaterial GetObjectData()
        {
            var sceneData = new SceneMaterial();

            sceneData.name        = name;
            sceneData.shader      = shader.name;
            sceneData.passCount   = unityMaterial.passCount;
            sceneData.renderQueue = unityMaterial.renderQueue;

            if (textures.Count > 0)
            {
                sceneData.textureIDs = new int[textures.Count];
                for (int i = 0; i < textures.Count; i++)
                {
                    sceneData.textureIDs[i] = textures[i].uniqueID;
                }

                sceneData.textureUnits = new int[textureUnits.Count];
                for (int i = 0; i < textureUnits.Count; i++)
                {
                    sceneData.textureUnits[i] = textureUnits[i];
                }

                sceneData.textureTilingOffsets = new Vector4[textureUnits.Count];
                for (int i = 0; i < textureUnits.Count; i++)
                {
                    Vector2 sc = textureScales[i], of = textureOffsets[i];
                    sceneData.textureTilingOffsets[i] = new Vector4(sc.x, sc.y, of.x, of.y);
                }
            }

            if (unityMaterial.shaderKeywords.Length > 0)
            {
                sceneData.shaderKeywords = new string[unityMaterial.shaderKeywords.Length];
                for (int i = 0; i < unityMaterial.shaderKeywords.Length; i++)
                {
                    sceneData.shaderKeywords[i] = unityMaterial.shaderKeywords[i];
                }
            }
            //sceneData.color = unityMaterial.color;
            return(sceneData);
        }
예제 #2
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);
        }
예제 #3
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);
        }