Example #1
0
 public Entity FromInstancedGeometry(BspTag bsp, BspTag.InstancedGeometryInstance instance)
 {
     return(SceneryFactory.FromInstancedGeometry(this.Map, bsp, instance));
 }
Example #2
0
        public static Scenery FromInstancedGeometry(H2vMap map, BspTag bsp, BspTag.InstancedGeometryInstance instance)
        {
            var scenery = new Scenery();

            scenery.FriendlyName = "Geom";

            if (instance.Index >= bsp.InstancedGeometryDefinitions.Length)
            {
                return(scenery);
            }

            var def = bsp.InstancedGeometryDefinitions[instance.Index];

            var transparentMeshes = new List <Mesh <BitmapTag> >(def.Model.Meshes.Length);
            var renderModelMeshes = new List <Mesh <BitmapTag> >(def.Model.Meshes.Length);

            foreach (var mesh in def.Model.Meshes)
            {
                var mat = map.CreateMaterial(mesh);

                var renderMesh = new Mesh <BitmapTag>()
                {
                    Compressed  = mesh.Compressed,
                    ElementType = mesh.ElementType,
                    Indicies    = mesh.Indices,
                    Note        = mesh.Note,
                    RawData     = mesh.RawData,
                    Verticies   = mesh.Verticies,

                    Material = mat
                };

                if (mat.AlphaMap == null)
                {
                    renderModelMeshes.Add(renderMesh);
                }
                else
                {
                    transparentMeshes.Add(renderMesh);
                }
            }

            var comps = new List <Component>();

            comps.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
            {
                Note   = $"[{bsp.Id}] {bsp.Name}//instanced//{instance.Index}",
                Meshes = renderModelMeshes.ToArray(),
                Flags  = ModelFlags.Diffuse | ModelFlags.ReceivesShadows | ModelFlags.IsStatic
            }));

            foreach (var mesh in transparentMeshes)
            {
                comps.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
                {
                    Note   = $"[{bsp.Id}] {bsp.Name}//instanced//{instance.Index}",
                    Meshes = new[] { mesh },
                    Flags  = ModelFlags.IsTransparent | ModelFlags.IsStatic
                }));
            }

            var xform = new TransformComponent(scenery, instance.Position, QuaternionExtensions.From3x3Mat(instance.RotationMatrix))
            {
                Scale = new Vector3(instance.Scale),
            };

            comps.Add(xform);

            if (def.Vertices.Length > 0)
            {
                var geom = PhysicsComponentFactory.CreateStaticGeometry(scenery, xform, def, bsp.Shaders);
                comps.Add(geom);

                comps.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
                {
                    Note        = $"[{bsp.Id}] {bsp.Name}//instanced//{instance.Index}-collision",
                    Meshes      = MeshFactory.GetRenderModel(geom.Collider, new Vector4(0f, 1f, 1f, 1f)),
                    Flags       = ModelFlags.Wireframe | ModelFlags.IsStatic,
                    RenderLayer = RenderLayers.Collision
                }));
            }

            xform.UpdateDerivedData();

            scenery.SetComponents(comps);

            return(scenery);
        }