/// <summary>
/// Ray Constructor
/// </summary>
public Ray() : base()
{
Material = new Material()
{
Color = new Vector4(1, 1, 1, 1),
Diffuse = new Vector3(1, 1, 1),
Specular = new Vector3(1, 1, 1),
Shininess = 64.0f
};
//Create Line
line = new Mesh();
line.Positions.Add(new Vector3(0));
line.Positions.Add(new Vector3(0));
line.Normals.Add(new Vector3(0));
line.Normals.Add(new Vector3(0));
line.UVs.Add(new Vector2(0));
line.UVs.Add(new Vector2(0));
line.Indices.Add(0);
line.Indices.Add(1);
Name = "Ray";
//Add Line
Meshes.Add(line);
}
/// <summary>
/// Slider
/// </summary>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <param name="Width"></param>
/// <param name="Height"></param>
/// <param name="Min"></param>
/// <param name="Max"></param>
/// <param name="Value"></param>
/// <param name="Color"></param>
/// <param name="CursorColor"></param>
public Slider(GUI gui, float X, float Y, float Width, float Height, float Min, float Max, float Value, Vector4 Color, Vector4 CursorColor) : base(gui)
{
this.X = X;
this.Width = Width;
this.Height = Height - 8;
this.Y = Y + 4;
if (this.Height < 4)
{
this.Height = Height;
}
this.Color = Color;
this.Min = Min;
this.Max = Max;
this.Value = Value;
Cursor = new Box(gui, X, Y, 8, Height, CursorColor);
Cursor.MouseMoveX = true;
Children.Add(Cursor);
//Set cursor position
Cursor.X = (((Value - Min) / (Max - Min)) * (Width - Cursor.Width)) + X;
Meshes.Add(Quad.Rect().Compile());
Update();
MultiShader_StrVal = GUI.Default_Element;
}
public void ReadA(Stream s)
{
asciiReader = new StreamReader(s);
Meshes.Add(new MeshBuilder(true, true));
Materials.Add(MaterialHelper.CreateMaterial(Brushes.Blue));
while (!asciiReader.EndOfStream)
{
var line = asciiReader.ReadLine().Trim();
if (line.Length == 0 || line.StartsWith("\0") || line.StartsWith("#") || line.StartsWith("!") || line.StartsWith("$"))
{
continue;
}
string id, values;
SplitLine(line, out id, out values);
switch (id)
{
case "solid":
break;
case "facet":
ReadTriangleA(values);
break;
case "endsolid":
break;
}
}
asciiReader.Close();
}
private void SetFirstLine(string line)
{
string[] xvalues = line.Split();
//ID = xvalues[0];
Name = xvalues[1].Replace('_', ' ');
PluralName = xvalues[2].Replace('_', ' ');
int tmp = int.Parse(xvalues[3]);//meshCount
for (int i = 0; i < tmp; i++)
{
Meshes.Add(new Variable(xvalues[4 + (i * 2)], ulong.Parse(xvalues[5 + (i * 2)])));
}
tmp *= 2;
SpecialValues[0] = xvalues[tmp + 4];
SpecialValues[1] = xvalues[tmp + 5];
Price = int.Parse(xvalues[tmp + 6]);
SpecialValues[2] = xvalues[tmp + 7];
Weight = double.Parse(xvalues[tmp + 8], CultureInfo.InvariantCulture);
for (int i = 0; i < ItemStats.Length; i++)
{
ItemStats[i] = int.Parse(xvalues[i + tmp + 9]);
}
}
/// <summary>
/// Adds the specified mesh (for collection Initializers).
/// </summary>
/// <param name="mesh">The mesh.</param>
public void Add(Mesh mesh)
{
if (mesh != null)
{
Meshes.Add(mesh);
}
}
public void BuildModel(int modelIndex)
{
_srModel = _srFile.Models[modelIndex];
String modelName = _objectName + "-" + modelIndex.ToString();
#region Materials
ProgressStage = "Model " + modelIndex.ToString() + " - Creating Materials";
Thread.Sleep(500);
for (int materialIndex = 0; materialIndex < _srModel.MaterialCount; materialIndex++)
{
Material material = new Material();
Color colorDiffuse = Color.FromArgb((int)unchecked (_srModel.Materials[materialIndex].colour));
material.Diffuse = colorDiffuse;
material.TextureFileName = GetTextureName(_srModel, materialIndex);
Materials.Add(material);
progressLevel += _srModel.IndexCount / _srModel.Groups.Length;
}
#endregion
#region Groups
for (int groupIndex = 0; groupIndex < _srModel.Groups.Length; groupIndex++)
{
ProgressStage = "Model " + modelIndex.ToString() + " - Creating Group " + groupIndex.ToString();
Thread.Sleep(100);
Tree srGroup = _srModel.Groups[groupIndex];
String groupName = String.Format("{0}-{1}-group-{2}", _objectName, modelIndex, groupIndex);
if (srGroup != null && srGroup.mesh != null &&
srGroup.mesh.indexCount > 0 && srGroup.mesh.polygonCount > 0)
{
Node group = new Node();
SRMeshParser meshParser = new SRMeshParser(_objectName, _srFile);
meshParser.BuildMesh(modelIndex, groupIndex, 0);
foreach (SubMesh subMesh in meshParser.SubMeshes)
{
// If the mesh parser knew the total submeshes for the model,
// then this could be done inside BuildMesh.
subMesh.MeshIndex = Meshes.Count;
group.SubMeshIndices.Add(SubMeshes.Count);
SubMeshes.Add(subMesh);
}
Meshes.Add(meshParser.Mesh);
group.Name = groupName;
Groups.Add(group);
}
}
#endregion
ModelName = modelName;
if (_srFile.Asset == CDC.Asset.Unit)
{
Model = new Unit(this);
}
else
{
Model = new Physical(this);
}
}
protected virtual async Task LoadGeometryAsync(IAwaitCaller awaitCaller, Func <string, IDisposable> MeasureTime)
{
var inverter = InvertAxis.Create();
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var index = i;
using (MeasureTime("ReadMesh"))
{
var x = meshImporter.ReadMesh(GLTF, index, inverter);
var y = await BuildMeshAsync(awaitCaller, MeasureTime, x, index);
Meshes.Add(y);
}
}
using (MeasureTime("LoadNodes"))
{
for (int i = 0; i < GLTF.nodes.Count; i++)
{
Nodes.Add(NodeImporter.ImportNode(GLTF.nodes[i], i).transform);
}
}
await awaitCaller.NextFrame();
using (MeasureTime("BuildHierarchy"))
{
var nodes = new List <NodeImporter.TransformWithSkin>();
for (int i = 0; i < Nodes.Count; ++i)
{
nodes.Add(NodeImporter.BuildHierarchy(GLTF, i, Nodes, Meshes));
}
NodeImporter.FixCoordinate(GLTF, nodes, inverter);
// skinning
for (int i = 0; i < nodes.Count; ++i)
{
NodeImporter.SetupSkinning(GLTF, nodes, i, inverter);
}
if (Root == null)
{
Root = new GameObject("GLTF");
}
if (GLTF.rootnodes != null)
{
// connect root
foreach (var x in GLTF.rootnodes)
{
var t = nodes[x].Transform;
t.SetParent(Root.transform, false);
}
}
}
await awaitCaller.NextFrame();
}
public void CreateMesh(Canvas canvas)
{
if (PointsToAdd.Count == 4 && TexturePath != null)
{
Meshes.Add(new Mesh(openGL, MeshName, SelectedMeshType, new List <Point>(PointsToAdd), new Transformation(), TexturePath));
i = -1;
}
}
public Model(MeshVertex[] vertices, uint[] indices = null, MeshMaterial material = default, Matrix4 state = default, string name = "", RenderFlags renderFlags = RenderFlags.Solid)
{
Meshes.Add(new Mesh(name, vertices, indices ?? new uint[0], new MeshTexture[0], material)); // TODO: perhaps replace empty array with nulls?
State = state == default ? Matrix4.Identity : state;
RenderFlags = renderFlags;
}
public void AddMesh(int groupId, Mesh mesh)
{
if (!Meshes.ContainsKey(groupId))
{
Meshes.Add(groupId, new List <Mesh>());
}
Meshes[groupId].Add(mesh);
}
protected virtual Schedulable <Unit> LoadAsync()
{
return
(Schedulable.Create()
.AddTask(Scheduler.ThreadPool, () =>
{
m_materialFactory.Prepare(GLTF);
})
.ContinueWithCoroutine(Scheduler.ThreadPool, () => m_materialFactory.TexturesProcessOnAnyThread(GLTF, Storage))
.ContinueWithCoroutine(Scheduler.MainThread, () => m_materialFactory.TexturesProcessOnMainThread(GLTF))
.ContinueWithCoroutine(Scheduler.MainThread, () => m_materialFactory.LoadMaterials(GLTF))
.OnExecute(Scheduler.ThreadPool, parent =>
{
// UniGLTF does not support draco
// https://github.com/KhronosGroup/glTF/blob/master/extensions/2.0/Khronos/KHR_draco_mesh_compression/README.md#conformance
if (GLTF.extensionsRequired.Contains("KHR_draco_mesh_compression"))
{
throw new UniGLTFNotSupportedException("draco is not supported");
}
// meshes
var meshImporter = new MeshImporter();
for (int i = 0; i < GLTF.meshes.Count; ++i)
{
var index = i;
parent.AddTask(Scheduler.ThreadPool,
() =>
{
using (MeasureTime("ReadMesh"))
{
return meshImporter.ReadMesh(this, index);
}
})
.ContinueWithCoroutine <MeshWithMaterials>(Scheduler.MainThread, x => BuildMesh(x, index))
.ContinueWith(Scheduler.ThreadPool, x => Meshes.Add(x))
;
}
})
.ContinueWithCoroutine(Scheduler.MainThread, LoadNodes)
.ContinueWithCoroutine(Scheduler.MainThread, BuildHierarchy)
.ContinueWith(Scheduler.MainThread, _ =>
{
using (MeasureTime("AnimationImporter"))
{
AnimationImporter.Import(this);
}
})
.ContinueWithCoroutine(Scheduler.MainThread, OnLoadModel)
.ContinueWith(Scheduler.CurrentThread,
_ =>
{
if (m_showSpeedLog)
{
Debug.Log(GetSpeedLog());
}
return Unit.Default;
}));
}
internal void Read(EndianBinaryReader reader, ObjectSection section = null)
{
uint signature = reader.ReadUInt32();
reader.SeekCurrent(4); // Unused flags
int meshCount, materialCount;
long meshesOffset, materialsOffset;
// X stores mesh/material count before the bounding sphere
if (section?.Format == BinaryFormat.X)
{
meshCount = reader.ReadInt32();
materialCount = reader.ReadInt32();
BoundingSphere = reader.ReadBoundingSphere();
meshesOffset = reader.ReadOffset();
materialsOffset = reader.ReadOffset();
reader.SkipNulls(4 * sizeof(uint));
Flags = reader.ReadUInt32(); // TODO: Is this available in other games?
reader.SkipNulls(sizeof(uint));
}
else
{
BoundingSphere = reader.ReadBoundingSphere();
meshCount = reader.ReadInt32();
meshesOffset = reader.ReadOffset();
materialCount = reader.ReadInt32();
materialsOffset = reader.ReadOffset();
}
reader.SkipNulls(10 * sizeof(uint));
Meshes.Capacity = meshCount;
for (int i = 0; i < meshCount; i++)
{
reader.ReadAtOffset(meshesOffset + i * Mesh.GetByteSize(section?.Format ?? BinaryFormat.DT), () =>
{
var mesh = new Mesh();
mesh.Read(reader, section);
Meshes.Add(mesh);
});
}
Materials.Capacity = materialCount;
for (int i = 0; i < materialCount; i++)
{
reader.ReadAtOffset(materialsOffset + i * Material.BYTE_SIZE, () =>
{
var material = new Material();
material.Read(reader);
Materials.Add(material);
});
}
}
private ObjMesh NewMesh(string name)
{
Meshes.Add(CurrentMesh = new ObjMesh(this)
{
Name = name
});
CurrentSubMesh = null;
return(CurrentMesh);
}
/// <summary>This allows you to add a mesh to the seam fixer.
/// NOTE: You must later call <b>Generate</b> to seam fix the added meshes.</summary>
public void AddMesh(Mesh mesh)
{
if (mesh != null)
{
Meshes.Add(new Pair()
{
Source = mesh
});
}
}
public SkeletalModel(string name, string file, Skeleton skeleton, List <Mesh> meshes)
: base(name, file, meshes, "Skeletal")
{
Skeleton = skeleton;
AddPose(skeleton.BindPose.Clone("Default"));
shaderProgram.AddUniform("Bones");
Meshes.Add(Util.Mesh.GenerateSkeletonMesh(skeleton));
}
public Particle(Particle bp)
{
Name = "ParticleNode";
Meshes.Add(bp.Meshes[0]);
W = bp.W;
H = bp.H;
Alpha = bp.Alpha;
Life = bp.Life;
Tex = bp.Tex;
}
public bool ParseJsonElement(JsonElement element)
{
// NumMesh
JsonElement numMeshElem;
if (element.TryGetProperty("NumMesh", out numMeshElem))
{
if (numMeshElem.ValueKind == JsonValueKind.Number)
{
NumMesh = numMeshElem.GetUInt32();
}
}
// NumMaterial
JsonElement numMaterialElem;
if (element.TryGetProperty("NumMaterial", out numMaterialElem))
{
if (numMaterialElem.ValueKind == JsonValueKind.Number)
{
NumMaterial = numMaterialElem.GetUInt32();
}
}
// Mesh
JsonElement meshElem;
if (element.TryGetProperty("Mesh", out meshElem))
{
if (meshElem.ValueKind == JsonValueKind.Array)
{
for (int i = 0; i < meshElem.GetArrayLength(); ++i)
{
var mesh = new MeshData();
mesh.ParseJsonElement(meshElem[i]);
Meshes.Add(mesh);
}
}
}
// Material
JsonElement materialElem;
if (element.TryGetProperty("Material", out materialElem))
{
if (materialElem.ValueKind == JsonValueKind.Array)
{
for (int i = 0; i < materialElem.GetArrayLength(); ++i)
{
var material = new MaterialData();
material.ParseJsonElement(materialElem[i]);
Materials.Add(material);
}
}
}
return(true);
}
/// <summary>
/// Loads a md5mesh file
/// </summary>
/// <param name="filename">File name to load</param>
/// <returns>True if successful</returns>
public bool Load(string filename)
{
if (string.IsNullOrEmpty(filename))
{
return(false);
}
if (!File.Exists(filename))
{
return(false);
}
int numjoints = 0;
int nummeshes = 0;
using (StreamReader stream = new StreamReader(filename))
{
string line = null;
while ((line = stream.ReadLine()) != null)
{
if (line.StartsWith("MD5Version"))
{
if (Version != int.Parse(line.Substring("MD5Version".Length)))
{
Trace.WriteLine("Unsuported MD5Mesh found !");
return(false);
}
}
else if (line.StartsWith("numJoints"))
{
numjoints = int.Parse(line.Substring("numJoints".Length));
Joints = new Joint[numjoints];
}
else if (line.StartsWith("numMeshes"))
{
nummeshes = int.Parse(line.Substring("numMeshes".Length));
Meshes = new List <SubMesh>(nummeshes);
}
else if (line.StartsWith("joints"))
{
ReadJoints(stream);
}
else if (line.StartsWith("mesh"))
{
SubMesh mesh = new SubMesh();
mesh.ReadMesh(stream);
Meshes.Add(mesh);
}
}
}
Prepare();
return(true);
}
public void Rebuild(GraphicsDevice gd, bool force = false)
{
switch (MeshType)
{
case MeshType.Smooth:
Meshes = new List <HexMapMesh> {
new HexMapMeshSmooth(gd, Hexes, Texture)
};
break;
case MeshType.Flat:
if (force)
{
Meshes = new List <HexMapMesh>();
for (var xp = 0; xp < Width; xp += PatchSize)
{
for (var yp = 0; yp < Height; yp += PatchSize)
{
var patchHexes = new List <Hexagon>();
for (var x = xp; x < xp + PatchSize; x++)
{
for (var y = yp; y < yp + PatchSize; y++)
{
var hex = GetHex(x, y);
if (hex != null)
{
patchHexes.Add(hex);
}
}
}
Meshes.Add(new HexMapMeshFlat(gd, patchHexes, Texture));
}
}
}
else
{
foreach (var dirtyPatch in DirtyPatches)
{
var mesh = Meshes.FirstOrDefault(m => m.PatchID == dirtyPatch);
if (mesh == null)
{
continue;
}
Meshes.Remove(mesh);
Meshes.Add(new HexMapMeshFlat(gd, mesh.Hexes, Texture));
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
DirtyPatches.Clear();
}
public void BuildModel(RenderResource resource, int modelIndex, CDC.Objects.ExportOptions options)
{
_srModel = _srFile.Models[modelIndex];
String modelName = _objectName + "-" + modelIndex.ToString();
#region Materials
for (int materialIndex = 0; materialIndex < _srModel.MaterialCount; materialIndex++)
{
Material material = new Material();
material.Visible = _srModel.Materials[materialIndex].visible;
// Breaks early SR1 builds.
//material.BlendMode = _srModel.Materials[materialIndex].blendMode;
//int sortPush = unchecked((sbyte)_srModel.Materials[materialIndex].sortPush);
//sortPush = 128 - sortPush;
//material.DepthBias = (1.0f / 100000.0f) * sortPush;
// Maybe use a hack for warpgates WARPGATE_DrawWarpGateRim indicates tree 3 should have lower priority.
Color colorDiffuse = Color.FromArgb((int)unchecked (_srModel.Materials[materialIndex].colour));
material.Diffuse = colorDiffuse;
material.TextureFileName = CDC.Objects.Models.SRModel.GetTextureName(_srModel, materialIndex, options);
Materials.Add(material);
}
#endregion
#region Groups
for (int groupIndex = 0; groupIndex < _srModel.Groups.Length; groupIndex++)
{
Tree srGroup = _srModel.Groups[groupIndex];
String groupName = String.Format("{0}-{1}-group-{2}", _objectName, modelIndex, groupIndex);
if (srGroup != null && srGroup.mesh != null &&
srGroup.mesh.indexCount > 0 && srGroup.mesh.polygonCount > 0)
{
ModelNode group = new ModelNode();
SRMeshParser meshParser = new SRMeshParser(_objectName, _srFile);
meshParser.BuildMesh(resource, modelIndex, groupIndex, 0);
foreach (SubMesh subMesh in meshParser.SubMeshes)
{
// If the mesh parser knew the total submeshes for the model,
// then this could be done inside BuildMesh.
subMesh.MeshIndex = Meshes.Count;
group.SubMeshIndices.Add(SubMeshes.Count);
SubMeshes.Add(subMesh);
}
Meshes.Add(meshParser.Mesh);
group.Name = groupName;
Groups.Add(group);
}
}
#endregion
ModelName = modelName;
Model = new Model(this);
}
/// <summary>
/// Initialization
/// </summary>
/// <param name="device"></param>
/// <param name="physicsEngine"></param>
public override void Initialize(xnagrfx.GraphicsDevice device, PhysicsEngine physicsEngine)
{
try
{
InitError = string.Empty;
// set flag so rendering engine renders us last
Flags |= VisualEntityProperties.UsesAlphaBlending;
// creates effect, loads meshes, etc
base.Initialize(device, physicsEngine);
HeightFieldShapeProperties hf = new HeightFieldShapeProperties("height field", 2, 0.02f, 2, 0.02f, 0, 0, 1, 1);
hf.HeightSamples = new HeightFieldSample[hf.RowCount * hf.ColumnCount];
for (int i = 0; i < hf.HeightSamples.Length; i++)
{
hf.HeightSamples[i] = new HeightFieldSample();
}
_particlePlane = new Shape(hf);
_particlePlane.State.Name = "sonar impact plane";
VisualEntityMesh sonarMesh = null;
// we render on our own only the laser impact points. The laser Box is rendered as part of the parent.
int index = Meshes.Count;
Meshes.Add(SimulationEngine.ResourceCache.CreateMesh(device, _particlePlane.State));
Meshes[0].Textures[0] = SimulationEngine.ResourceCache.CreateTextureFromFile(device, "particle.bmp");
// we have a custom effect, with an additional global parameter. Get handle to it here
if (Effect != null)
{
_timeAttenuationHandle = Effect.GetParameter("timeAttenuation");
}
World = xna.Matrix.Identity;
if (Meshes.Count > 1)
{
sonarMesh = Meshes[0];
}
if (Parent == null)
{
throw new Exception("This entity must be a child of another entity.");
}
Parent.AddShapeToPhysicsEntity(_sonarBox, sonarMesh);
}
catch (Exception ex)
{
HasBeenInitialized = false;
InitError = ex.ToString();
}
}
public void ConvertLegacy()
{
if (source != null)
{
Meshes.Add(new Pair()
{
Source = mesh, Output = mesh
});
source = null;
mesh = null;
}
}
public int AddMesh(DMesh3 mesh, PrintMeshOptions options)
{
SliceMesh m = new SliceMesh()
{
mesh = mesh,
bounds = mesh.CachedBounds,
options = options
};
int idx = Meshes.Count;
Meshes.Add(m);
return(idx);
}
public void Read(BlamCacheFile cacheFile, Resource resourceRef)
{
IReader reader = cacheFile.Reader;
StructureLayout meshLayout = cacheFile.GetLayout("model section");
for (int i = 0; i < Meshes.Capacity; i++)
{
reader.SeekTo(meshTableOffset + (i * meshLayout.Size));
Meshes.Add(new BlamModelMesh(cacheFile, i, meshLayout));
}
ReadResourceBuffers(cacheFile, ref resourceRef);
}
/// <summary>
/// Box Constructor
/// </summary>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <param name="Width"></param>
/// <param name="Height"></param>
/// <param name="Color"></param>
public Box(GUI gui, float X, float Y, float Width, float Height, Vector4 Color) : base(gui)
{
this.X = X;
this.Y = Y;
this.Width = Width;
this.Height = Height;
this.Color = Color;
Meshes.Add(Quad.Rect().Compile());
Update();
MultiShader_StrVal = GUI.Default_Element;
}
void InitFrames(xxFrame frame)
{
Frames.Add(frame);
if (frame.Mesh != null)
{
Meshes.Add(frame);
}
for (int i = 0; i < frame.Count; i++)
{
InitFrames(frame[i]);
}
}
private void ProcessNode(Node node, Scene scene)
{
// process all the node's meshes (if any)
for (int i = 0; i < node.MeshCount; i++)
{
Assimp.Mesh mesh = scene.Meshes[node.MeshIndices[i]];
Meshes.Add(ProcessMesh(mesh, scene));
}
// then do the same for each of its children
for (int i = 0; i < node.ChildCount; i++)
{
ProcessNode(node.Children[i], scene);
}
}
private void Initialize()
{
if (Meshes == null)
{
Meshes = new Dictionary <int, Record>();
}
if (Mesh == null)
{
Mesh = new List <Record>();
}
foreach (var item in Mesh)
{
Meshes.Add(item.GetHashCode(), item);
}
}
protected override void ReadMesh()
{
// Override internal mesh read method to fill the mesh list
// with drawable meshes
DrawableRoRsmMesh m = new DrawableRoRsmMesh(Reader, Version);
if (m.IsValid == true)
{
m.SetUpVertices(mDevice);
Meshes.Add(m);
}
else
{
// TODO: debug in valid meshes
}
}
/// <summary>
/// Button Constructor
/// </summary>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <param name="Width"></param>
/// <param name="Height"></param>
/// <param name="Color"></param>
/// <param name="Text"></param>
/// <param name="Font"></param>
/// <param name="LineSpacing"></param>
/// <param name="xOffset"></param>
/// <param name="yOffset"></param>
public Button(GUI gui, float X, float Y, float Width, float Height, Vector4 Color, string Text, Font Font, float LineSpacing = 1, float xOffset = 0, float yOffset = 0) : base(gui)
{
this.X = X;
this.Y = Y;
this.Width = Width;
this.Height = Height;
this.Color = Color;
Meshes.Add(Quad.Rect().Compile());
Update();
//Text
this.Text = new Text(gui, X, Y, new Vector4(1), Text, Font, Width, LineSpacing, xOffset, yOffset);
Children.Add(this.Text);
MultiShader_StrVal = GUI.Default_Element;
}
