Beispiel #1
0
    private GameObject CreatePrefabFromModel(string tgt_path, GameObject modelAsset)
    {
        Tools.EnsureDirectoryExists(tgt_path);

        string destinationPath = GetSafeFilename(tgt_path + "/" + modelAsset.name + ".prefab");
        var    pfbsrc          = GetPrefabAsset(tgt_path, modelAsset.name);

        if (pfbsrc != null)
        {
            return(pfbsrc);
        }
        m_created_prefabs.Add(destinationPath);
        var pfb = PrefabUtility.SaveAsPrefabAsset(modelAsset, destinationPath);

        GameObject.DestroyImmediate(modelAsset);

        return(null);
    }
Beispiel #2
0
    public override void OnImportAsset(AssetImportContext ctx)
    {
        Tools.EnsureDirectoryExists(PREFAB_DESTINATION_DIRECTORY);
        int idx = ctx.assetPath.LastIndexOf("geobin");

        if (-1 == idx)
        {
            ctx.LogImportWarning("File is not located under 'geobin', skipping");
            return;
        }

        if (null == s_runtime_data) //!m_RuntimeReady
        {
            s_runtime_data = new RuntimeData();
            string basepath = ctx.assetPath.Substring(0, idx - 1);
            if (!basepath.EndsWith("/") && basepath[basepath.Length - 1] != Path.DirectorySeparatorChar)
            {
                basepath += Path.DirectorySeparatorChar;
            }
            s_runtime_data.prepare(basepath);
        }

        if (m_previous_asset == null || m_previous == null)
        {
            sg = SceneGraph.loadWholeMap(ctx.assetPath);
        }
        else
        {
            Debug.Log("Reusing previously loaded graph");
            sg = m_previous;
        }

        m_previous       = sg;
        m_previous_asset = ctx.assetPath;
        var top_nodes = sg.calculateUsages();

        if (top_nodes.Count != 0)
        {
            bool some_prefabs_were_missing = false;
            foreach (var pair in top_nodes)
            {
                GameObject top_level = convertFromRoot(pair.Value);
                if (top_level == null)
                {
                    some_prefabs_were_missing = true;
                }
                else
                {
                    GameObject.DestroyImmediate(top_level);
                }
            }

            foreach (KeyValuePair <SceneNode, GameObject> pair in m_imported_prefabs)
            {
                if (!top_nodes.ContainsValue(pair.Key))
                {
                    GameObject.DestroyImmediate(pair.Value); // remove all non-top-level prefabs from scene.
                }
            }

            if (some_prefabs_were_missing == false)
            {
                createTopNodesInstances(top_nodes);
            }
            else
            {
                string saved_ones = String.Join("\n", m_created_prefabs);
                ctx.LogImportWarning(String.Format(
                                         "The following prefab assets were missing and were created, please retry: {0}",
                                         saved_ones));
            }
        }
    }
Beispiel #3
0
    private static void convertMaterials(MeshRenderer ren, Model mdl, GameObject tgt)
    {
        ModelModifiers        model_trick = mdl.trck_node;
        GeometryModifiersData geom_trick  = mdl.src_mod;
        RuntimeData           rd          = RuntimeData.get();
        MaterialDescriptor    descriptor;

        string model_base_name = mdl.name.Split(new[] { "__" }, StringSplitOptions.None)[0];
        string mesh_path       = mdl.geoset.full_geo_path;
        int    obj_lib_idx     = mesh_path.IndexOf("object_library");

        if (obj_lib_idx != -1)
        {
            mesh_path = "Assets/Materials/" + mesh_path.Substring(obj_lib_idx);
        }
        string material_base_path = mesh_path + "/" + Path.GetFileNameWithoutExtension(mdl.name);

        if (mdl.name == "Crate1_med_Wood__TintCrates")
        {
            Debug.LogFormat("Crate {0}", mdl.BlendMode.ToString());
        }
        if (model_trick != null && model_trick._TrickFlags.HasFlag(TrickFlags.ColorOnly))
        {
//        result = result.Clone(result.GetName()+"Colored");
//        result.SetShaderParameter("MatDiffColor",Vector4(1.0, 1.0, 0.2f, 1.0f));
        }

        // Select material based on the model blend state
        // Modify material based on the applied model tricks
        Color onlyColor;
        Color tint1    = new Color(1, 1, 1, 1); // Shader Constant 0
        Color tint2    = new Color(1, 1, 1, 1); // Shader Constant 1
        float alphaRef = 0.0f;

        descriptor.depthWrite    = true;
        descriptor.isAdditive    = false;
        descriptor.targetCulling = UnityEngine.Rendering.CullMode.Back;
        descriptor.depthTest     = CompareFunction.LessEqual;
        descriptor.targetCulling = UnityEngine.Rendering.CullMode.Back;

        string shader_to_use = "";

        if (null != model_trick && model_trick._TrickFlags != 0)
        {
            var tflags = model_trick._TrickFlags;
            if (tflags.HasFlag(TrickFlags.Additive))
            {
                descriptor.isAdditive = true;
            }

            if (tflags.HasFlag(TrickFlags.ColorOnly))
            {
                onlyColor = model_trick.TintColor0;
            }
            if (tflags.HasFlag(TrickFlags.DoubleSided))
            {
                descriptor.targetCulling = UnityEngine.Rendering.CullMode.Off;
            }
            if (tflags.HasFlag(TrickFlags.NoZTest))
            {
                // simulate disabled Z test
                descriptor.depthTest = CompareFunction.Always;
                //depthTest = CompareFunction.Always;
                descriptor.depthWrite = false;
            }

            if (tflags.HasFlag(TrickFlags.NoZWrite))
            {
                descriptor.depthWrite = false;
            }
            if (tflags.HasFlag(TrickFlags.SetColor))
            {
                tint1   = model_trick.TintColor0;
                tint2   = model_trick.TintColor1;
                tint1.a = 1.0f;
                tint2.a = 1.0f;
            }

            if (tflags.HasFlag(TrickFlags.ReflectTex0) || tflags.HasFlag(TrickFlags.ReflectTex1))
            {
                shader_to_use = "Custom/ReflectGen";
                if (mdl.flags.HasFlag(ModelFlags.OBJ_CUBEMAP))
                {
                    Debug.Log("Unhandled Cubemap");
                }
            }

            if (tflags.HasFlag(TrickFlags.AlphaRef))
            {
                //qDebug() << "Unhandled alpha ref";
                alphaRef = geom_trick.AlphaRef;
            }

            if (tflags.HasFlag(TrickFlags.TexBias))
            {
                Debug.Log("Unhandled TexBias");
            }
        }

        CompareFunction depthTest     = CompareFunction.LessEqual;
        TextureWrapper  whitetex      = GeoSet.loadTexHeader("white");
        var             pixel_defines = new List <string>();

        pixel_defines.Add("DIFFMAP");
        pixel_defines.Add("ALPHAMASK");
        switch (mdl.BlendMode)
        {
        case CoHBlendMode.MULTIPLY:
            pixel_defines.Add("COH_MULTIPLY");
            break;

        case CoHBlendMode.MULTIPLY_REG:
            if (!descriptor.depthWrite && descriptor.isAdditive)
            {
                descriptor.targetCulling = UnityEngine.Rendering.CullMode.Off;
            }

            pixel_defines.Add("COH_MULTIPLY");
            break;

        case CoHBlendMode.COLORBLEND_DUAL:
            pixel_defines.Add("COH_COLOR_BLEND_DUAL");
            break;

        case CoHBlendMode.ADDGLOW:
            pixel_defines.Add("COH_ADDGLOW");
            break;

        case CoHBlendMode.ALPHADETAIL:
            pixel_defines.Add("COH_ALPHADETAIL");
            break;

        case CoHBlendMode.BUMPMAP_MULTIPLY:
            pixel_defines.Add("COH_MULTIPLY");
            break;

        case CoHBlendMode.BUMPMAP_COLORBLEND_DUAL:
            pixel_defines.Add("COH_COLOR_BLEND_DUAL");
            break;
        }

        if (mdl.flags.HasFlag(ModelFlags.OBJ_TREE))
        {
            shader_to_use = "CoH/Vegetation";
            alphaRef      = 0.4f;
            tint1.a       = 254.0f / 255.0f;
        }

        Material[] materials = new Material[mdl.texture_bind_info.Count];
        int        idx       = 0;

        Tools.EnsureDirectoryExists(material_base_path);
        var sup = tgt.GetComponent <ModelNodeMods>();

        sup.GeomTricks = geom_trick;
        VBOPointers vbo      = mdl.vbo;
        Shader      selected = null;

        if (descriptor.isAdditive)
        {
            if (shader_to_use == "Custom/ReflectGen")
            {
                selected = Shader.Find("Custom/ReflectGen");
            }
            else
            {
                selected = Shader.Find("Unlit/Additive");
            }
        }
        else
        {
            if (!String.IsNullOrEmpty(shader_to_use))
            {
                selected = Shader.Find(shader_to_use);
            }
            else
            {
                selected = Shader.Find("CoH/CoHMult");
            }
        }

        sup.TexWrappers = vbo.assigned_textures;

        foreach (TextureWrapper wrap in vbo.assigned_textures)
        {
            string   path_material_name = String.Format("{0}/{1}_{2}.mat", material_base_path, idx, descriptor.GetHashCode());
            Material available          = AssetDatabase.LoadAssetAtPath <Material>(path_material_name);
            if (available == null)
            {
                if (wrap != null)
                {
                    TextureWrapper detail = null;
                    if (!String.IsNullOrEmpty(wrap.detailname))
                    {
                        detail = GeoSet.loadTexHeader(wrap.detailname);
                    }


                    Material mat = new Material(selected);
                    mat.enableInstancing = true;
                    mat.SetColor("_Color", tint1);
                    mat.SetColor("_Color2", tint2);
                    mat.SetFloat("_AlphaRef", alphaRef);
                    mat.SetInt("_CoHMod", (int)mdl.BlendMode);

                    mat.SetTexture("_MainTex", wrap.tex);
                    if (detail != null)
                    {
                        mat.SetTexture("_Detail", detail.tex);
                    }
                    mat.SetInt("_ZWrite", descriptor.depthWrite ? 1 : 0);
                    mat.SetInt(ZTest, (int)descriptor.depthTest);
                    mat.SetInt(CullMode, (int)descriptor.targetCulling);
                    mat.SetTextureScale(MainTex, wrap.scaleUV1);
                    mat.SetTextureScale(Detail, wrap.scaleUV0);
                    AssetDatabase.CreateAsset(mat, path_material_name);
                    AssetDatabase.SaveAssets();
                    available = AssetDatabase.LoadAssetAtPath <Material>(path_material_name);
                }
            }
            materials[idx++] = available;
        }

        if (mdl.flags.HasFlag(ModelFlags.OBJ_HIDE))
        {
            ren.enabled = false;
        }

        ren.sharedMaterials = materials;
    }