public static ICollider GetConvexColliderForHlmt(H2vMap map, HaloModelTag hlmt, int damageLevel = 0)
{
if (map.TryGetTag(hlmt.ColliderId, out var coll) == false)
{
// TODO: determine why collider can be invalid, if it's expected
return(DefaultCollider);
}
if (coll.ColliderComponents.Length == 0 ||
coll.ColliderComponents[0].DamageLevels.Length <= damageLevel ||
coll.ColliderComponents[0].DamageLevels[damageLevel].Parts.Length == 0)
{
Console.WriteLine($"No colliders defined in coll[{hlmt.ColliderId}] for damage level {damageLevel}");
return(DefaultCollider);
}
var colliderMeshes = new List <Vector3[]>();
foreach (var component in coll.ColliderComponents)
{
var container = component.DamageLevels[damageLevel];
foreach (var info in container.Parts)
{
colliderMeshes.Add(info.Vertices.Select(v => new Vector3(v.x, v.y, v.z)).ToArray());
}
}
var collider = new ConvexModelCollider(colliderMeshes);
return(collider);
}
public static ActorSpawn?SpawnPointFromStartingLocation(H2vMap map,
ScenarioTag.AiSquadDefinition.StartingLocation loc)
{
var entity = new ActorSpawn();
entity.FriendlyName = loc.Description;
var charIndex = loc.CharacterIndex;
if (charIndex == ushort.MaxValue)
{
charIndex = map.Scenario.AiSquadDefinitions[loc.SquadIndex].CharacterIndex;
}
TagRef <HaloModelTag> model = default;
string modelDesc = entity.FriendlyName;
if (charIndex != ushort.MaxValue)
{
var character = map.GetTag(map.Scenario.CharacterDefinitions[charIndex].CharacterReference);
if (map.TryGetTag <BaseTag>(character.Unit, out var unit) == false)
{
return(null);
}
modelDesc = $"[{unit.Id}] {unit.Name}";
if (unit is BipedTag biped)
{
model = biped.Model;
}
else if (unit is VehicleTag vehicle)
{
model = vehicle.Hlmt;
}
}
else
{
// Use some default model?
return(null);
}
var comp = new RenderModelComponent(entity, new Model <BitmapTag>
{
Note = modelDesc,
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows,
Meshes = MeshFactory.GetRenderModel(map, model),
RenderLayer = RenderLayers.Scripting
});
var orientation = Quaternion.CreateFromAxisAngle(EngineGlobals.Up, loc.Rotation);
var xform = new TransformComponent(entity, loc.Position, orientation);
var originalTag = new OriginalTagComponent(entity, loc);
entity.SetComponents(new Component[] { xform, comp, originalTag });
return(entity);
}
public static void AddLocators(H2vMap map, Scene destination)
{
var scenario = map.GetLocalTagsOfType <ScenarioTag>().First();
//foreach (var obj in scenario.Obj96s)
//{
// AddAtLocation(96, obj.Position, colors[0], destination);
//}
}
public static Machine FromTag(H2vMap map, ScenarioTag scenario, ScenarioTag.MachineryInstance instance)
{
var scenery = new Machine();
scenery.FriendlyName = "Machine_" + instance.MachineryDefinitionIndex;
if (instance.MachineryDefinitionIndex == ushort.MaxValue)
{
Console.WriteLine($"MACH index out of range");
return(scenery);
}
var id = scenario.MachineryDefinitions[instance.MachineryDefinitionIndex].Machinery;
var tag = map.GetTag(id);
scenery.FriendlyName = tag.Name;
var orientation = QuaternionExtensions.FromH2vOrientation(instance.Orientation);
var xform = new TransformComponent(scenery, instance.Position, orientation);
var components = new List <Component>();
if (tag.Model != uint.MaxValue)
{
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name}",
Meshes = MeshFactory.GetRenderModel(map, tag.Model),
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows
}));
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name} bones",
Meshes = MeshFactory.GetBonesModel(map, tag.Model),
Flags = ModelFlags.Wireframe,
RenderLayer = RenderLayers.Debug
}));
var body = PhysicsComponentFactory.CreateKinematicRigidBody(scenery, xform, map, tag.Model);
if (body != null)
{
components.Add(body);
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Meshes = MeshFactory.GetRenderModel(body.Collider, new Vector4(1f, 0f, 1f, 1f)),
Flags = ModelFlags.Wireframe | ModelFlags.IsStatic,
RenderLayer = RenderLayers.Collision
}));
}
}
scenery.SetComponents(xform, components.ToArray());
return(scenery);
}
private static void PopulateVehicle(Vehicle item, H2vMap map, TransformComponent xform, VehicleTag vehi)
{
item.FriendlyName = vehi.Name;
item.SetComponents(xform,
PhysicsComponentFactory.CreateDynamicRigidBody(item, xform, map, vehi.Hlmt),
new RenderModelComponent(item, new Model <BitmapTag>
{
Note = $"[{vehi.Id}] {vehi.Name}",
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows,
Meshes = MeshFactory.GetRenderModel(map, vehi.Hlmt)
}));
}
public static Bloc FromTag(H2vMap map, ScenarioTag scenario, ScenarioTag.BlocInstance instance)
{
var scenery = new Bloc();
var components = new List <Component>();
var bloc = scenario.BlocDefinitions[instance.BlocDefinitionIndex].Bloc;
var tag = map.GetTag(bloc);
scenery.FriendlyName = tag.Name;
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name}",
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows,
Meshes = MeshFactory.GetRenderModel(map, tag.PhysicalModel),
ColorChangeData = PackColorChange(instance)
}));
var orientation = QuaternionExtensions.FromH2vOrientation(instance.Orientation);
var xform = new TransformComponent(scenery, instance.Position, orientation);
var body = PhysicsComponentFactory.CreateDynamicRigidBody(scenery, xform, map, tag.PhysicalModel);
if (body != null)
{
components.Add(body);
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"bloc//{scenery.FriendlyName}-collision",
Meshes = MeshFactory.GetRenderModel(body.Collider, new Vector4(0.19f, 0.47f, 0.15f, 1f)),
Flags = ModelFlags.Wireframe | ModelFlags.IsStatic,
RenderLayer = RenderLayers.Collision
}));
}
var comOffset = Vector3.Zero;
if (map.TryGetTag(tag.PhysicalModel, out var hlmt) &&
map.TryGetTag(hlmt.PhysicsModel, out var phmo) &&
phmo.BodyParameters.Length > 0)
{
comOffset = phmo.BodyParameters[0].CenterOfMass;
}
components.Add(new BoundsComponent(scenery, comOffset - new Vector3(0.02f), comOffset + new Vector3(0.02f), new Vector4(1f, 1f, 0, 1f)));
components.Add(new BoundsComponent(scenery, new Vector3(-0.02f), new Vector3(0.02f), new Vector4(0, 1f, 0, 1f)));
components.Add(new OriginalTagComponent(scenery, instance));
scenery.SetComponents(xform, components.ToArray());
return(scenery);
}
public static Scenery FromTag(H2vMap map, ScenarioTag scenario, ScenarioTag.SkyboxInstance instance)
{
var scenery = new Scenery();
scenery.FriendlyName = "Skybox_" + instance.Skybox.Id;
var tag = map.GetTag(instance.Skybox);
if (map.TryGetTag(tag.Model, out var model) == false)
{
Console.WriteLine($"No MODE[{tag.Model}] found for SKY[{instance.Skybox}]");
return(scenery);
}
var meshes = new List <ModelMesh>();
var partIndex = model.Components.First().DamageLevels.First().HighestPieceIndex;
meshes.AddRange(model.Parts[partIndex].Model.Meshes);
var renderModelMeshes = new List <Mesh <BitmapTag> >(meshes.Count);
foreach (var mesh in meshes)
{
var mat = map.CreateMaterial(mesh);
renderModelMeshes.Add(new Mesh <BitmapTag>()
{
Compressed = mesh.Compressed,
ElementType = mesh.ElementType,
Indicies = mesh.Indices,
Note = mesh.Note,
RawData = mesh.RawData,
Verticies = mesh.Verticies,
Material = mat
});
}
var comp = new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name}",
Meshes = renderModelMeshes.ToArray(),
Flags = ModelFlags.IsSkybox
});
var components = new List <Component>();
components.Add(comp);
scenery.SetComponents(components.ToArray());
return(scenery);
}
private static List <Entity> CreateFromItemCollection(H2vMap map, ItemCollectionTag itmc, ScenarioTag.ItemCollectionPlacement instance)
{
var entities = new List <Entity>();
// I've only seen 1 item collections though
foreach (var item in itmc.Items)
{
if (map.TryGetTag <BaseTag>(item.ItemTag, out var tag) == false)
{
throw new Exception("No tag found for weap/equip");
}
TagRef <HaloModelTag> itemHlmt = default;
if (tag is WeaponTag weap)
{
itemHlmt = weap.Hlmt;
}
if (tag is EquipmentTag eqip)
{
itemHlmt = eqip.Hlmt;
}
if (itemHlmt == default)
{
continue;
}
var entity = new Item();
entity.FriendlyName = tag.Name;
var renderModel = new RenderModelComponent(entity, new Model <BitmapTag>
{
Note = $"[{itmc.Id}] {itmc.Name}",
//Position = instance.Position,
//Orientation = baseRotation,
//Scale = new Vector3(1.3f),
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows,
Meshes = MeshFactory.GetRenderModel(map, itemHlmt)
});
var xform = new TransformComponent(entity, instance.Position, QuaternionExtensions.FromH2vOrientation(instance.Orientation));
var body = PhysicsComponentFactory.CreateDynamicRigidBody(entity, xform, map, itemHlmt);
entity.SetComponents(xform, renderModel, body);
entities.Add(entity);
}
return(entities);
}
public TagTranslator(H2vMap scene)
{
this.scene = scene;
this.cache = new TagDataCache();
foreach (var entry in scene.TagIndex)
{
// TODO: Tag can be null here because we don't process all tags yet
if (scene.TryGetTag <BaseTag>(entry.ID, out var tag) && tag != null)
{
this.AddTag(tag);
}
}
}
public static Vehicle CreateFromVehicleInstance(H2vMap map, ScenarioTag scenario, ScenarioTag.VehicleInstance instance)
{
var item = new Vehicle();
item.FriendlyName = "Vehicle_" + instance.Index;
var def = scenario.VehicleDefinitions[instance.Index];
if (map.TryGetTag(def.Vehicle, out var vehi) == false)
{
throw new Exception("No tag found for vehi reference");
}
var xform = new TransformComponent(item, instance.Position, QuaternionExtensions.FromH2vOrientation(instance.Orientation));
PopulateVehicle(item, map, xform, vehi);
return(item);
}
public Material <BitmapTag> CreateMaterial(H2vMap map, ModelMesh mesh)
{
if (createdMaterials.TryGetValue(mesh.Shader.Id, out var mat))
{
return(mat);
}
mat = new Material <BitmapTag>
{
DiffuseColor = VectorExtensions.RandomColor()
};
if (map.TryGetTag(mesh.Shader, out var shader) == false)
{
return(mat);
}
var args = shader.Arguments[0];
var templateTag = map.GetTag(args.ShaderTemplate);
var templateKey = templateTag.Name;
if (mappingConfig.Aliases.TryGetValue(templateKey, out var alias))
{
templateKey = alias.Alias;
}
if (mappingConfig.Mappings.TryGetValue(templateKey, out var mapping))
{
PopulateFromMapping(map, mat, args, mapping);
return(mat);
}
if (stemsWarned.Contains(shader.ShaderTemplate.Id) == false)
{
Console.WriteLine($"Using heuristic for shader '{shader.Name}' stem[{shader.ShaderTemplate.Id}]");
stemsWarned.Add(shader.ShaderTemplate.Id);
}
PopulateFromHeuristic(map, mat, shader);
return(mat);
}
private static List <Entity> CreateFromVehicleCollection(H2vMap map, VehicleCollectionTag vehc, ScenarioTag.ItemCollectionPlacement instance)
{
var entities = new List <Entity>();
// I've only seen 1 item collections though
foreach (var vehicle in vehc.VehicleReferences)
{
if (map.TryGetTag(vehicle.Vehicle, out var vehi) == false)
{
throw new Exception("No tag found for vehc reference");
}
var entity = new Vehicle();
entity.FriendlyName = vehi.Name;
var xform = new TransformComponent(entity, instance.Position, QuaternionExtensions.FromH2vOrientation(instance.Orientation));
PopulateVehicle(entity, map, xform, vehi);
entities.Add(entity);
}
return(entities);
}
public static ICollider GetTriangleColliderForHlmt(H2vMap map, HaloModelTag hlmt, int damageLevel = 0)
{
if (hlmt.ColliderId.IsInvalid)
{
return(DefaultCollider);
}
if (map.TryGetTag(hlmt.ColliderId, out var coll) == false)
{
Console.WriteLine($"Couldn't find COLL[{hlmt.ColliderId.Id}]");
return(DefaultCollider);
}
if (coll.ColliderComponents.Length == 0 ||
coll.ColliderComponents[0].DamageLevels.Length <= damageLevel ||
coll.ColliderComponents[0].DamageLevels[damageLevel].Parts.Length == 0)
{
Console.WriteLine($"No colliders defined in coll[{hlmt.ColliderId}] for damage level {damageLevel}");
return(DefaultCollider);
}
var colliderMeshes = new List <TriangleMeshCollider>();
foreach (var component in coll.ColliderComponents)
{
var container = component.DamageLevels[damageLevel];
// TODO material lookup
colliderMeshes.Add(TriangleMeshCollider.Create(container.Parts, i => - 1));
}
// TODO: relative transforms?
var collider = new TriangleModelCollider()
{
MeshColliders = colliderMeshes.ToArray()
};
return(collider);
}
private void PopulateFromMapping(
H2vMap map,
Material <BitmapTag> mat,
ShaderTag.ShaderTemplateArguments args,
MaterialMapping mapping)
{
mat.NormalMap = args.GetBitmap(map, mapping.NormalMapIndex);
mat.NormalMapScale = args.GetInput(mapping.NormalScaleIndex);
mat.DiffuseMap = args.GetBitmap(map, mapping.DiffuseMapIndex);
if (mapping.DiffuseColor.Length == 4)
{
mat.DiffuseColor = new Vector4(mapping.DiffuseColor[0], mapping.DiffuseColor[1], mapping.DiffuseColor[2], mapping.DiffuseColor[3]);
}
else if (mapping.DiffuseColor.Length == 1)
{
mat.DiffuseColor = new Vector4(mapping.DiffuseColor[0]);
}
mat.DetailMap1 = args.GetBitmap(map, mapping.Detail1MapIndex);
mat.Detail1Scale = args.GetInput(mapping.Detail1ScaleIndex);
mat.DetailMap2 = args.GetBitmap(map, mapping.Detail2MapIndex);
mat.Detail2Scale = args.GetInput(mapping.Detail2ScaleIndex);
mat.EmissiveMap = args.GetBitmap(map, mapping.EmissiveMapIndex);
mat.EmissiveArguments = args.GetInput(mapping.EmissiveArgumentsIndex);
mat.EmissiveType = mapping.EmissiveType;
mat.AlphaMap = args.GetBitmap(map, mapping.AlphaMapIndex);
mat.AlphaFromRed = mapping.AlphaFromRed;
mat.ColorChangeMask = args.GetBitmap(map, mapping.ColorChangeMaskMapIndex);
mat.SpecularMap = args.GetBitmap(map, mapping.SpecularMapIndex);
}
public static Entity FromTag(H2vMap map, ScenarioTag scenario, ScenarioTag.ItemCollectionPlacement instance)
{
if (instance.ItemCollectionReference.IsInvalid)
{
return(new Scenery());
}
if (map.TryGetTag <BaseTag>(instance.ItemCollectionReference, out var itemTag) == false)
{
throw new Exception("Unable to load itmc");
}
if (itemTag is ItemCollectionTag itmc)
{
return(CreateFromItemCollection(map, itmc, instance)[0]);
}
if (itemTag is VehicleCollectionTag vehc)
{
return(CreateFromVehicleCollection(map, vehc, instance)[0]);
}
return(new Scenery());
}
public static RigidBodyComponent CreateDynamicRigidBody(Entity parent, TransformComponent transform, H2vMap map, TagRef <HaloModelTag> hlmtRef, int damageLevel = 0)
{
if (map.TryGetTag(hlmtRef, out var hlmt) == false)
{
throw new Exception($"Couldn't find HLMT[{hlmtRef.Id}]");
}
RigidBodyComponent body;
if (map.TryGetTag(hlmt.PhysicsModel, out var phmo) && phmo.BodyParameters.Length > 0)
{
var param = phmo.BodyParameters[0];
body = new RigidBodyComponent(parent, transform, param.InertiaTensor, param.Mass, param.CenterOfMass);
body.Collider = ColliderFactory.GetAggregateColliderForPhmo(map, phmo, damageLevel);
}
else
{
body = new RigidBodyComponent(parent, transform);
}
return(body);
}
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);
}
public static Scenery FromTag(H2vMap map, ScenarioTag scenario, ScenarioTag.SceneryInstance instance)
{
var scenery = new Scenery();
scenery.FriendlyName = "Scenery_" + instance.SceneryDefinitionIndex;
var id = scenario.SceneryDefinitions[instance.SceneryDefinitionIndex].Scenery;
var tag = map.GetTag(id);
scenery.FriendlyName = tag.Name;
var meshes = MeshFactory.GetRenderModel(map, tag.Model);
var transparentMeshes = new List <Mesh <BitmapTag> >(meshes.Length);
var renderModelMeshes = new List <Mesh <BitmapTag> >(meshes.Length);
foreach (var mesh in meshes)
{
var mat = mesh.Material;
if (mat.AlphaMap == null)
{
renderModelMeshes.Add(mesh);
}
else
{
transparentMeshes.Add(mesh);
}
}
var components = new List <Component>();
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name}",
Meshes = renderModelMeshes.ToArray(),
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows
}));
foreach (var transparentMesh in transparentMeshes)
{
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"[{tag.Id}] {tag.Name}",
Meshes = new[] { transparentMesh },
Flags = ModelFlags.IsTransparent
}));
}
var orientation = QuaternionExtensions.FromH2vOrientation(instance.Orientation);
var xform = new TransformComponent(scenery, instance.Position, orientation);
var body = PhysicsComponentFactory.CreateStaticRigidBody(scenery, xform, map, tag.Model);
if (body != null)
{
components.Add(body);
components.Add(new RenderModelComponent(scenery, new Model <BitmapTag>
{
Note = $"scenery//{scenery.FriendlyName}-collision",
Meshes = MeshFactory.GetRenderModel(body.Collider, new Vector4(0.9f, 0.5f, .24f, 1f)),
Flags = ModelFlags.Wireframe | ModelFlags.IsStatic,
RenderLayer = RenderLayers.Collision
}));
}
scenery.SetComponents(xform, components.ToArray());
return(scenery);
}
public static ICollider GetAggregateColliderForPhmo(H2vMap map, PhysicsModelTag phmo, int damageLevel = 0)
{
var collider = new AggregateCollider();
var colliderMeshes = new List <Vector3[]>();
var convexModelMaterial = -1;
foreach (var mesh in phmo.PolyhedraDefinitions)
{
var meshVerts = new List <Vector3>();
for (var i = 0; i < mesh.CountA; i++)
{
var x1 = mesh.FloatsC[i * 12 + 0];
var x2 = mesh.FloatsC[i * 12 + 1];
var x3 = mesh.FloatsC[i * 12 + 2];
var x4 = mesh.FloatsC[i * 12 + 3];
// TODO: figure out inidcator on how many polyhedra to read
if (x1 + x2 + x3 + x4 == 0)
{
break;
}
var y1 = mesh.FloatsC[i * 12 + 4];
var y2 = mesh.FloatsC[i * 12 + 5];
var y3 = mesh.FloatsC[i * 12 + 6];
var y4 = mesh.FloatsC[i * 12 + 7];
var z1 = mesh.FloatsC[i * 12 + 8];
var z2 = mesh.FloatsC[i * 12 + 9];
var z3 = mesh.FloatsC[i * 12 + 10];
var z4 = mesh.FloatsC[i * 12 + 11];
meshVerts.Add(new Vector3(x1, y1, z1));
meshVerts.Add(new Vector3(x2, y2, z2));
meshVerts.Add(new Vector3(x3, y3, z3));
meshVerts.Add(new Vector3(x4, y4, z4));
}
if (meshVerts.Count > 0)
{
colliderMeshes.Add(meshVerts.ToArray());
convexModelMaterial = mesh.MaterialIndexMaybe;
}
}
foreach (var p in phmo.PolyhedraAlternativeDefinitions)
{
var meshVerts = new List <Vector3>();
var x1 = p.Floats[0];
var x2 = p.Floats[1];
var x3 = p.Floats[2];
var x4 = p.Floats[3];
var y1 = p.Floats[4];
var y2 = p.Floats[5];
var y3 = p.Floats[6];
var y4 = p.Floats[7];
var z1 = p.Floats[8];
var z2 = p.Floats[9];
var z3 = p.Floats[10];
var z4 = p.Floats[11];
meshVerts.Add(new Vector3(x1, y1, z1));
meshVerts.Add(new Vector3(x2, y2, z2));
meshVerts.Add(new Vector3(x3, y3, z3));
meshVerts.Add(new Vector3(x4, y4, z4));
//colliderMeshes.Add(meshVerts.ToArray());
}
if (colliderMeshes.Count > 0)
{
var convexModel = new ConvexModelCollider(colliderMeshes);
convexModel.PhysicsMaterial = convexModelMaterial;
collider.AddCollider(convexModel);
}
foreach (var box in phmo.BoxDefinitions)
{
var xform = new Transform();
xform.UseTransformationMatrix(box.Transform);
var boxCollider = new BoxCollider(xform, box.HalfWidthsMaybe);
boxCollider.PhysicsMaterial = box.MaterialIndexMaybe;
collider.AddCollider(boxCollider);
}
return(collider);
}
public static Terrain FromBspData(H2vMap map, BspTag tag)
{
var terrain = new Terrain();
terrain.FriendlyName = tag.Name;
var meshes = new List <ModelMesh>();
foreach (var chunk in tag.RenderChunks)
{
meshes.AddRange(chunk.Model.Meshes);
}
var transparentMeshes = new List <Mesh <BitmapTag> >(meshes.Count);
var renderModelMeshes = new List <Mesh <BitmapTag> >(meshes.Count);
foreach (var mesh in 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 components = new List <Component>();
components.Add(new RenderModelComponent(terrain, new Model <BitmapTag>
{
Meshes = renderModelMeshes.ToArray(),
Flags = ModelFlags.Diffuse | ModelFlags.ReceivesShadows | ModelFlags.IsStatic
}));
foreach (var mesh in transparentMeshes)
{
components.Add(new RenderModelComponent(terrain, new Model <BitmapTag>
{
Meshes = new[] { mesh },
Flags = ModelFlags.IsTransparent | ModelFlags.IsStatic
}));
}
var collisionTerrain = PhysicsComponentFactory.CreateTerrain(terrain, tag.CollisionInfos, tag.Shaders);
components.Add(collisionTerrain);
components.Add(new RenderModelComponent(terrain, new Model <BitmapTag>
{
Meshes = MeshFactory.GetRenderModel(collisionTerrain.Collider),
Flags = ModelFlags.Wireframe | ModelFlags.IsStatic,
RenderLayer = RenderLayers.Collision
}));
components.Add(new TransformComponent(terrain, Vector3.Zero));
terrain.SetComponents(components);
return(terrain);
}
public static BitmapTag GetBitmap(this ShaderTag.ShaderTemplateArguments args, H2vMap map, int?index)
{
if (index.HasValue == false)
{
return(null);
}
if (map.TryGetTag(args.BitmapArguments[index.Value].Bitmap, out var bitm))
{
return(bitm);
}
return(null);
}
public Material <BitmapTag> CreateMaterial(H2vMap map, ModelMesh mesh) => new Material <BitmapTag>();
public static Actor FromStartingLocation(H2vMap map,
ScenarioTag.AiSquadDefinition.StartingLocation loc)
{
var entity = new Actor();
entity.FriendlyName = loc.Description;
var charIndex = loc.CharacterIndex;
if (charIndex == ushort.MaxValue)
{
charIndex = map.Scenario.AiSquadDefinitions[loc.SquadIndex].CharacterIndex;
}
if (charIndex == ushort.MaxValue)
{
throw new Exception("Couldn't determine character to create");
}
var character = map.GetTag(map.Scenario.CharacterDefinitions[charIndex].CharacterReference);
if (map.TryGetTag <BaseTag>(character.Unit, out var unit) == false)
{
return(entity);
}
TagRef <HaloModelTag> model = default;
if (unit is BipedTag biped)
{
model = biped.Model;
}
else if (unit is VehicleTag vehicle)
{
model = vehicle.Hlmt;
}
var comp = new RenderModelComponent(entity, new Model <BitmapTag>
{
Note = $"[{unit.Id}] {unit.Name}",
Flags = ModelFlags.Diffuse | ModelFlags.CastsShadows | ModelFlags.ReceivesShadows,
Meshes = MeshFactory.GetRenderModel(map, model)
});
var boneComp = new RenderModelComponent(entity, new Model <BitmapTag>
{
Note = $"[{unit.Id}] {unit.Name} Bones",
Flags = ModelFlags.Wireframe,
Meshes = MeshFactory.GetBonesModel(map, model),
RenderLayer = RenderLayers.Debug
});
var orientation = Quaternion.CreateFromAxisAngle(EngineGlobals.Up, loc.Rotation);
var xform = new TransformComponent(entity, loc.Position, orientation);
// TODO: add back
var body = PhysicsComponentFactory.CreateDynamicRigidBody(entity, xform, map, model);
var comOffset = Vector3.Zero;
if (map.TryGetTag(model, out var hlmt) &&
map.TryGetTag(hlmt.PhysicsModel, out var phmo) &&
phmo.BodyParameters.Length > 0)
{
comOffset = phmo.BodyParameters[0].CenterOfMass;
}
var centerOfMass = new BoundsComponent(entity, comOffset - new Vector3(0.02f), comOffset + new Vector3(0.02f), new Vector4(1f, 1f, 0, 1f));
var origin = new BoundsComponent(entity, new Vector3(-0.02f), new Vector3(0.02f), new Vector4(0, 1f, 0, 1f));
var originalTag = new OriginalTagComponent(entity, loc);
entity.SetComponents(xform, comp, boneComp, centerOfMass, origin, originalTag);
return(entity);
}
private static void PopulateFromHeuristic(H2vMap map, Material <BitmapTag> mat, ShaderTag shader)
{
foreach (var info in shader.BitmapInfos)
{
if (info.AlphaBitmap.IsInvalid == false && mat.AlphaMap == default)
{
map.TryGetTag(info.AlphaBitmap, out var alpha);
mat.AlphaMap = alpha;
}
if (info.DiffuseBitmap.IsInvalid == false && mat.DiffuseMap == default)
{
map.TryGetTag(info.DiffuseBitmap, out var diff);
mat.DiffuseMap = diff;
}
}
var args = shader.Arguments[0];
var bitmRefs = args.BitmapArguments;
for (int i = 0; i < bitmRefs.Length; i++)
{
var bitmRef = bitmRefs[i];
if (map.TryGetTag(bitmRef.Bitmap, out var bitm) == false)
{
continue;
}
if (bitm == mat.DiffuseMap || bitm == mat.AlphaMap)
{
continue;
}
if (bitm.TextureUsage == TextureUsage.Bump || bitm.Name.Contains("bump"))
{
mat.NormalMap = bitm;
mat.NormalMapScale = args.GetInput(0, new Vector4(1, 1, 0, 0));
continue;
}
if (bitm.TextureUsage == TextureUsage.Diffuse)
{
if (mat.DiffuseMap == default)
{
mat.DiffuseMap = bitm;
continue;
}
}
if (bitm.TextureUsage == TextureUsage.Diffuse || bitm.TextureUsage == TextureUsage.Detail || bitm.Name.Contains("detail"))
{
// HACK: if texture is small, it's likely not a detail map
if (bitm.TextureInfos[0].Width <= 16 || bitm.TextureInfos[0].Height <= 16)
{
continue;
}
int inputOffset = i;
Vector4 detailScale = Vector4.Zero;
while ((detailScale.X < 1 || detailScale.Y < 1 || detailScale.Z != 0 || detailScale.W != 0) &&
inputOffset < args.ShaderInputs.Length)
{
detailScale = args.ShaderInputs[inputOffset];
inputOffset++;
}
if (mat.DetailMap1 == null)
{
mat.DetailMap1 = bitm;
mat.Detail1Scale = detailScale;
continue;
}
else if (mat.DetailMap2 == null)
{
mat.DetailMap2 = bitm;
mat.Detail2Scale = detailScale;
continue;
}
}
}
}
private static void WriteInfo <TProp>(H2vMap map, Expression <Func <ScenarioTag.AiSquadDefinition, TProp> > accessor)
{
var vals = map.Scenario.AiSquadDefinitions;
WriteInfo(vals, accessor);
}
public static RigidBodyComponent CreateKinematicRigidBody(Entity parent, TransformComponent transform, H2vMap map, TagRef <HaloModelTag> hlmtRef, int damageLevel = 0)
{
if (map.TryGetTag(hlmtRef, out var hlmt) == false)
{
throw new Exception($"Couldn't find HLMT[{hlmtRef.Id}]");
}
RigidBodyComponent body;
if (!map.TryGetTag(hlmt.PhysicsModel, out var phmo) || phmo.BodyParameters.Length == 0)
{
return(null);
}
var param = phmo.BodyParameters[0];
body = new RigidBodyComponent(parent, transform, param.InertiaTensor, param.Mass, param.CenterOfMass)
{
IsDynamic = false,
Collider = ColliderFactory.GetTriangleColliderForHlmt(map, hlmt, damageLevel)
};
return(body);
}
public EntityCreator(H2vMap map)
{
this.Map = map;
}
public static StaticGeometryComponent CreateStaticRigidBody(Entity parent, TransformComponent transform, H2vMap map, TagRef <HaloModelTag> hlmtRef, int damageLevel = 0)
{
if (map.TryGetTag(hlmtRef, out var hlmt) == false)
{
return(null);
}
return(new StaticGeometryComponent(parent, transform)
{
Collider = ColliderFactory.GetTriangleColliderForHlmt(map, hlmt, damageLevel)
});
}
