static void ParseVtxFile()
        {
            if (VTX_Header.checkSum != MDL_Header.checksum)
            {
                throw new FileLoadException(String.Format("{0}: Does not match the checksum in the .mdl", ModelObject.name + ".dx90.vtx"));
            }

            mstudiomodel_t pModel = MDL_Models[0];
            mstudiomesh_t  pStudioMesh;

            BoneWeight[] pBoneWeight = new BoneWeight[pModel.numvertices];
            Vector3[]    pVertices   = new Vector3[pModel.numvertices];
            Vector3[]    pNormals    = new Vector3[pModel.numvertices];
            Vector2[]    pUvBuffer   = new Vector2[pModel.numvertices];

            List <Material> pMaterials = new List <Material>();

            ModelFileLoader.ReadType(ref vBodypart, VTX_Header.bodyPartOffset);

            Int32 ModelInputFilePosition = VTX_Header.bodyPartOffset + vBodypart.modelOffset;

            ModelFileLoader.ReadType(ref vModel, ModelInputFilePosition);

            Int32 ModelLODInputFilePosition = ModelInputFilePosition + vModel.lodOffset;

            ModelFileLoader.ReadType(ref vLod, ModelLODInputFilePosition);

            Int32 MeshInputFilePosition = ModelLODInputFilePosition + vLod.meshOffset;

            VTX_Meshes = new MeshHeader_t[vLod.numMeshes];
            ModelFileLoader.ReadArray(ref VTX_Meshes, MeshInputFilePosition);

            for (Int32 i = 0; i < pModel.numvertices; i++)
            {
                pVertices[i] = MathUtils.SwapZY(VVD_Vertexes[pModel.vertexindex + i].m_vecPosition * ConfigLoader.WorldScale);
                pNormals[i]  = MathUtils.SwapZY(VVD_Vertexes[pModel.vertexindex + i].m_vecNormal);
                pUvBuffer[i] = VVD_Vertexes[pModel.vertexindex + i].m_vecTexCoord;
            }

            Mesh pMesh = new Mesh();

            //ModelObject.AddComponent<MeshCollider>().sharedMesh = pMesh;

            pMesh.subMeshCount = vLod.numMeshes;

            pMesh.vertices = pVertices;
            pMesh.normals  = pNormals;
            pMesh.uv       = pUvBuffer;

            if (MDL_Bones.Count > 1)
            {
                for (Int32 i = 0; i < pModel.numvertices; i++)
                {
                    pBoneWeight[i] = GetBoneWeight(VVD_Vertexes[pModel.vertexindex + i].m_BoneWeights);
                }

                SkinnedMeshRenderer smr       = ModelObject.AddComponent <SkinnedMeshRenderer>();
                Matrix4x4[]         bindPoses = new Matrix4x4[MDL_Bones.Count];

                for (Int32 i = 0; i < bindPoses.Length; i++)
                {
                    bindPoses[i] = MDL_Bones[i].worldToLocalMatrix * ModelObject.transform.localToWorldMatrix;
                }

                pMesh.boneWeights = pBoneWeight;
                pMesh.bindposes   = bindPoses;

                smr.sharedMesh = pMesh;

                smr.bones = MDL_Bones.ToArray();
                smr.updateWhenOffscreen = true;
            }
            else
            {
                MeshFilter MeshFilter = ModelObject.AddComponent <MeshFilter>();
                ModelObject.AddComponent <MeshRenderer>();

                MeshFilter.sharedMesh = pMesh;
            }

            for (Int32 i = 0; i < vLod.numMeshes; i++)
            {
                List <Int32> pIndices = new List <Int32>();
                pStudioMesh = MDL_Meshes[i];

                StripGroupHeader_t[] StripGroups = new StripGroupHeader_t[VTX_Meshes[i].numStripGroups];
                Int32 StripGroupFilePosition     = MeshInputFilePosition + (Marshal.SizeOf(typeof(MeshHeader_t)) * i) + VTX_Meshes[i].stripGroupHeaderOffset;
                ModelFileLoader.ReadArray(ref StripGroups, StripGroupFilePosition);

                for (Int32 j = 0; j < VTX_Meshes[i].numStripGroups; j++)
                {
                    Vertex_t[] pVertexBuffer = new Vertex_t[StripGroups[j].numVerts];
                    ModelFileLoader.ReadArray(ref pVertexBuffer, StripGroupFilePosition + (Marshal.SizeOf(typeof(StripGroupHeader_t)) * j) + StripGroups[j].vertOffset);

                    UInt16[] Indices = new UInt16[StripGroups[j].numIndices];
                    ModelFileLoader.ReadArray(ref Indices, StripGroupFilePosition + (Marshal.SizeOf(typeof(StripGroupHeader_t)) * j) + StripGroups[j].indexOffset);

                    for (Int32 n = 0; n < Indices.Length; n++)
                    {
                        pIndices.Add(pVertexBuffer[Indices[n]].origMeshVertID + pStudioMesh.vertexoffset);
                    }
                }

                pMesh.SetTriangles(pIndices.ToArray(), i);
                String MaterialPath = String.Empty;

                for (Int32 j = 0; j < MDL_TDirectories.Length; j++)
                {
                    for (Int32 n = 0; n < ConfigLoader.ModFolders.Length; n++)
                    {
                        if (File.Exists(ConfigLoader.GamePath + "/" + ConfigLoader.ModFolders[n] + "/materials/" + MDL_TDirectories[j] + MDL_Textures[pStudioMesh.material] + ".vmt"))
                        {
                            MaterialPath = MDL_TDirectories[j] + MDL_Textures[pStudioMesh.material];
                        }
                    }
                }

                pMaterials.Add(MaterialLoader.Load(MaterialPath));
            }

            ;
            ModelObject.GetComponent <Renderer>().sharedMaterials = pMaterials.ToArray();
        }
        static void CreateModels()
        {
            BSP_Brushes = new List <GameObject>();

            for (Int32 Index = 0; Index < BSP_Models.Length; Index++)
            {
                GameObject Model = new GameObject("*" + Index);
                Model.transform.parent = BSP_WorldSpawn.transform;

                Dictionary <Int32, List <Int32> > MeshInfo = new Dictionary <Int32, List <Int32> >();

                for (Int32 i = BSP_Models[Index].FirstFace; i < BSP_Models[Index].FirstFace + BSP_Models[Index].NumFaces; i++)
                {
                    if (!MeshInfo.ContainsKey(BSP_TexData[BSP_TexInfo[BSP_Faces[i].TexInfo].TexData].NameStringTableID))
                    {
                        MeshInfo.Add(BSP_TexData[BSP_TexInfo[BSP_Faces[i].TexInfo].TexData].NameStringTableID, new List <Int32>());
                    }

                    MeshInfo[BSP_TexData[BSP_TexInfo[BSP_Faces[i].TexInfo].TexData].NameStringTableID].Add(i);
                    MeshInfo[BSP_TexData[BSP_TexInfo[BSP_Faces[i].TexInfo].TexData].NameStringTableID].Add(i);
                }

                for (Int32 i = 0; i < BSP_TextureStringData.Length; i++)
                {
                    if (!MeshInfo.ContainsKey(i))
                    {
                        continue;
                    }

                    List <Face> Faces = new List <Face>();

                    List <Vector3> Vertices  = new List <Vector3>();
                    List <Color32> Colors    = new List <Color32>();
                    List <Int32>   Triangles = new List <Int32>();
                    List <Vector2> UV        = new List <Vector2>();

                    for (Int32 j = 0; j < MeshInfo[i].Count; j++)
                    {
                        dface_t CFace = BSP_Faces[MeshInfo[i][j]];

                        if (CFace.DispInfo == -1)
                        {
                            Faces.Add(BSP_CFaces[MeshInfo[i][j]]);

                            Int32 PointOffset = Vertices.Count;
                            for (Int32 n = 0; n < Faces[j].Triangles.Length; n++)
                            {
                                Triangles.Add(Faces[j].Triangles[n] + PointOffset);
                            }

                            Vertices.AddRange(Faces[j].Vertices);
                            Colors.AddRange(Faces[j].Colors);
                            UV.AddRange(Faces[j].UV);
                        }
                    }

                    GameObject MeshObject = new GameObject(BSP_TextureStringData[i]);
                    MeshObject.transform.parent = Model.transform;
                    MeshObject.isStatic         = true;

                    MeshRenderer MeshRenderer = MeshObject.AddComponent <MeshRenderer>();
                    MeshRenderer.sharedMaterial    = MaterialLoader.Load(BSP_TextureStringData[i]);
                    MeshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
                    MeshRenderer.lightmapIndex     = ConfigLoader.CurrentLightmap;

                    if (MaterialLoader.HasAnimation)
                    {
                        AnimatedTexture AnimationControlScript = MeshObject.AddComponent <AnimatedTexture>();
                        MaterialLoader.SetupAnimations(ref AnimationControlScript);
                    }

                    Mesh Mesh = MeshObject.AddComponent <MeshFilter>().sharedMesh = new Mesh();
                    Mesh.SetVertices(Vertices);
                    Mesh.SetTriangles(Triangles, 0);
                    Mesh.SetColors(Colors);
                    Mesh.SetUVs(0, UV);

                    if (BSP_TextureStringData[i].Contains("TOOLS/"))
                    {
                        MeshRenderer.enabled = false;
                        BSP_Brushes.Add(MeshObject);
                    }
                    else
                    {
                        MeshObject.AddComponent <MeshCollider>();

                        List <Vector2> UV2          = new List <Vector2>();
                        Texture2D      Lightmap_tex = new Texture2D(1, 1);

                        CreateLightMap(Faces, ref Lightmap_tex, ref UV2);

                        if (ConfigLoader.LoadLightmapsAsTextureShader)
                        {
                            if (MeshRenderer.sharedMaterial != null)
                            {
                                MeshRenderer.sharedMaterial.SetTexture("_LightMap", Lightmap_tex);
                            }
                        }

                        Mesh.SetUVs(1, UV2);
                    }

                    Mesh.RecalculateNormals();
                }
            }
        }
        static void CreateDisplacements()
        {
            Dictionary <Int32, List <Int32> > MeshInfo = new Dictionary <Int32, List <Int32> >();

            for (Int32 i = 0; i < BSP_DispInfo.Length; i++)
            {
                if (!MeshInfo.ContainsKey(BSP_TexData[BSP_TexInfo[BSP_Faces[BSP_DispInfo[i].MapFace].TexInfo].TexData].NameStringTableID))
                {
                    MeshInfo.Add(BSP_TexData[BSP_TexInfo[BSP_Faces[BSP_DispInfo[i].MapFace].TexInfo].TexData].NameStringTableID, new List <Int32>());
                }

                MeshInfo[BSP_TexData[BSP_TexInfo[BSP_Faces[BSP_DispInfo[i].MapFace].TexInfo].TexData].NameStringTableID].Add(BSP_DispInfo[i].MapFace);
            }

            for (Int32 i = 0; i < BSP_TextureStringData.Length; i++)
            {
                if (!MeshInfo.ContainsKey(i))
                {
                    continue;
                }

                List <Face> Faces = new List <Face>();

                List <Vector3> Vertices  = new List <Vector3>();
                List <Color32> Colors    = new List <Color32>();
                List <Int32>   Triangles = new List <Int32>();
                List <Vector2> UV        = new List <Vector2>();

                for (Int32 j = 0; j < MeshInfo[i].Count; j++)
                {
                    if (BSP_Faces[MeshInfo[i][j]].DispInfo != -1)
                    {
                        Faces.Add(BSP_CDisp[BSP_Faces[MeshInfo[i][j]].DispInfo]);

                        Int32 PointOffset = Vertices.Count;
                        for (Int32 n = 0; n < Faces[j].Triangles.Length; n++)
                        {
                            Triangles.Add(Faces[j].Triangles[n] + PointOffset);
                        }

                        Vertices.AddRange(Faces[j].Vertices);
                        Colors.AddRange(Faces[j].Colors);
                        UV.AddRange(Faces[j].UV);
                    }
                }

                GameObject MeshObject = new GameObject(BSP_TextureStringData[i]);
                MeshObject.transform.localScale = new Vector3(1, 1, -1);
                MeshObject.transform.parent     = BSP_WorldSpawn.transform;
                MeshObject.isStatic             = true;

                MeshRenderer MeshRenderer = MeshObject.AddComponent <MeshRenderer>();
                MeshRenderer.sharedMaterial = MaterialLoader.Load(BSP_TextureStringData[i]);
                MeshRenderer.lightmapIndex  = ConfigLoader.CurrentLightmap;

                if (MaterialLoader.HasAnimation)
                {
                    AnimatedTexture AnimationControlScript = MeshObject.AddComponent <AnimatedTexture>();
                    MaterialLoader.SetupAnimations(ref AnimationControlScript);
                }

                Mesh Mesh = MeshObject.AddComponent <MeshFilter>().sharedMesh = new Mesh();
                MeshObject.AddComponent <MeshCollider>();

                Mesh.SetVertices(Vertices);
                Mesh.SetTriangles(Triangles, 0);
                Mesh.SetColors(Colors);
                Mesh.SetUVs(0, UV);

                {
                    List <Vector2> UV2          = new List <Vector2>();
                    Texture2D      Lightmap_tex = new Texture2D(1, 1);

                    CreateLightMap(Faces, ref Lightmap_tex, ref UV2);

                    if (ConfigLoader.LoadLightmapsAsTextureShader)
                    {
                        if (MeshRenderer.sharedMaterial != null)
                        {
                            MeshRenderer.sharedMaterial.SetTexture("_LightMap", Lightmap_tex);
                        }
                    }

                    Mesh.SetUVs(1, UV2);
                }

                Mesh.RecalculateNormals();
            }
        }
Esempio n. 4
0
        public void Configure(List <String> Data)
        {
            this.Data = Data;

            String Classname = Data[Data.FindIndex(n => n == "classname") + 1], Targetname = Data[Data.FindIndex(n => n == "targetname") + 1];

            name = Classname;

            //StudioMDLLoader.Load("editor/axis_helper").SetParent(transform, false);

            if (Data.Contains("origin"))
            {
                String[] Array = Data[Data.FindIndex(n => n == "origin") + 1].Split(' ');

                while (Array.Length != 3)
                {
                    Int32 TempIndex = Data.FindIndex(n => n == "origin") + 1;
                    Array = Data[Data.FindIndex(TempIndex, n => n == "origin") + 1].Split(' ');
                }

                transform.position = new Vector3(-Single.Parse(Array[0]), Single.Parse(Array[2]), -Single.Parse(Array[1])) * ConfigLoader.WorldScale;
            }

            if (Data.Contains("angles"))
            {
                String[] Array = Data[Data.FindIndex(n => n == "angles") + 1].Split(' ');
                if (!Classname.Contains("prop_"))
                {
                    EulerAngles    = new Vector3(Single.Parse(Array[0]), -Single.Parse(Array[1]), -Single.Parse(Array[2]));
                    EulerAngles.y -= 90;
                }
                else
                {
                    EulerAngles = new Vector3(-Single.Parse(Array[2]), Single.Parse(Array[1]), Single.Parse(Array[0]));
                }

                //float y = EulerAngles.y;

                /*if (Mathf.Approximately(y, 90) || Mathf.Approximately(y, 270))
                 *  EulerAngles.y += 90;
                 *
                 * if (Mathf.Approximately(y, 0) || Mathf.Approximately(y, 180))
                 *  EulerAngles.y -= 90;*/

                if (Data.Contains("pitch"))
                {
                    EulerAngles.x = -Single.Parse(Data[Data.FindIndex(n => n == "pitch") + 1]);
                }

                transform.eulerAngles = EulerAngles;
            }

            if (Classname.Contains("trigger"))
            {
                for (Int32 i = 0; i < transform.childCount; i++)
                {
                    GameObject Child = transform.GetChild(i).gameObject;
                    Child.SetActive(false);
                    Child.AddComponent <BoxCollider>().isTrigger = true;
                }
            }

            //if (Classname.Equals("point_viewcontrol"))
            //    gameObject.AddComponent<point_viewcontrol>();

            //3D Skybox
            if (Classname.Equals("sky_camera"))
            {
                //Setup 3DSkybox
                Camera    playerCamera = new GameObject("CameraPlayer").AddComponent <Camera>();
                CameraFly camFly       = playerCamera.gameObject.AddComponent <CameraFly>();
                camFly.skyScale    = float.Parse(Data[Data.FindIndex(n => n == "scale") + 1]);
                camFly.offset3DSky = transform.position;
                if (ConfigLoader.use3DSkybox)
                {
                    Camera skyCamera = gameObject.AddComponent <Camera>();
                    skyCamera.depth        = 0f;
                    skyCamera.farClipPlane = 70f;

                    playerCamera.depth      = 1f;
                    playerCamera.clearFlags = CameraClearFlags.Depth;
                    camFly.skyCamera        = skyCamera.transform;
                }
                //Setup 3DSkybox
            }
            //3D Skybox

            //Simple light

            /*if(Classname.Equals("shadow_control"))
             * {
             *  String[] color = Data[Data.FindIndex(n => n == "color") + 1].Split(' ');
             *  RenderSettings.subtractiveShadowColor = new Color32(Byte.Parse(color[0]), Byte.Parse(color[1]), Byte.Parse(color[2]), 255);
             * }*/

            if (Classname.Contains("light_") || Classname.Equals("light"))
            {
                if (Classname.Equals("light_environment"))
                {
                    if (RenderSettings.sun != null)
                    {
                        return;
                    }

                    String[] _ambient = Data[Data.FindIndex(n => n == "_ambient") + 1].Split(' ');
                    RenderSettings.ambientLight = new Color32(Byte.Parse(_ambient[0]), Byte.Parse(_ambient[1]), Byte.Parse(_ambient[2]), 255);
                }

                Light light = gameObject.AddComponent <Light>();

                if (Classname.Equals("light_spot"))
                {
                    light.type = LightType.Spot;
                }
                else if (Classname.Equals("light_environment"))
                {
                    RenderSettings.sun = light;
                    light.type         = LightType.Directional;
                }

                String[] _light = Data[Data.FindIndex(n => n == "_light") + 1].Split(' ');
                light.color = new Color32(Byte.Parse(_light[0]), Byte.Parse(_light[1]), Byte.Parse(_light[2]), 255);
                if (light.type == LightType.Point || light.type == LightType.Spot)
                {
                    String[] _distance = Data[Data.FindIndex(n => n == "_distance") + 1].Split(' ');

                    Int32 _distance_value = 0;
                    if (Int32.TryParse(_distance[0], out _distance_value))
                    {
                        light.range = _distance_value > 0 ? _distance_value * ConfigLoader.WorldScale : 10;
                    }
                    else
                    {
                        light.range = 10;
                    }

                    if (light.type == LightType.Spot)
                    {
                        String[] _inner_cone = Data[Data.FindIndex(n => n == "_inner_cone") + 1].Split(' ');
                        String[] _cone       = Data[Data.FindIndex(n => n == "_cone") + 1].Split(' ');
                        light.spotAngle = Int32.Parse(_inner_cone[0]) + Int32.Parse(_cone[0]);
                    }
                }

                light.lightmapBakeType = ConfigLoader.DynamicLight ? LightmapBakeType.Mixed : LightmapBakeType.Baked;
                if (ConfigLoader.DynamicLight)
                {
                    light.shadows = LightShadows.Soft;
                    if (light.type == LightType.Directional)
                    {
                        light.shadowBias       = 0.1f;
                        light.shadowNormalBias = 0;
                    }
                    else
                    {
                        light.shadowBias = 0.01f;
                    }
                }
            }
            //Simple light

            if (Classname.Equals("info_player_terrorist"))
            {
                StudioMDLLoader.Load("player/t_phoenix").SetParent(transform, false);
            }

            if (Classname.Equals("info_player_counterterrorist"))
            {
                StudioMDLLoader.Load("player/ct_urban").SetParent(transform, false);
            }

            if (Classname.Equals("info_player_start"))
            {
                StudioMDLLoader.Load("editor/playerstart").SetParent(transform, false);
            }

            if (Classname.Contains("weapon_"))
            {
                StudioMDLLoader.Load("weapons/w_rif_ak47").SetParent(transform, false);
            }

            if (Classname.Equals("hostage_entity"))//hostage_entity
            {
                String[] hostages = new[] { "characters/hostage_01", "characters/hostage_02", "characters/hostage_03", "characters/hostage_04" };
                StudioMDLLoader.Load(hostages[UnityEngine.Random.Range(0, hostages.Length)]).SetParent(transform, false);
            }

            if (Data.Contains("rendermode"))
            {
                if (Data[Data.FindIndex(n => n == "rendermode") + 1] == "10")
                {
                    for (Int32 i = 0; i < transform.childCount; i++)
                    {
                        GameObject Child = transform.GetChild(i).gameObject;
                        Child.GetComponent <Renderer>().enabled = false;
                    }
                }
            }

            if (Classname.Contains("prop_") || Classname.Contains("npc_"))
            {
                string ModelName = Data[Data.FindIndex(n => n == "model") + 1];
                StudioMDLLoader.Load(ModelName).SetParent(transform, false);
            }

            if (Classname.Equals("infodecal"))
            {
                //This is just an example, you need to implement a complete decal system.
                if (ConfigLoader.LoadInfoDecals)
                {
                    String   TextureName = Data[Data.FindIndex(n => n == "texture") + 1];
                    Material DecalMat    = MaterialLoader.Load(TextureName);

                    int x = DecalMat.mainTexture.width;
                    int y = DecalMat.mainTexture.height;

                    float  decalScale = 1;
                    String Value      = MaterialLoader.GetParametr("$decalscale");

                    if (!String.IsNullOrEmpty(Value))
                    {
                        decalScale *= float.Parse(Value);
                    }

                    SpriteRenderer DecalRender = gameObject.AddComponent <SpriteRenderer>();
                    DecalRender.sprite = Sprite.Create((Texture2D)DecalMat.mainTexture, new Rect(0, 0, x, y), new Vector2(0.5f, 0.5f), 1);

                    DecalRender.flipX = true;
                    DecalRender.flipY = true;

                    transform.localScale = new Vector3(decalScale * ConfigLoader.WorldScale, decalScale * ConfigLoader.WorldScale, 1);
                }
            }
        }