Inheritance: GlTF_Writer
    // This does once-per-light work, as well as once-per-material-per-light work.
    // So this ends up being called multiple times with the same parameters, except
    // for matObjName.
    // matObjName is the name of the material being exported
    // lightObjectName is the name of the light
    public void ExportLight(LightPayload payload, IExportableMaterial exportableMaterial)
    {
        ObjectName lightNodeName = new ObjectName(payload.legacyUniqueName); // does need to be unique

        // Add the light to the scene -- this does _not_ need to be done per-material.
        // As a result, the node will generally have already been created.
        GlTF_Node node = GlTF_Node.GetOrCreate(G, lightNodeName, payload.xform, null, out _);

        node.lightNameThatDoesNothing = payload.name;

        // The names of the uniforms can be anything, really. Named after the light is the most
        // logical choice, but note that nobody checks that two lights don't have the same name.
        // Thankfully for Tilt Brush, they don't.
        // This should probably have used a guaranteed-unique name from the start but I don't want
        // to change it now because it'd break my diffs and be kind of ugly.
        string lightUniformPrefix = payload.name;

        AddUniform(exportableMaterial, lightUniformPrefix + "_matrix",
                   GlTF_Technique.Type.FLOAT_MAT4, GlTF_Technique.Semantic.MODELVIEW, node);

        // Add light color.
        GlTF_Material mtl = G.materials[exportableMaterial];
        var           val = new GlTF_Material.ColorKV {
            key   = lightUniformPrefix + "_color",
            color = payload.lightColor
        };

        mtl.values.Add(val);
        AddUniform(exportableMaterial, val.key,
                   GlTF_Technique.Type.FLOAT_VEC4, GlTF_Technique.Semantic.UNKNOWN, node);
    }
示例#2
0
 // Public only for use by GlTF_Globals
 public GlTF_Material(GlTF_Globals globals, IExportableMaterial exportableMaterial)
     : base(globals)
 {
     this.ExportableMaterial = exportableMaterial;
     this.name = GlTF_Material.GetNameFromObject(exportableMaterial);
     // PresentationNameOverride is set by GlTF_Globals in order to make it unique-ish
 }
    // Adds material and sets up its dependent technique, program, shaders. This should be called
    // after adding meshes, but before populating lights, textures, etc.
    // Pass:
    //   hack - attributes of some mesh that uses this material
    public void AddMaterialWithDependencies(
        IExportableMaterial exportableMaterial,
        string meshNamespace,
        GlTF_Attributes hack)
    {
        GlTF_Material gltfMtl = G.CreateMaterial(meshNamespace, exportableMaterial);

        // Set up technique.
        GlTF_Technique tech = GlTF_Writer.CreateTechnique(G, exportableMaterial);

        gltfMtl.instanceTechniqueName = tech.name;
        GlTF_Technique.States states = null;
        if (m_techniqueStates.ContainsKey(exportableMaterial))
        {
            states = m_techniqueStates[exportableMaterial];
        }

        if (states == null)
        {
            // Unless otherwise specified the preset, enable z-buffering.
            states        = new GlTF_Technique.States();
            states.enable = new[] { GlTF_Technique.Enable.DEPTH_TEST }.ToList();
        }
        tech.states = states;
        AddAllAttributes(tech, exportableMaterial, hack);
        tech.AddDefaultUniforms(G.RTCCenter != null);

        // Add program.
        GlTF_Program program = new GlTF_Program(G);

        program.name = GlTF_Program.GetNameFromObject(exportableMaterial);
        tech.program = program.name;
        foreach (var attr in tech.attributes)
        {
            program.attributes.Add(attr.name);
        }
        G.programs.Add(program);

        // Add vertex and fragment shaders.
        GlTF_Shader vertShader = new GlTF_Shader(G);

        vertShader.name      = GlTF_Shader.GetNameFromObject(exportableMaterial, GlTF_Shader.Type.Vertex);
        program.vertexShader = vertShader.name;
        vertShader.type      = GlTF_Shader.Type.Vertex;
        vertShader.uri       = ExportFileReference.CreateHttp(exportableMaterial.VertShaderUri);
        G.shaders.Add(vertShader);

        GlTF_Shader fragShader = new GlTF_Shader(G);

        fragShader.name        = GlTF_Shader.GetNameFromObject(exportableMaterial, GlTF_Shader.Type.Fragment);
        program.fragmentShader = fragShader.name;
        fragShader.type        = GlTF_Shader.Type.Fragment;
        fragShader.uri         = ExportFileReference.CreateHttp(exportableMaterial.FragShaderUri);
        G.shaders.Add(fragShader);
    }
    // Should be called per material.
    public void ExportAmbientLight(IExportableMaterial exportableMaterial, Color color)
    {
        GlTF_Material mtl = G.materials[exportableMaterial];
        var           val = new GlTF_Material.ColorKV {
            key   = "ambient_light_color",
            color = color
        };

        mtl.values.Add(val);
        AddUniform(exportableMaterial, val.key,
                   GlTF_Technique.Type.FLOAT_VEC4, GlTF_Technique.Semantic.UNKNOWN);
    }
    // Export a single shader vector uniform
    public void ExportShaderUniform(
        IExportableMaterial exportableMaterial, string name, Vector4 value)
    {
        GlTF_Material mtl     = G.materials[exportableMaterial];
        var           vec_val = new GlTF_Material.VectorKV {
            key = name, vector = value
        };

        mtl.values.Add(vec_val);
        AddUniform(exportableMaterial, vec_val.key,
                   GlTF_Technique.Type.FLOAT_VEC4, GlTF_Technique.Semantic.UNKNOWN);
    }
    // Export a single shader float uniform
    public void ExportShaderUniform(
        IExportableMaterial exportableMaterial, string name, float value)
    {
        GlTF_Material mtl       = G.materials[exportableMaterial];
        var           float_val = new GlTF_Material.FloatKV {
            key   = name,
            value = value
        };

        mtl.values.Add(float_val);
        AddUniform(exportableMaterial, float_val.key,
                   GlTF_Technique.Type.FLOAT, GlTF_Technique.Semantic.UNKNOWN);
    }
    /// Adds a texture parameter + uniform to the specified material.
    /// As a side effect, auto-creates textures, images, and maybe a sampler if necessary.
    /// Pass:
    ///   matObjName - the material
    ///   texParam - name of the material parameter to add
    ///   fileRef - file containing texture data
    public void AddTextureToMaterial(
        IExportableMaterial exportableMaterial, string texParam, ExportFileReference fileRef)
    {
        GlTF_Material material = G.materials[exportableMaterial];

        GlTF_Sampler sampler = GlTF_Sampler.LookupOrCreate(
            G, GlTF_Sampler.MagFilter.LINEAR, GlTF_Sampler.MinFilter.LINEAR_MIPMAP_LINEAR);

        // The names only matter for gltf1, so keep them similar for easier diffing.
        // Essentially, this names the image and texture after the first material that wanted them.
        string matNameAndParam = $"{exportableMaterial.UniqueName:D}_{texParam}";
        var    img             = GlTF_Image.LookupOrCreate(G, fileRef, proposedName: matNameAndParam);
        var    tex             = GlTF_Texture.LookupOrCreate(G, img, sampler, proposedName: matNameAndParam);

        material.values.Add(new GlTF_Material.TextureKV(key: texParam, texture: tex));

        // Add texture-related parameter and uniform.
        AddUniform(exportableMaterial,
                   texParam, GlTF_Technique.Type.SAMPLER_2D, GlTF_Technique.Semantic.UNKNOWN, null);
    }
示例#8
0
    private bool handleTransparency(ref Material mat, ref GlTF_Material material)
    {
        if (mat.HasProperty("_Mode") && mat.GetFloat("_Mode") != 0)
        {
            string mode = mat.GetFloat("_Mode") == 1 ? "MASK" : "BLEND";
            GlTF_Material.StringValue alphaMode = new GlTF_Material.StringValue();
            alphaMode.name  = "alphaMode";
            alphaMode.value = mode;

            GlTF_Material.FloatValue alphaCutoff = new GlTF_Material.FloatValue();
            alphaCutoff.name  = "alphaCutoff";
            alphaCutoff.value = mat.GetFloat("_Cutoff");

            material.values.Add(alphaMode);
            material.values.Add(alphaCutoff);

            return(true);
        }

        return(false);
    }
    // Adds to gltfMesh the glTF dependencies (primitive, material, technique, program, shaders)
    // required by unityMesh, using matObjName for naming the various material-related glTF
    // components. This does not add any geometry from the mesh (that's done separately using
    // GlTF_Mesh.Populate()).
    //
    // This does not create the material either. It adds a reference to a material that
    // presumably will be created very soon (if it hasn't previously been created).
    private void AddMeshDependencies(
        ObjectName meshName, IExportableMaterial exportableMaterial, GlTF_Mesh gltfMesh,
        GlTF_VertexLayout gltfLayout)
    {
        GlTF_Primitive primitive = new GlTF_Primitive(
            new GlTF_Attributes(G, meshName, gltfLayout));

        GlTF_Accessor indexAccessor = G.CreateAccessor(
            GlTF_Accessor.GetNameFromObject(meshName, "indices_0"),
            GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.USHORT,
            isNonVertexAttributeAccessor: true);

        primitive.indices = indexAccessor;
        if (gltfMesh.primitives.Count > 0)
        {
            Debug.LogError("More than one primitive per mesh is unimplemented and unsupported");
        }
        gltfMesh.primitives.Add(primitive);

        // This needs to be a forward-reference (ie, by name) because G.materials[exportableMaterial]
        // may not have been created yet.
        primitive.materialName = GlTF_Material.GetNameFromObject(exportableMaterial);
    }
示例#10
0
    // Convert material from Unity to glTF PBR
    private void unityToPBRMaterial(Material mat, ref GlTF_Material material)
    {
        bool isMaterialPBR = true;
        bool isMetal       = true;
        bool hasPBRMap     = false;

        if (!mat.shader.name.Contains("Standard"))
        {
            Debug.Log("Material " + mat.shader + " is not fully supported");
            isMaterialPBR = false;
        }
        else
        {
            // Is metal workflow used
            isMetal = mat.shader.name == "Standard";
            GlTF_Writer.hasSpecularMaterials = GlTF_Writer.hasSpecularMaterials || !isMetal;
            material.isMetal = isMetal;

            // Is smoothness defined by diffuse texture or PBR texture' alpha?
            if (mat.GetFloat("_SmoothnessTextureChannel") != 0)
            {
                Debug.Log("Smoothness uses diffuse's alpha channel. Unsupported for now");
            }

            hasPBRMap = (!isMetal && mat.GetTexture("_SpecGlossMap") != null || isMetal && mat.GetTexture("_MetallicGlossMap") != null);
        }

        //Check transparency
        bool hasTransparency = handleTransparency(ref mat, ref material);

        //Parse diffuse channel texture and color
        if (mat.HasProperty("_MainTex") && mat.GetTexture("_MainTex") != null)
        {
            var textureValue = new GlTF_Material.DictValue();
            textureValue.name = isMetal ? "baseColorTexture" : "diffuseTexture";

            int diffuseTextureIndex = processTexture((Texture2D)mat.GetTexture("_MainTex"), hasTransparency ? IMAGETYPE.RGBA : IMAGETYPE.RGBA_OPAQUE);
            textureValue.intValue.Add("index", diffuseTextureIndex);
            textureValue.intValue.Add("texCoord", 0);
            material.pbrValues.Add(textureValue);
        }

        if (mat.HasProperty("_Color"))
        {
            var colorValue = new GlTF_Material.ColorValue();
            colorValue.name = isMetal ? "baseColorFactor" : "diffuseFactor";
            Color c = mat.GetColor("_Color");
            clampColor(ref c);
            colorValue.color = c;
            material.pbrValues.Add(colorValue);
        }

        //Parse PBR textures
        if (isMaterialPBR)
        {
            if (isMetal)
            {
                if (hasPBRMap)                 // No metallic factor if texture
                {
                    var textureValue = new GlTF_Material.DictValue();
                    textureValue.name = "metallicRoughnessTexture";
                    Texture2D metallicRoughnessTexture = (Texture2D)mat.GetTexture("_MetallicGlossMap");
                    Texture2D occlusion = (Texture2D)mat.GetTexture("_OcclusionMap");
                    int       metalRoughTextureIndex = createOcclusionMetallicRoughnessTexture(ref occlusion, ref metallicRoughnessTexture);
                    textureValue.intValue.Add("index", metalRoughTextureIndex);
                    textureValue.intValue.Add("texCoord", 0);
                    material.pbrValues.Add(textureValue);
                }

                var metallicFactor = new GlTF_Material.FloatValue();
                metallicFactor.name  = "metallicFactor";
                metallicFactor.value = hasPBRMap ? 1.0f : mat.GetFloat("_Metallic");
                material.pbrValues.Add(metallicFactor);

                //Roughness factor
                var roughnessFactor = new GlTF_Material.FloatValue();
                roughnessFactor.name  = "roughnessFactor";
                roughnessFactor.value = hasPBRMap ? 1.0f : 1 - mat.GetFloat("_Glossiness");                 // gloss scale is not supported for now(property _GlossMapScale)
                material.pbrValues.Add(roughnessFactor);
            }
            else
            {
                if (hasPBRMap)                 // No metallic factor if texture
                {
                    var textureValue = new GlTF_Material.DictValue();
                    textureValue.name = "specularGlossinessTexture";
                    int specGlossTextureIndex = processTexture((Texture2D)mat.GetTexture("_SpecGlossMap"), IMAGETYPE.RGBA);
                    textureValue.intValue.Add("index", specGlossTextureIndex);
                    textureValue.intValue.Add("texCoord", 0);
                    material.pbrValues.Add(textureValue);
                }

                var specularFactor = new GlTF_Material.ColorValue();
                specularFactor.name  = "specularFactor";
                specularFactor.color = hasPBRMap ? Color.white : mat.GetColor("_SpecColor");                 // gloss scale is not supported for now(property _GlossMapScale)
                specularFactor.isRGB = true;
                material.pbrValues.Add(specularFactor);

                var glossinessFactor = new GlTF_Material.FloatValue();
                glossinessFactor.name  = "glossinessFactor";
                glossinessFactor.value = hasPBRMap ? 1.0f : mat.GetFloat("_Glossiness");                 // gloss scale is not supported for now(property _GlossMapScale)
                material.pbrValues.Add(glossinessFactor);
            }
        }

        //BumpMap
        if (mat.HasProperty("_BumpMap") && mat.GetTexture("_BumpMap") != null)
        {
            Texture2D bumpTexture = mat.GetTexture("_BumpMap") as Texture2D;
            // Check if it's a normal or a bump map
            TextureImporter im        = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(bumpTexture)) as TextureImporter;
            bool            isBumpMap = im.convertToNormalmap;

            if (isBumpMap)
            {
                Debug.LogWarning("Unsupported texture " + bumpTexture + " (normal maps generated from grayscale are not supported)");
            }
            else
            {
                var textureValue = new GlTF_Material.DictValue();
                textureValue.name = "normalTexture";

                int bumpTextureIndex = processTexture(bumpTexture, IMAGETYPE.NORMAL_MAP);
                textureValue.intValue.Add("index", bumpTextureIndex);
                textureValue.intValue.Add("texCoord", 0);
                textureValue.floatValue.Add("scale", mat.GetFloat("_BumpScale"));
                material.values.Add(textureValue);
            }
        }

        //Emissive
        if (mat.HasProperty("_EmissionMap") && mat.GetTexture("_EmissionMap") != null)
        {
            Texture2D emissiveTexture = mat.GetTexture("_EmissionMap") as Texture2D;
            var       textureValue    = new GlTF_Material.DictValue();
            textureValue.name = "emissiveTexture";

            int emissiveTextureIndex = processTexture(emissiveTexture, IMAGETYPE.RGB);
            textureValue.intValue.Add("index", emissiveTextureIndex);
            textureValue.intValue.Add("texCoord", 0);
            material.values.Add(textureValue);
        }

        var emissiveFactor = new GlTF_Material.ColorValue();

        emissiveFactor.name  = "emissiveFactor";
        emissiveFactor.isRGB = true;
        emissiveFactor.color = mat.GetColor("_EmissionColor");
        material.values.Add(emissiveFactor);

        //Occlusion (kept as separated channel for specular workflow, but merged in R channel for metallic workflow)
        if (mat.HasProperty("_OcclusionMap") && mat.GetTexture("_OcclusionMap") != null)
        {
            Texture2D occlusionTexture = mat.GetTexture("_OcclusionMap") as Texture2D;
            var       textureValue     = new GlTF_Material.DictValue();
            textureValue.name = "occlusionTexture";

            int occlusionTextureIndex = processTexture(occlusionTexture, IMAGETYPE.RGB);
            textureValue.intValue.Add("index", occlusionTextureIndex);
            textureValue.intValue.Add("texCoord", 0);
            textureValue.floatValue.Add("strength", mat.GetFloat("_OcclusionStrength"));
            material.values.Add(textureValue);
        }

        // Unity materials are single sided by default
        GlTF_Material.BoolValue doubleSided = new GlTF_Material.BoolValue();
        doubleSided.name  = "doubleSided";
        doubleSided.value = false;
        material.values.Add(doubleSided);
    }
示例#11
0
    public IEnumerator Export(string path, Preset presetAsset, bool buildZip, bool exportPBRMaterials, bool exportAnimation = true, bool doConvertImages = false)
    {
        writer = new GlTF_Writer();
        writer.Init();
        done = false;
        bool debugRightHandedScale = false;

        GlTF_Writer.exportedFiles.Clear();
        if (debugRightHandedScale)
        {
            GlTF_Writer.convertRightHanded = false;
        }

        writer.extraString.Add("exporterVersion", GlTF_Writer.exporterVersion);

        // Create rootNode
        GlTF_Node correctionNode = new GlTF_Node();

        correctionNode.id   = "UnityGlTF_root";
        correctionNode.name = "UnityGlTF_root";
        GlTF_Writer.nodes.Add(correctionNode);
        GlTF_Writer.nodeNames.Add(correctionNode.name);
        GlTF_Writer.rootNodes.Add(correctionNode);

        //path = toGlTFname(path);
        savedPath = Path.GetDirectoryName(path);

        // Temp list to keep track of skeletons
        Dictionary <string, GlTF_Skin> parsedSkins = new Dictionary <string, GlTF_Skin>();

        parsedSkins.Clear();

        // first, collect objects in the scene, add to lists
        Transform[]      transforms = Selection.GetTransforms(SelectionMode.Deep);
        List <Transform> trs        = new List <Transform>(transforms);
        // Prefilter selected nodes and look for skinning in order to list "bones" nodes
        //FIXME: improve this
        List <Transform> bones = new List <Transform>();

        foreach (Transform tr in trs)
        {
            if (!tr.gameObject.activeSelf)
            {
                continue;
            }

            SkinnedMeshRenderer skin = tr.GetComponent <SkinnedMeshRenderer>();
            if (skin)
            {
                foreach (Transform bone in skin.bones)
                {
                    bones.Add(bone);
                }
            }
        }

        nbSelectedObjects = trs.Count;
        int nbDisabledObjects = 0;

        foreach (Transform tr in trs)
        {
            if (tr.gameObject.activeInHierarchy == false)
            {
                nbDisabledObjects++;
                continue;
            }

            // Initialize the node
            GlTF_Node node = new GlTF_Node();
            node.id   = GlTF_Node.GetNameFromObject(tr);
            node.name = GlTF_Writer.cleanNonAlphanumeric(tr.name);

            if (tr.GetComponent <Camera>() != null)
            {
                parseUnityCamera(tr);
            }

            if (tr.GetComponent <Light>() != null)
            {
                parseUnityLight(tr);
            }

            Mesh m = GetMesh(tr);
            if (m != null)
            {
                GlTF_Mesh mesh = new GlTF_Mesh();
                mesh.name = GlTF_Writer.cleanNonAlphanumeric(GlTF_Mesh.GetNameFromObject(m) + tr.name);

                GlTF_Accessor positionAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "position"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
                positionAccessor.bufferView = GlTF_Writer.vec3BufferView;
                GlTF_Writer.accessors.Add(positionAccessor);

                GlTF_Accessor normalAccessor = null;
                if (m.normals.Length > 0)
                {
                    normalAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "normal"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
                    normalAccessor.bufferView = GlTF_Writer.vec3BufferView;
                    GlTF_Writer.accessors.Add(normalAccessor);
                }

                GlTF_Accessor colorAccessor = null;
                if (m.colors.Length > 0)
                {
                    colorAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "color"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
                    colorAccessor.bufferView = GlTF_Writer.vec4BufferView;
                    GlTF_Writer.accessors.Add(colorAccessor);
                }

                GlTF_Accessor uv0Accessor = null;
                if (m.uv.Length > 0)
                {
                    uv0Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv0"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv0Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv0Accessor);
                }

                GlTF_Accessor uv1Accessor = null;
                if (m.uv2.Length > 0)
                {
                    // check if object is affected by a lightmap
                    uv1Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv1"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv1Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv1Accessor);
                }

                GlTF_Accessor uv2Accessor = null;
                if (m.uv3.Length > 0)
                {
                    uv2Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv2"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv2Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv2Accessor);
                }

                GlTF_Accessor uv3Accessor = null;
                if (m.uv4.Length > 0)
                {
                    uv3Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv3"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv3Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv3Accessor);
                }

                GlTF_Accessor jointAccessor = null;
                if (exportAnimation && m.boneWeights.Length > 0)
                {
                    jointAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "joints"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.USHORT);
                    jointAccessor.bufferView = GlTF_Writer.vec4UshortBufferView;
                    GlTF_Writer.accessors.Add(jointAccessor);
                }

                GlTF_Accessor weightAccessor = null;
                if (exportAnimation && m.boneWeights.Length > 0)
                {
                    weightAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "weights"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
                    weightAccessor.bufferView = GlTF_Writer.vec4BufferView;
                    GlTF_Writer.accessors.Add(weightAccessor);
                }

                GlTF_Accessor tangentAccessor = null;
                if (m.tangents.Length > 0)
                {
                    tangentAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "tangents"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
                    tangentAccessor.bufferView = GlTF_Writer.vec4BufferView;
                    GlTF_Writer.accessors.Add(tangentAccessor);
                }

                var smCount = m.subMeshCount;
                for (var i = 0; i < smCount; ++i)
                {
                    GlTF_Primitive primitive = new GlTF_Primitive();
                    primitive.name  = GlTF_Primitive.GetNameFromObject(m, i);
                    primitive.index = i;
                    GlTF_Attributes attributes = new GlTF_Attributes();
                    attributes.positionAccessor  = positionAccessor;
                    attributes.normalAccessor    = normalAccessor;
                    attributes.colorAccessor     = colorAccessor;
                    attributes.texCoord0Accessor = uv0Accessor;
                    attributes.texCoord1Accessor = uv1Accessor;
                    attributes.texCoord2Accessor = uv2Accessor;
                    attributes.texCoord3Accessor = uv3Accessor;
                    attributes.jointAccessor     = jointAccessor;
                    attributes.weightAccessor    = weightAccessor;
                    attributes.tangentAccessor   = tangentAccessor;
                    primitive.attributes         = attributes;
                    GlTF_Accessor indexAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "indices_" + i), GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.USHORT);
                    indexAccessor.bufferView = GlTF_Writer.ushortBufferView;
                    GlTF_Writer.accessors.Add(indexAccessor);
                    primitive.indices = indexAccessor;

                    var mr = GetRenderer(tr);
                    var sm = mr.sharedMaterials;
                    if (i < sm.Length)
                    {
                        var mat     = sm[i];
                        var matName = GlTF_Material.GetNameFromObject(mat);
                        if (GlTF_Writer.materialNames.Contains(matName))
                        {
                            primitive.materialIndex = GlTF_Writer.materialNames.IndexOf(matName);                             // THIS INDIRECTION CAN BE REMOVED!
                        }
                        else
                        {
                            GlTF_Material material = new GlTF_Material();
                            material.name           = GlTF_Writer.cleanNonAlphanumeric(mat.name);
                            primitive.materialIndex = GlTF_Writer.materials.Count;
                            GlTF_Writer.materialNames.Add(matName);
                            GlTF_Writer.materials.Add(material);

                            //technique
                            var s        = mat.shader;
                            var techName = GlTF_Technique.GetNameFromObject(s);
                            if (GlTF_Writer.techniqueNames.Contains(techName))
                            {
                                material.instanceTechniqueIndex = GlTF_Writer.techniqueNames.IndexOf(techName);                                // THIS INDIRECTION CAN BE REMOVED!
                            }
                            else
                            {
                                GlTF_Technique tech = new GlTF_Technique();
                                tech.name = techName;
                                GlTF_Technique.Parameter tParam = new GlTF_Technique.Parameter();
                                tParam.name     = "position";
                                tParam.type     = GlTF_Technique.Type.FLOAT_VEC3;
                                tParam.semantic = GlTF_Technique.Semantic.POSITION;
                                tech.parameters.Add(tParam);
                                GlTF_Technique.Attribute tAttr = new GlTF_Technique.Attribute();
                                tAttr.name  = "a_position";
                                tAttr.param = tParam.name;
                                tech.attributes.Add(tAttr);

                                if (normalAccessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "normal";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC3;
                                    tParam.semantic = GlTF_Technique.Semantic.NORMAL;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_normal";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv0Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord0";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_0;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord0";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv1Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord1";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_1;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord1";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv2Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord2";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_2;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord2";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv3Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord3";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_3;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord3";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                tech.AddDefaultUniforms();

                                // Populate technique with shader data
                                GlTF_Writer.techniqueNames.Add(techName);
                                GlTF_Writer.techniques.Add(tech);

                                // create program
                                GlTF_Program program = new GlTF_Program();
                                program.name = GlTF_Program.GetNameFromObject(s);
                                tech.program = program.name;
                                foreach (var attr in tech.attributes)
                                {
                                    program.attributes.Add(attr.name);
                                }
                                GlTF_Writer.programs.Add(program);
                            }

                            unityToPBRMaterial(mat, ref material);
                        }
                    }
                    mesh.primitives.Add(primitive);
                }

                // If gameobject having SkinnedMeshRenderer component has been transformed,
                // the mesh would need to be baked here.
                mesh.Populate(m);
                GlTF_Writer.meshes.Add(mesh);
                node.meshIndex = GlTF_Writer.meshes.IndexOf(mesh);
            }

            // Parse animations
            if (exportAnimation)
            {
                Animator a = tr.GetComponent <Animator>();
                if (a != null)
                {
                    AnimationClip[] clips = AnimationUtility.GetAnimationClips(tr.gameObject);
                    for (int i = 0; i < clips.Length; i++)
                    {
                        //FIXME It seems not good to generate one animation per animator.
                        GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(a.name));
                        anim.Populate(clips[i], tr, GlTF_Writer.bakeAnimation);
                        if (anim.channels.Count > 0)
                        {
                            GlTF_Writer.animations.Add(anim);
                        }
                    }
                }

                Animation animation = tr.GetComponent <Animation>();
                if (animation != null)
                {
                    AnimationClip clip = animation.clip;
                    //FIXME It seems not good to generate one animation per animator.
                    GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(animation.name));
                    anim.Populate(clip, tr, GlTF_Writer.bakeAnimation);
                    if (anim.channels.Count > 0)
                    {
                        GlTF_Writer.animations.Add(anim);
                    }
                }
            }

            // Parse transform
            if (tr.parent == null)
            {
                Matrix4x4 mat = Matrix4x4.identity;
                if (debugRightHandedScale)
                {
                    mat.m22 = -1;
                }
                mat         = mat * Matrix4x4.TRS(tr.localPosition, tr.localRotation, tr.localScale);
                node.matrix = new GlTF_Matrix(mat);
            }
            // Use good transform if parent object is not in selection
            else if (!trs.Contains(tr.parent))
            {
                node.hasParent = false;
                Matrix4x4 mat = Matrix4x4.identity;
                if (debugRightHandedScale)
                {
                    mat.m22 = -1;
                }
                mat         = mat * tr.localToWorldMatrix;
                node.matrix = new GlTF_Matrix(mat);
            }
            else
            {
                node.hasParent = true;
                if (tr.localPosition != Vector3.zero)
                {
                    node.translation = new GlTF_Translation(tr.localPosition);
                }
                if (tr.localScale != Vector3.one)
                {
                    node.scale = new GlTF_Scale(tr.localScale);
                }
                if (tr.localRotation != Quaternion.identity)
                {
                    node.rotation = new GlTF_Rotation(tr.localRotation);
                }
            }

            if (!node.hasParent)
            {
                correctionNode.childrenNames.Add(node.id);
            }

            if (tr.GetComponent <Camera>() != null)
            {
                node.cameraName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
            }
            else if (tr.GetComponent <Light>() != null)
            {
                node.lightName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
            }

            // Parse node's skin data
            GlTF_Accessor       invBindMatrixAccessor = null;
            SkinnedMeshRenderer skinMesh = tr.GetComponent <SkinnedMeshRenderer>();
            if (exportAnimation && skinMesh != null && skinMesh.enabled && checkSkinValidity(skinMesh, trs) && skinMesh.rootBone != null)
            {
                GlTF_Skin skin = new GlTF_Skin();

                skin.name = GlTF_Writer.cleanNonAlphanumeric(skinMesh.rootBone.name) + "_skeleton_" + GlTF_Writer.cleanNonAlphanumeric(node.name) + tr.GetInstanceID();

                // Create invBindMatrices accessor
                invBindMatrixAccessor            = new GlTF_Accessor(skin.name + "invBindMatrices", GlTF_Accessor.Type.MAT4, GlTF_Accessor.ComponentType.FLOAT);
                invBindMatrixAccessor.bufferView = GlTF_Writer.mat4BufferView;
                GlTF_Writer.accessors.Add(invBindMatrixAccessor);

                // Generate skin data
                skin.Populate(tr, ref invBindMatrixAccessor, GlTF_Writer.accessors.Count - 1);
                GlTF_Writer.skins.Add(skin);
                node.skinIndex = GlTF_Writer.skins.IndexOf(skin);
            }

            foreach (Transform t in tr.transform)
            {
                if (t.gameObject.activeInHierarchy)
                {
                    node.childrenNames.Add(GlTF_Node.GetNameFromObject(t));
                }
            }

            GlTF_Writer.nodeNames.Add(node.id);
            GlTF_Writer.nodes.Add(node);
        }

        if (GlTF_Writer.meshes.Count == 0)
        {
            Debug.Log("No visible objects have been exported. Aboring export");
            yield return(false);
        }

        writer.OpenFiles(path);
        writer.Write();
        writer.CloseFiles();

        if (nbDisabledObjects > 0)
        {
            Debug.Log(nbDisabledObjects + " disabled object ignored during export");
        }

        Debug.Log("Scene has been exported to " + path);
        if (buildZip)
        {
            ZipFile zip = new ZipFile();
            Debug.Log(GlTF_Writer.exportedFiles.Count + " files generated");
            string zipName = Path.GetFileNameWithoutExtension(path) + ".zip";
            foreach (string originFilePath in GlTF_Writer.exportedFiles.Keys)
            {
                zip.AddFile(originFilePath, GlTF_Writer.exportedFiles[originFilePath]);
            }

            zip.Save(savedPath + "/" + zipName);

            // Remove all files
            foreach (string pa in GlTF_Writer.exportedFiles.Keys)
            {
                if (System.IO.File.Exists(pa))
                {
                    System.IO.File.Delete(pa);
                }
            }

            Debug.Log("Files have been cleaned");
        }
        done = true;

        yield return(true);
    }
示例#12
0
    public static BoundsDouble Export(string path, Transform[] trs, Transform root, out double minHeight, out double maxHeight)
    {
        minHeight = 0;
        maxHeight = 0;

        writer = new GlTF_Writer();
        writer.Init();

        if (presetAsset != null)
        {
            string psPath = AssetDatabase.GetAssetPath(presetAsset);
            if (psPath != null)
            {
                psPath = psPath.Remove(0, "Assets".Length);
                psPath = Application.dataPath + psPath;
                preset.Load(psPath);
            }
        }

        savedPath = Path.GetDirectoryName(path);
        savedFile = Path.GetFileNameWithoutExtension(path);

        EditorPrefs.SetString(KEY_PATH, savedPath);
        EditorPrefs.SetString(KEY_FILE, savedFile);

        Debug.Log("attempting to save to " + path);
        writer.OpenFiles(path);

        if (rtcScript != null && root != null)
        {
            var instance = Activator.CreateInstance(rtcScript.GetClass());
            var rtc      = instance as RTCCallback;
            if (rtc != null)
            {
                writer.RTCCenter = rtc.GetCenter(root);
            }
        }

        RotationCallback rotCallback = null;;

        if (rotScript != null)
        {
            var instance = Activator.CreateInstance(rotScript.GetClass());
            rotCallback = instance as RotationCallback;
        }

        if (unpackTexture)
        {
            // prepass, for texture unpacker
            TextureUnpacker.Reset();
            foreach (Transform tr in trs)
            {
                TextureUnpacker.CheckPackedTexture(tr, preset);
            }
            TextureUnpacker.Build();
        }

        BoundsDouble bb = new BoundsDouble();

        // first, collect objects in the scene, add to lists
        foreach (Transform tr in trs)
        {
            if (tr.GetComponent <Camera>() != null)
            {
                if (tr.GetComponent <Camera>().orthographic)
                {
                    GlTF_Orthographic cam;
                    cam       = new GlTF_Orthographic();
                    cam.type  = "orthographic";
                    cam.zfar  = tr.GetComponent <Camera>().farClipPlane;
                    cam.znear = tr.GetComponent <Camera>().nearClipPlane;
                    cam.name  = tr.name;
                    //cam.orthographic.xmag = tr.camera.
                    GlTF_Writer.cameras.Add(cam);
                }
                else
                {
                    GlTF_Perspective cam;
                    cam              = new GlTF_Perspective();
                    cam.type         = "perspective";
                    cam.zfar         = tr.GetComponent <Camera>().farClipPlane;
                    cam.znear        = tr.GetComponent <Camera>().nearClipPlane;
                    cam.aspect_ratio = tr.GetComponent <Camera>().aspect;
                    cam.yfov         = tr.GetComponent <Camera>().fieldOfView;
                    cam.name         = tr.name;
                    GlTF_Writer.cameras.Add(cam);
                }
            }

            if (tr.GetComponent <Light>() != null)
            {
                switch (tr.GetComponent <Light>().type)
                {
                case LightType.Point:
                    GlTF_PointLight pl = new GlTF_PointLight();
                    pl.color = new GlTF_ColorRGB(tr.GetComponent <Light>().color);
                    pl.name  = tr.name;
                    GlTF_Writer.lights.Add(pl);
                    break;

                case LightType.Spot:
                    GlTF_SpotLight sl = new GlTF_SpotLight();
                    sl.color = new GlTF_ColorRGB(tr.GetComponent <Light>().color);
                    sl.name  = tr.name;
                    GlTF_Writer.lights.Add(sl);
                    break;

                case LightType.Directional:
                    GlTF_DirectionalLight dl = new GlTF_DirectionalLight();
                    dl.color = new GlTF_ColorRGB(tr.GetComponent <Light>().color);
                    dl.name  = tr.name;
                    GlTF_Writer.lights.Add(dl);
                    break;

                case LightType.Area:
                    GlTF_AmbientLight al = new GlTF_AmbientLight();
                    al.color = new GlTF_ColorRGB(tr.GetComponent <Light>().color);
                    al.name  = tr.name;
                    GlTF_Writer.lights.Add(al);
                    break;
                }
            }

            Mesh m = GetMesh(tr);
            if (m != null)
            {
                GlTF_Mesh mesh = new GlTF_Mesh();
                mesh.name = GlTF_Mesh.GetNameFromObject(m);

                GlTF_Accessor positionAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "position"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
                positionAccessor.bufferView = GlTF_Writer.vec3BufferView;
                GlTF_Writer.accessors.Add(positionAccessor);

                GlTF_Accessor normalAccessor = null;
                if (m.normals.Length > 0)
                {
                    normalAccessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "normal"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
                    normalAccessor.bufferView = GlTF_Writer.vec3BufferView;
                    GlTF_Writer.accessors.Add(normalAccessor);
                }

                GlTF_Accessor uv0Accessor = null;
                if (m.uv.Length > 0)
                {
                    uv0Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv0"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv0Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv0Accessor);
                }

                GlTF_Accessor uv1Accessor = null;
                if (m.uv2.Length > 0)
                {
                    uv1Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv1"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv1Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv1Accessor);
                }

                GlTF_Accessor uv2Accessor = null;
                if (m.uv3.Length > 0)
                {
                    uv2Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv2"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv2Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv2Accessor);
                }

                GlTF_Accessor uv3Accessor = null;
                if (m.uv4.Length > 0)
                {
                    uv3Accessor            = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv3"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
                    uv3Accessor.bufferView = GlTF_Writer.vec2BufferView;
                    GlTF_Writer.accessors.Add(uv3Accessor);
                }

                var smCount = m.subMeshCount;
                for (var i = 0; i < smCount; ++i)
                {
                    GlTF_Primitive primitive = new GlTF_Primitive();
                    primitive.name  = GlTF_Primitive.GetNameFromObject(m, i);
                    primitive.index = i;
                    GlTF_Attributes attributes = new GlTF_Attributes();
                    attributes.positionAccessor  = positionAccessor;
                    attributes.normalAccessor    = normalAccessor;
                    attributes.texCoord0Accessor = uv0Accessor;
                    attributes.texCoord1Accessor = uv1Accessor;
                    attributes.texCoord2Accessor = uv2Accessor;
                    attributes.texCoord3Accessor = uv3Accessor;
                    primitive.attributes         = attributes;
                    GlTF_Accessor indexAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "indices_" + i), GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.USHORT);
                    indexAccessor.bufferView = GlTF_Writer.ushortBufferView;
                    GlTF_Writer.accessors.Add(indexAccessor);
                    primitive.indices = indexAccessor;

                    var mr = GetRenderer(tr);
                    var sm = mr.sharedMaterials;
                    if (i < sm.Length && sm[i] != null)
                    {
                        var mat     = sm[i];
                        var matName = GlTF_Material.GetNameFromObject(mat);
                        primitive.materialName = matName;
                        if (!GlTF_Writer.materials.ContainsKey(matName))
                        {
                            GlTF_Material material = new GlTF_Material();
                            material.name = matName;
                            GlTF_Writer.materials.Add(material.name, material);

                            //technique
                            var s        = mat.shader;
                            var techName = GlTF_Technique.GetNameFromObject(s);
                            material.instanceTechniqueName = techName;
                            if (!GlTF_Writer.techniques.ContainsKey(techName))
                            {
                                GlTF_Technique tech = new GlTF_Technique();
                                tech.name = techName;

                                GlTF_Technique.States ts = null;
                                if (preset.techniqueStates.ContainsKey(s.name))
                                {
                                    ts = preset.techniqueStates[s.name];
                                }
                                else if (preset.techniqueStates.ContainsKey("*"))
                                {
                                    ts = preset.techniqueStates["*"];
                                }

                                if (ts == null)
                                {
                                    // Unless otherwise specified by a preset file, enable z-buffering.
                                    ts = new GlTF_Technique.States();
                                    const int DEPTH_TEST = 2929;
                                    // int CULL_FACE = 2884;
                                    ts.enable = new int[1] {
                                        DEPTH_TEST
                                    };
                                }

                                tech.states = ts;

                                GlTF_Technique.Parameter tParam = new GlTF_Technique.Parameter();
                                tParam.name     = "position";
                                tParam.type     = GlTF_Technique.Type.FLOAT_VEC3;
                                tParam.semantic = GlTF_Technique.Semantic.POSITION;
                                tech.parameters.Add(tParam);
                                GlTF_Technique.Attribute tAttr = new GlTF_Technique.Attribute();
                                tAttr.name  = "a_position";
                                tAttr.param = tParam.name;
                                tech.attributes.Add(tAttr);

                                if (normalAccessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "normal";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC3;
                                    tParam.semantic = GlTF_Technique.Semantic.NORMAL;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_normal";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv0Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord0";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_0;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord0";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv1Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord1";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_1;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord1";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv2Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord2";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_2;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord2";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                if (uv3Accessor != null)
                                {
                                    tParam          = new GlTF_Technique.Parameter();
                                    tParam.name     = "texcoord3";
                                    tParam.type     = GlTF_Technique.Type.FLOAT_VEC2;
                                    tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_3;
                                    tech.parameters.Add(tParam);
                                    tAttr       = new GlTF_Technique.Attribute();
                                    tAttr.name  = "a_texcoord3";
                                    tAttr.param = tParam.name;
                                    tech.attributes.Add(tAttr);
                                }

                                tech.AddDefaultUniforms(writer.RTCCenter != null);

                                GlTF_Writer.techniques.Add(techName, tech);

                                int spCount = ShaderUtil.GetPropertyCount(s);
                                for (var j = 0; j < spCount; ++j)
                                {
                                    var pName = ShaderUtil.GetPropertyName(s, j);
                                    var pType = ShaderUtil.GetPropertyType(s, j);
                                    // Debug.Log(pName + " " + pType);

                                    GlTF_Technique.Uniform tUni;
                                    if (pType == ShaderUtil.ShaderPropertyType.Color)
                                    {
                                        tParam      = new GlTF_Technique.Parameter();
                                        tParam.name = pName;
                                        tParam.type = GlTF_Technique.Type.FLOAT_VEC4;
                                        tech.parameters.Add(tParam);
                                        tUni       = new GlTF_Technique.Uniform();
                                        tUni.name  = pName;
                                        tUni.param = tParam.name;
                                        tech.uniforms.Add(tUni);
                                    }
                                    else if (pType == ShaderUtil.ShaderPropertyType.Vector)
                                    {
                                        tParam      = new GlTF_Technique.Parameter();
                                        tParam.name = pName;
                                        tParam.type = GlTF_Technique.Type.FLOAT_VEC4;
                                        tech.parameters.Add(tParam);
                                        tUni       = new GlTF_Technique.Uniform();
                                        tUni.name  = pName;
                                        tUni.param = tParam.name;
                                        tech.uniforms.Add(tUni);
                                    }
                                    else if (pType == ShaderUtil.ShaderPropertyType.Float ||
                                             pType == ShaderUtil.ShaderPropertyType.Range)
                                    {
                                        tParam      = new GlTF_Technique.Parameter();
                                        tParam.name = pName;
                                        tParam.type = GlTF_Technique.Type.FLOAT;
                                        tech.parameters.Add(tParam);
                                        tUni       = new GlTF_Technique.Uniform();
                                        tUni.name  = pName;
                                        tUni.param = tParam.name;
                                        tech.uniforms.Add(tUni);
                                    }
                                    else if (pType == ShaderUtil.ShaderPropertyType.TexEnv)
                                    {
                                        var td = ShaderUtil.GetTexDim(s, j);
                                        if (td == UnityEngine.Rendering.TextureDimension.Tex2D)
                                        {
                                            tParam      = new GlTF_Technique.Parameter();
                                            tParam.name = pName;
                                            tParam.type = GlTF_Technique.Type.SAMPLER_2D;
                                            tech.parameters.Add(tParam);
                                            tUni       = new GlTF_Technique.Uniform();
                                            tUni.name  = pName;
                                            tUni.param = tParam.name;
                                            tech.uniforms.Add(tUni);
                                        }
                                    }
                                }

                                // create program
                                GlTF_Program program = new GlTF_Program();
                                program.name = GlTF_Program.GetNameFromObject(s);
                                tech.program = program.name;
                                foreach (var attr in tech.attributes)
                                {
                                    program.attributes.Add(attr.name);
                                }
                                GlTF_Writer.programs.Add(program);

                                // shader
                                GlTF_Shader vs = new GlTF_Shader();
                                vs.name = GlTF_Shader.GetNameFromObject(s, GlTF_Shader.Type.Vertex);
                                program.vertexShader = vs.name;
                                vs.type = GlTF_Shader.Type.Vertex;
                                vs.uri  = preset.GetVertexShader(s.name);
                                GlTF_Writer.shaders.Add(vs);

                                GlTF_Shader fs = new GlTF_Shader();
                                fs.name = GlTF_Shader.GetNameFromObject(s, GlTF_Shader.Type.Fragment);
                                program.fragmentShader = fs.name;
                                fs.type = GlTF_Shader.Type.Fragment;
                                fs.uri  = preset.GetFragmentShader(s.name);
                                GlTF_Writer.shaders.Add(fs);
                            }

                            int spCount2 = ShaderUtil.GetPropertyCount(s);
                            for (var j = 0; j < spCount2; ++j)
                            {
                                var pName = ShaderUtil.GetPropertyName(s, j);
                                var pType = ShaderUtil.GetPropertyType(s, j);

                                if (pType == ShaderUtil.ShaderPropertyType.Color)
                                {
                                    var matCol = new GlTF_Material.ColorValue();
                                    matCol.name  = pName;
                                    matCol.color = mat.GetColor(pName);
                                    material.values.Add(matCol);
                                }
                                else if (pType == ShaderUtil.ShaderPropertyType.Vector)
                                {
                                    var matVec = new GlTF_Material.VectorValue();
                                    matVec.name   = pName;
                                    matVec.vector = mat.GetVector(pName);
                                    material.values.Add(matVec);
                                }
                                else if (pType == ShaderUtil.ShaderPropertyType.Float ||
                                         pType == ShaderUtil.ShaderPropertyType.Range)
                                {
                                    var matFloat = new GlTF_Material.FloatValue();
                                    matFloat.name  = pName;
                                    matFloat.value = mat.GetFloat(pName);
                                    material.values.Add(matFloat);
                                }
                                else if (pType == ShaderUtil.ShaderPropertyType.TexEnv)
                                {
                                    var td = ShaderUtil.GetTexDim(s, j);
                                    if (td == UnityEngine.Rendering.TextureDimension.Tex2D)
                                    {
                                        var t = mat.GetTexture(pName);
                                        if (t == null)
                                        {
                                            continue;
                                        }
                                        var val = new GlTF_Material.StringValue();
                                        val.name = pName;
                                        string texName = null;
                                        texName   = GlTF_Texture.GetNameFromObject(t);
                                        val.value = texName;
                                        material.values.Add(val);
                                        if (!GlTF_Writer.textures.ContainsKey(texName))
                                        {
                                            var        texPath = ExportTexture(t, savedPath);
                                            GlTF_Image img     = new GlTF_Image();
                                            img.name = GlTF_Image.GetNameFromObject(t);
                                            img.uri  = texPath;
                                            GlTF_Writer.images.Add(img);

                                            GlTF_Sampler sampler;
                                            var          samplerName = GlTF_Sampler.GetNameFromObject(t);
                                            if (GlTF_Writer.samplers.ContainsKey(samplerName))
                                            {
                                                sampler = GlTF_Writer.samplers[samplerName];
                                            }
                                            else
                                            {
                                                sampler      = new GlTF_Sampler(t);
                                                sampler.name = samplerName;
                                                GlTF_Writer.samplers[samplerName] = sampler;
                                            }

                                            GlTF_Texture texture = new GlTF_Texture();
                                            texture.name        = texName;
                                            texture.source      = img.name;
                                            texture.samplerName = samplerName;

                                            GlTF_Writer.textures.Add(texName, texture);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    mesh.primitives.Add(primitive);
                }

                mesh.Populate(m);
                GlTF_Writer.meshes.Add(mesh);
                if (unpackTexture)
                {
                    TextureUnpacker.ProcessMesh(mesh);
                }

                // calculate bounding box transform
                if (root != null)
                {
                    Matrix4x4 brot = Matrix4x4.identity;
                    if (rotCallback != null)
                    {
                        brot = rotCallback.GetBoundsRotationMatrix(root);
                    }

                    var pos    = tr.position - root.position; // relative to parent
                    var objMat = Matrix4x4.TRS(pos, tr.rotation, tr.lossyScale);

                    //read vertices
                    var ms     = positionAccessor.bufferView.memoryStream;
                    var offset = (int)positionAccessor.byteOffset;
                    var len    = positionAccessor.count;
                    var buffer = new byte[len * 12];
                    var mspos  = ms.Position;
                    ms.Position = offset;
                    ms.Read(buffer, 0, buffer.Length);

                    minHeight = double.MaxValue;
                    maxHeight = double.MinValue;

                    double[] c = writer.RTCCenter;

                    double[] minPos = new double[3];
                    minPos[0] = double.MaxValue;
                    minPos[1] = double.MaxValue;
                    minPos[2] = double.MaxValue;

                    double[] maxPos = new double[3];
                    maxPos[0] = double.MinValue;
                    maxPos[1] = double.MinValue;
                    maxPos[2] = double.MinValue;

                    for (int j = 0; j < len; ++j)
                    {
                        var x = System.BitConverter.ToSingle(buffer, j * 12);
                        var y = System.BitConverter.ToSingle(buffer, j * 12 + 4);
                        var z = System.BitConverter.ToSingle(buffer, j * 12 + 8);

                        // local rotation
                        var lx = objMat.m00 * x + objMat.m01 * y + objMat.m02 * z;
                        var ly = objMat.m10 * x + objMat.m11 * y + objMat.m12 * z;
                        var lz = objMat.m20 * x + objMat.m21 * y + objMat.m22 * z;

                        minHeight = Math.Min(minHeight, ly);
                        maxHeight = Math.Max(maxHeight, ly);

                        // to world
                        double wx = brot.m00 * lx + brot.m01 * ly + brot.m02 * lz;
                        double wy = brot.m10 * lx + brot.m11 * ly + brot.m12 * lz;
                        double wz = brot.m20 * lx + brot.m21 * ly + brot.m22 * lz;

                        // local translation to world
                        double tx = brot.m00 * pos.x + brot.m01 * pos.y + brot.m02 * pos.z;
                        double ty = brot.m10 * pos.x + brot.m11 * pos.y + brot.m12 * pos.z;
                        double tz = brot.m20 * pos.x + brot.m21 * pos.y + brot.m22 * pos.z;

                        wx += tx;
                        wy += ty;
                        wz += tz;

                        if (c != null)
                        {
                            wx += c[0];
                            wy += c[1];
                            wz += c[2];
                        }

                        minPos[0] = Math.Min(minPos[0], wx);
                        minPos[1] = Math.Min(minPos[1], wy);
                        minPos[2] = Math.Min(minPos[2], wz);

                        maxPos[0] = Math.Max(maxPos[0], wx);
                        maxPos[1] = Math.Max(maxPos[1], wy);
                        maxPos[2] = Math.Max(maxPos[2], wz);
                    }

                    ms.Position = mspos;

                    BoundsDouble tbb = new BoundsDouble();
                    tbb.Encapsulate(new BoundsDouble(minPos, maxPos));
                    bb.Encapsulate(tbb);
                }
            }

            Animation a = tr.GetComponent <Animation>();

            //				Animator a = tr.GetComponent<Animator>();
            if (a != null)
            {
                AnimationClip[] clips  = AnimationUtility.GetAnimationClips(tr.gameObject);
                int             nClips = clips.Length;
                //					int nClips = a.GetClipCount();
                for (int i = 0; i < nClips; i++)
                {
                    GlTF_Animation anim = new GlTF_Animation(a.name);
                    anim.Populate(clips[i]);
                    GlTF_Writer.animations.Add(anim);
                }
            }


            // next, build hierarchy of nodes
            GlTF_Node node = new GlTF_Node();

            Matrix4x4 rotMat = Matrix4x4.identity;
            if (root != null && rotCallback != null)
            {
                rotMat = rotCallback.GetNodeRotationMatrix(root);
            }

            if (tr == root)
            {
                Matrix4x4 mat = Matrix4x4.identity;
                mat.m22 = -1; // flip z axis

                if (rotMat != Matrix4x4.identity)
                {
                    mat = rotMat;
                }

                // do not use global position if rtc is defined
                Vector3 pos = Vector3.zero;
                if (writer.RTCCenter == null)
                {
                    pos = tr.localPosition;
                }

                mat         = mat * Matrix4x4.TRS(pos, tr.localRotation, tr.localScale);
                node.matrix = new GlTF_Matrix(mat);
            }
            else
            {
                node.hasParent = true;
                if (tr.localPosition != Vector3.zero)
                {
                    node.translation = new GlTF_Translation(tr.localPosition);
                }
                if (tr.localScale != Vector3.one)
                {
                    node.scale = new GlTF_Scale(tr.localScale);
                }
                if (tr.localRotation != Quaternion.identity)
                {
                    node.rotation = new GlTF_Rotation(tr.localRotation);
                }
            }

            node.name = GlTF_Node.GetNameFromObject(tr);
            if (tr.GetComponent <Camera>() != null)
            {
                node.cameraName = tr.name;
            }
            else if (tr.GetComponent <Light>() != null)
            {
                node.lightName = tr.name;
            }
            else if (m != null)
            {
                node.meshNames.Add(GlTF_Mesh.GetNameFromObject(m));
            }

            foreach (Transform t in tr.transform)
            {
                var found = false;
                foreach (var check in trs)
                {
                    if (t == check)
                    {
                        found = true;
                        break;
                    }
                }
                if (found)
                {
                    node.childrenNames.Add(GlTF_Node.GetNameFromObject(t));
                }
            }

            GlTF_Writer.nodes.Add(node);
        }

        if (copyShaders && preset.shaderDir != null)
        {
            var sd = Path.Combine(Application.dataPath, preset.shaderDir);
            foreach (var shader in GlTF_Writer.shaders)
            {
                var srcPath = Path.Combine(sd, shader.uri);
                if (File.Exists(srcPath))
                {
                    var dstPath = Path.Combine(savedPath, shader.uri);
                    File.Copy(srcPath, dstPath, true);
                }
            }
        }

        // third, add meshes etc to byte stream, keeping track of buffer offsets
        writer.Write();
        writer.CloseFiles();
        return(bb);
    }
    void OnWizardCreate() // Create (Export) button has been hit (NOT wizard has been created!)
    {
		writer = new GlTF_Writer();
		writer.Init ();
/*
		Object[] deps = EditorUtility.CollectDependencies  (trs);
		foreach (Object o in deps)
		{
			Debug.Log("obj "+o.name+"  "+o.GetType());
		}
*/		
		
		path = EditorUtility.SaveFilePanel("Save glTF file as", savedPath, savedFile, "gltf");
		if (path.Length != 0)
		{
			Debug.Log ("attempting to save to "+path);
			writer.OpenFiles (path);

			// FOR NOW!
			GlTF_Sampler sampler = new GlTF_Sampler("sampler1"); // make the default one for now
			GlTF_Writer.samplers.Add (sampler);
			// first, collect objects in the scene, add to lists
			Transform[] trs = Selection.GetTransforms (SelectionMode.Deep);
			foreach (Transform tr in trs)
			{
				if (tr.camera != null)
				{
					if (tr.camera.isOrthoGraphic)
					{
						GlTF_Orthographic cam;
						cam = new GlTF_Orthographic();
						cam.type = "orthographic";
						cam.zfar = tr.camera.farClipPlane;
						cam.znear = tr.camera.nearClipPlane;
						cam.name = tr.name;
						//cam.orthographic.xmag = tr.camera.
						GlTF_Writer.cameras.Add(cam);
					}
					else
					{
						GlTF_Perspective cam;
						cam = new GlTF_Perspective();
						cam.type = "perspective";
						cam.zfar = tr.camera.farClipPlane;
						cam.znear = tr.camera.nearClipPlane;
						cam.aspect_ratio = tr.camera.aspect;
						cam.yfov = tr.camera.fieldOfView;
						cam.name = tr.name;
						GlTF_Writer.cameras.Add(cam);
					}
				}
				
				if (tr.light != null)
				{
					switch (tr.light.type)
					{
					case LightType.Point:
						GlTF_PointLight pl = new GlTF_PointLight();
						pl.color = new GlTF_ColorRGB (tr.light.color);
						pl.name = tr.name;
						GlTF_Writer.lights.Add (pl);
						break;

					case LightType.Spot:
						GlTF_SpotLight sl = new GlTF_SpotLight();
						sl.color = new GlTF_ColorRGB (tr.light.color);
						sl.name = tr.name;
						GlTF_Writer.lights.Add (sl);
						break;
						
					case LightType.Directional:
						GlTF_DirectionalLight dl = new GlTF_DirectionalLight();
						dl.color = new GlTF_ColorRGB (tr.light.color);
						dl.name = tr.name;
						GlTF_Writer.lights.Add (dl);
						break;
						
					case LightType.Area:
						GlTF_AmbientLight al = new GlTF_AmbientLight();
						al.color = new GlTF_ColorRGB (tr.light.color);
						al.name = tr.name;
						GlTF_Writer.lights.Add (al);
						break;
					}
				}

				MeshRenderer mr = tr.GetComponent<MeshRenderer>();
				if (mr != null)
				{
					MeshFilter mf = tr.GetComponent<MeshFilter>();
					Mesh m = mf.sharedMesh;
					GlTF_Accessor normalAccessor = new GlTF_Accessor("normalAccessor-" + tr.name + "_FIXTHIS", "VEC3", "FLOAT");
					GlTF_Accessor positionAccessor = new GlTF_Accessor("positionAccessor-" + tr.name + "_FIXTHIS", "VEC3", "FLOAT");
					GlTF_Accessor texCoord0Accessor = new GlTF_Accessor("texCoord0Accessor-" + tr.name + "_FIXTHIS", "VEC2", "FLOAT");
					GlTF_Accessor indexAccessor = new GlTF_Accessor("indicesAccessor-" + tr.name + "_FIXTHIS", "SCALAR", "USHORT");
					indexAccessor.bufferView = GlTF_Writer.ushortBufferView;
					normalAccessor.bufferView = GlTF_Writer.vec3BufferView;
					positionAccessor.bufferView = GlTF_Writer.vec3BufferView;
					texCoord0Accessor.bufferView = GlTF_Writer.vec2BufferView;
					GlTF_Mesh mesh = new GlTF_Mesh();
					mesh.name = "mesh-" + tr.name;
					GlTF_Primitive primitive = new GlTF_Primitive();
					primitive.name = "primitive-"+tr.name+"_FIXTHIS";
					GlTF_Attributes attributes = new GlTF_Attributes();
					attributes.normalAccessor = normalAccessor;
					attributes.positionAccessor = positionAccessor;
					attributes.texCoord0Accessor = texCoord0Accessor;
					primitive.attributes = attributes;
					primitive.indices = indexAccessor;
					mesh.primitives.Add (primitive);
					mesh.Populate (m);
					GlTF_Writer.accessors.Add (normalAccessor);
					GlTF_Writer.accessors.Add (positionAccessor);
					GlTF_Writer.accessors.Add (texCoord0Accessor);
					GlTF_Writer.accessors.Add (indexAccessor);
					GlTF_Writer.meshes.Add (mesh);

					// next, add material(s) to dictionary (when unique)
					string matName = mr.sharedMaterial.name;
					if (matName == "")
						matName = "material-diffault-diffuse";
					else
						matName = "material-" + matName;
					primitive.materialName = matName;
					if (!GlTF_Writer.materials.ContainsKey (matName))
					{
						GlTF_Material material = new GlTF_Material();
						material.name = matName;
						if (mr.sharedMaterial.HasProperty ("shininess"))
							material.shininess = mr.sharedMaterial.GetFloat("shininess");
						material.diffuse = new GlTF_MaterialColor ("diffuse", mr.sharedMaterial.color);
						//material.ambient = new GlTF_Color ("ambient", mr.material.color);
						
						if (mr.sharedMaterial.HasProperty ("specular"))
						{
							Color sc = mr.sharedMaterial.GetColor ("specular");
							material.specular = new GlTF_MaterialColor ("specular", sc);
						}
						GlTF_Writer.materials.Add (material.name, material);

						// if there are textures, add them too
						if (mr.sharedMaterial.mainTexture != null)
						{
							if (!GlTF_Writer.textures.ContainsKey (mr.sharedMaterial.mainTexture.name))
							{
								GlTF_Texture texture = new GlTF_Texture ();
								texture.name = mr.sharedMaterial.mainTexture.name;
								texture.source = AssetDatabase.GetAssetPath(mr.sharedMaterial.mainTexture);
								texture.samplerName = sampler.name; // FIX! For now!
								GlTF_Writer.textures.Add (mr.sharedMaterial.mainTexture.name, texture);
								material.diffuse = new GlTF_MaterialTexture ("diffuse", texture);
							}
						}
					}
					
				}

				Animation a = tr.animation;
				
//				Animator a = tr.GetComponent<Animator>();				
				if (a != null)
				{
					AnimationClip[] clips = AnimationUtility.GetAnimationClips(tr.gameObject);
					int nClips = clips.Length;
//					int nClips = a.GetClipCount();
					for (int i = 0; i < nClips; i++)
					{
						GlTF_Animation anim = new GlTF_Animation(a.name);
						anim.Populate (clips[i]);
						GlTF_Writer.animations.Add (anim);
					}
				}

	
				// next, build hierarchy of nodes
				GlTF_Node node = new GlTF_Node();
				if (tr.parent != null)
					node.hasParent = true;
				if (tr.localPosition != Vector3.zero)
					node.translation = new GlTF_Translation (tr.localPosition);
				if (tr.localScale != Vector3.one)
					node.scale = new GlTF_Scale (tr.localScale);
				if (tr.localRotation != Quaternion.identity)
					node.rotation = new GlTF_Rotation (tr.localRotation);
				node.name = tr.name;
				if (tr.camera != null)
				{
					node.cameraName = tr.name;
				}
				else if (tr.light != null)
					node.lightName = tr.name;
				else if (mr != null)
				{
					node.meshNames.Add ("mesh-" + tr.name);
				}

				foreach (Transform t in tr.transform)
					node.childrenNames.Add ("node-" + t.name);
				
				GlTF_Writer.nodes.Add (node);
			}

			// third, add meshes etc to byte stream, keeping track of buffer offsets
			writer.Write ();
			writer.CloseFiles();
		}
	}