public RenderObject GetRenderObject(Table.Table table, string id, Origin origin, bool asRightHanded)
{
var meshes = GenerateMeshes(table);
var(preVertexMatrix, preNormalsMatrix) = GetPreMatrix(table, origin, asRightHanded);
switch (id)
{
case Base:
return(new RenderObject(
id,
meshes[Base].Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
));
case Rubber:
if (meshes.ContainsKey(Rubber))
{
return(new RenderObject(
id,
meshes[Rubber].Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.RubberMaterial)),
_data.IsVisible
));
}
break;
}
return(null);
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin = Origin.Global, bool asRightHanded = true)
{
var meshes = GetMeshes(table, origin);
var translationMatrix = GetPostMatrix(origin);
return(new RenderObjectGroup(_data.Name, "Bumpers", translationMatrix,
new RenderObject(
"Base",
asRightHanded ? meshes["Base"].Transform(Matrix3D.RightHanded) : meshes["Base"],
new PbrMaterial(table.GetMaterial(_data.BaseMaterial), Texture.BumperBase),
_data.IsBaseVisible
),
new RenderObject(
"Ring",
asRightHanded ? meshes["Ring"].Transform(Matrix3D.RightHanded) : meshes["Ring"],
new PbrMaterial(table.GetMaterial(_data.RingMaterial), Texture.BumperRing),
_data.IsRingVisible
),
new RenderObject(
"Skirt",
asRightHanded ? meshes["Skirt"].Transform(Matrix3D.RightHanded) : meshes["Skirt"],
new PbrMaterial(table.GetMaterial(_data.SocketMaterial), Texture.BumperSocket),
_data.IsSocketVisible
),
new RenderObject(
"Cap",
asRightHanded ? meshes["Cap"].Transform(Matrix3D.RightHanded) : meshes["Cap"],
new PbrMaterial(table.GetMaterial(_data.CapMaterial), Texture.BumperCap),
_data.IsCapVisible
)
));
}
public RenderObject GetRenderObject(Table.Table table, string id, bool asRightHanded, Mesh preGeneratedMesh = null)
{
var mesh = preGeneratedMesh ?? GenerateMesh(table, id);
switch (id)
{
case Side:
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.SideMaterial), table.GetTexture(_data.SideImage)),
_data.IsSideVisible
));
case Top:
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.TopMaterial), table.GetTexture(_data.Image)),
_data.IsTopBottomVisible
));
default:
throw new ArgumentException($"Unknown mesh ID \"{id}\".");
}
}
public RenderObject GetRenderObject(Table.Table table, string id, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
switch (id)
{
case Wire:
return(new RenderObject(
id,
GetBaseMesh().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible
));
case Bracket:
return(new RenderObject(
id,
GateBracketMesh.Clone().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible && _data.ShowBracket
));
default:
throw new ArgumentException("Unknown gate mesh \"" + id + "\".");
}
}
public RenderObjectGroup GetRenderObjects(Table.Table table, bool asRightHanded = true)
{
var meshes = GenerateMeshes(table);
var renderObjects = new List <RenderObject>();
if (meshes.ContainsKey("Side"))
{
renderObjects.Add(new RenderObject(
"Side",
asRightHanded ? meshes["Side"].Transform(Matrix3D.RightHanded) : meshes["Side"],
new PbrMaterial(table.GetMaterial(_data.SideMaterial), table.GetTexture(_data.SideImage)),
_data.IsSideVisible
));
}
if (meshes.ContainsKey("Top"))
{
renderObjects.Add(new RenderObject(
"Top",
asRightHanded ? meshes["Top"].Transform(Matrix3D.RightHanded) : meshes["Top"],
new PbrMaterial(table.GetMaterial(_data.TopMaterial), table.GetTexture(_data.Image)),
_data.IsTopBottomVisible
));
}
return(new RenderObjectGroup(_data.Name, "Surfaces", Matrix3D.Identity, renderObjects.ToArray()));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded = true)
{
var meshes = GenerateMeshes(table);
var(preVertexMatrix, preNormalsMatrix) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
var renderObjects = new List <RenderObject> {
new RenderObject(
Base,
meshes[Base].Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
)
};
if (meshes.ContainsKey(Rubber))
{
renderObjects.Add(new RenderObject(
Rubber,
meshes[Rubber].Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.RubberMaterial)),
_data.IsVisible
));
}
return(new RenderObjectGroup(_data.Name, "Flippers", postMatrix, renderObjects.ToArray()));
}
public PbrMaterial GetMaterial(string id, Table.Table table, SurfaceData data)
{
switch (id)
{
case Top:
return(new PbrMaterial(table.GetMaterial(data.TopMaterial), table.GetTexture(data.Image)));
case Side:
return(new PbrMaterial(table.GetMaterial(data.SideMaterial), table.GetTexture(data.SideImage)));
}
throw new ArgumentException($"Unknown mesh ID \"{id}\".");
}
public static PbrMaterial GetMaterial(string id, Table.Table table, FlipperData data)
{
switch (id)
{
case Base:
return(new PbrMaterial(table.GetMaterial(data.Material), table.GetTexture(data.Image)));
case Rubber:
return(new PbrMaterial(table.GetMaterial(data.RubberMaterial)));
}
throw new ArgumentException($"Unknown flipper ID \"{id}\".", nameof(id));
}
public PbrMaterial GetMaterial(string id, Table.Table table)
{
switch (id)
{
case Wire:
return(new PbrMaterial(table.GetMaterial(_data.Material)));
case Bracket:
return(new PbrMaterial(table.GetMaterial(_data.Material)));
}
throw new ArgumentException("Unknown gate \"" + id + "\".");
}
public RenderVertex3D[] GetCentralCurve(Table.Table table, float acc = -1.0f)
{
float accuracy;
// as solid ramps are rendered into the static buffer, always use maximum precision
if (acc != -1.0)
{
accuracy = acc; // used for hit shape calculation, always!
}
else
{
var mat = table.GetMaterial(_data.Material);
if (mat == null || !mat.IsOpacityActive)
{
accuracy = 10.0f;
}
else
{
accuracy = table.GetDetailLevel();
}
}
// min = 4 (highest accuracy/detail level), max = 4 * 10^(10/1.5) = ~18.000.000 (lowest accuracy/detail level)
accuracy = 4.0f * MathF.Pow(10.0f, (10.0f - accuracy) * (1.0f / 1.5f));
return(DragPoint.GetRgVertex <RenderVertex3D, CatmullCurve3DCatmullCurveFactory>(_data.DragPoints, false, accuracy));
}
public PbrMaterial GetMaterial(Table.Table table)
{
return(new PbrMaterial(
table.GetMaterial(_data.Material),
table.GetTexture(_data.Image),
table.GetTexture(_data.NormalMap)
));
}
private RenderObject GetRenderObject(Table.Table table, IReadOnlyDictionary <string, Mesh> meshes, string name, bool asRightHanded)
{
return(new RenderObject(
name,
asRightHanded ? meshes[name].Transform(Matrix3D.RightHanded) : meshes[name],
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
));
}
public PbrMaterial GetMaterial(string id, Table.Table table)
{
switch (id)
{
case Base:
return(new PbrMaterial(table.GetMaterial(_data.BaseMaterial), Texture.BumperBase));
case Cap:
return(new PbrMaterial(table.GetMaterial(_data.CapMaterial), Texture.BumperCap));
case Ring:
return(new PbrMaterial(table.GetMaterial(_data.RingMaterial), Texture.BumperRing));
case Skirt:
return(new PbrMaterial(table.GetMaterial(_data.SocketMaterial), Texture.BumperSocket));
}
throw new ArgumentException("Unknown bumper id \"" + id + "\".");
}
public RenderObject GetRenderObject(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
return(new RenderObject(
_data.Name,
GetMesh().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible && _data.Shape != TriggerShape.TriggerNone
));
}
public RenderObject GetRenderObject(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
return(new RenderObject(
_data.Name,
GetBaseMesh().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.KickerType != KickerType.KickerInvisible
));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "Gates", postMatrix, new RenderObject(
"Wire",
GetBaseMesh().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible
),
new RenderObject(
"Bracket",
GateBracketMesh.Clone().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material)),
_data.IsVisible && _data.ShowBracket
)
));
}
public RenderObject GetRenderObject(Table.Table table, Origin origin, bool asRightHanded)
{
var mesh = GetMesh(table);
var(preVertexMatrix, preNormalsMatrix) = GetPreMatrix(table, origin, asRightHanded);
return(new RenderObject(
_data.Name,
mesh.Transform(preVertexMatrix, preNormalsMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
));
}
public RenderObject GetRenderObject(Table.Table table, string id, Origin origin, bool asRightHanded)
{
var mesh = new Mesh();
if (id == Wires)
{
var meshes = GenerateWireMeshes(table);
for (var i = 1; i <= 4; i++)
{
var name = $"Wire{i}";
if (meshes.ContainsKey(name))
{
mesh.Merge(meshes[name]);
}
}
}
else
{
var rv = GetRampVertex(table, -1, true);
switch (id)
{
case Floor:
mesh = GenerateFlatFloorMesh(table, rv);
break;
case Wall:
if (_data.RightWallHeightVisible > 0.0)
{
mesh = mesh.Merge(GenerateFlatRightWall(table, rv));
}
if (_data.LeftWallHeightVisible > 0.0)
{
mesh = mesh.Merge(GenerateFlatLeftWall(table, rv));
}
break;
}
if (mesh.Vertices == null)
{
mesh.Vertices = new Vertex3DNoTex2[0];
mesh.Indices = new int[0];
}
}
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
));
}
public PbrMaterial GetMaterial(string id, Table.Table table)
{
switch (id)
{
case Plate:
return(new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)));
case Bracket:
return(new PbrMaterial(GetBracketMaterial(), table.GetTexture(_data.Image)));
}
throw new ArgumentException($"Invalid spinner mesh ID \"{id}\"");
}
public RenderObject GetRenderObject(Table.Table table, string id, Origin origin, bool asRightHanded)
{
var mesh = GetMesh(id, table, origin);
switch (id)
{
case Base:
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.BaseMaterial), Texture.BumperBase),
_data.IsBaseVisible
));
case Cap:
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.CapMaterial), Texture.BumperCap),
_data.IsCapVisible
));
case Ring:
return(new RenderObject(
id,
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.RingMaterial), Texture.BumperRing),
_data.IsRingVisible
));
case Skirt:
return(new RenderObject(
"Skirt",
asRightHanded ? mesh.Transform(Matrix3D.RightHanded) : mesh,
new PbrMaterial(table.GetMaterial(_data.SocketMaterial), Texture.BumperSocket),
_data.IsSocketVisible
));
}
throw new ArgumentException("Unknown bumper mesh \"" + id + "\".");
}
public RenderObject GetRenderObject(Table.Table table, Origin origin, bool asRightHanded)
{
return(new RenderObject(
_data.Name,
GetTransformedMesh(table, origin, asRightHanded),
new PbrMaterial(
table.GetMaterial(_data.Material),
table.GetTexture(_data.Image),
table.GetTexture(_data.NormalMap)
),
_data.IsVisible
));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var mesh = GetBaseMesh();
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "HitTargets", postMatrix, new RenderObject(
_data.Name,
mesh.Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
)));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded = true,
string parent = null, PbrMaterial material = null)
{
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, parent ?? "Primitives", postMatrix, new RenderObject(
_data.Name,
GetTransformedMesh(table, origin, asRightHanded),
material ?? new PbrMaterial(
table.GetMaterial(_data.Material),
table.GetTexture(_data.Image),
table.GetTexture(_data.NormalMap)
),
_data.IsVisible
)));
}
public RenderObjectGroup GetRenderObjects(Table.Table table, Origin origin, bool asRightHanded)
{
var(preMatrix, _) = GetPreMatrix(table, origin, asRightHanded);
var postMatrix = GetPostMatrix(table, origin);
return(new RenderObjectGroup(_data.Name, "Spinners", postMatrix, new RenderObject(
"Plate",
SpinnerPlateMesh.Clone().Transform(preMatrix),
new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image)),
_data.IsVisible
),
new RenderObject(
"Bracket",
SpinnerBracketMesh.Clone().Transform(preMatrix),
new PbrMaterial(GetBracketMaterial(), table.GetTexture(_data.Image)),
_data.IsVisible && _data.ShowBracket
)
));
}
public RenderObject GetRenderObject(int frame, Table.Table table, string id, Origin origin, bool asRightHanded)
{
Init(table);
var material = new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image));
switch (id)
{
case Flat:
var flatMesh = BuildFlatMesh(frame);
return(new RenderObject(
id,
asRightHanded ? flatMesh.Transform(Matrix3D.RightHanded) : flatMesh,
material,
true
));
case Rod:
CalculateArraySizes();
var rodMesh = BuildRodMesh(frame);
return(new RenderObject(
id,
asRightHanded ? rodMesh.Transform(Matrix3D.RightHanded) : rodMesh,
material,
true
));
case Spring:
CalculateArraySizes();
var springMesh = BuildSpringMesh(frame);
return(new RenderObject(
id,
asRightHanded ? springMesh.Transform(Matrix3D.RightHanded) : springMesh,
material,
true
));
default:
throw new ArgumentException("Unknown plunger mesh \"" + id + "\".");
}
}
public PbrMaterial GetMaterial(Table.Table table)
{
return(new PbrMaterial(table.GetMaterial(_data.Material)));
}
public RenderObjectGroup GetRenderObjects(int frame, Table.Table table, Origin origin, bool asRightHanded = true)
{
Init(table);
// todo
var translationMatrix = Matrix3D.Identity;
var material = new PbrMaterial(table.GetMaterial(_data.Material), table.GetTexture(_data.Image));
// flat plunger
if (_data.Type == PlungerType.PlungerTypeFlat)
{
var flatMesh = BuildFlatMesh(frame);
return(new RenderObjectGroup(_data.Name, "Plungers", translationMatrix,
new RenderObject(
FlatName,
asRightHanded ? flatMesh.Transform(Matrix3D.RightHanded) : flatMesh,
material,
true
)
)
{
ForceChild = true
});
}
CalculateArraySizes();
var rodMesh = BuildRodMesh(frame);
// custom plunger
if (_data.Type == PlungerType.PlungerTypeCustom)
{
var springMesh = BuildSpringMesh(frame);
return(new RenderObjectGroup(_data.Name, "Plungers", translationMatrix,
new RenderObject(
RodName,
asRightHanded ? rodMesh.Transform(Matrix3D.RightHanded) : rodMesh,
material,
true
),
new RenderObject(
SpringName,
asRightHanded ? springMesh.Transform(Matrix3D.RightHanded) : springMesh,
material,
true
)
));
}
// modern plunger
return(new RenderObjectGroup(_data.Name, "Plungers", translationMatrix,
new RenderObject(
RodName,
asRightHanded ? rodMesh.Transform(Matrix3D.RightHanded) : rodMesh,
material,
true
)
)
{
ForceChild = true
});
}
public PbrMaterial GetMaterial(Table.Table table, RubberData rubberData)
{
return(new PbrMaterial(table.GetMaterial(rubberData.Material), table.GetTexture(rubberData.Image)));
}
public PbrMaterial GetMaterial()
{
return(new PbrMaterial(_table.GetMaterial(_data.Material), _table.GetTexture(_data.Image)));
}
private Tuple <Mesh, Mesh> GenerateBaseWires(Table.Table table)
{
int accuracy;
if (table.GetDetailLevel() < 5)
{
accuracy = 6;
}
else if (table.GetDetailLevel() >= 5 && table.GetDetailLevel() < 8)
{
accuracy = 8;
}
else
{
accuracy = (int)(table.GetDetailLevel() * 1.3f); // see below
}
// as solid ramps are rendered into the static buffer, always use maximum precision
var mat = table.GetMaterial(_data.Material);
if (mat == null || !mat.IsOpacityActive)
{
accuracy = 12; // see above
}
var rv = GetRampVertex(table, -1, false);
var middlePoints = rv.MiddlePoints;
var numRings = rv.VertexCount;
var numSegments = accuracy;
var numVertices = numRings * numSegments;
var numIndices = 6 * numVertices; //m_numVertices*2+2;
var tmpPoints = new Vertex2D[rv.VertexCount];
for (var i = 0; i < rv.VertexCount; i++)
{
tmpPoints[i] = rv.RgvLocal[rv.VertexCount * 2 - i - 1];
}
Vertex3DNoTex2[] vertBuffer;
Vertex3DNoTex2[] vertBuffer2;
if (_data.RampType != RampType.RampType1Wire)
{
vertBuffer = CreateWire(numRings, numSegments, rv.RgvLocal, rv.PointHeights);
vertBuffer2 = CreateWire(numRings, numSegments, tmpPoints, rv.PointHeights);
}
else
{
vertBuffer = CreateWire(numRings, numSegments, middlePoints, rv.PointHeights);
vertBuffer2 = null;
}
// calculate faces
var indices = new int[numIndices];
for (var i = 0; i < numRings - 1; i++)
{
for (var j = 0; j < numSegments; j++)
{
var quad = new int[4];
quad[0] = i * numSegments + j;
if (j != numSegments - 1)
{
quad[1] = i * numSegments + j + 1;
}
else
{
quad[1] = i * numSegments;
}
if (i != numRings - 1)
{
quad[2] = (i + 1) * numSegments + j;
if (j != numSegments - 1)
{
quad[3] = (i + 1) * numSegments + j + 1;
}
else
{
quad[3] = (i + 1) * numSegments;
}
}
else
{
quad[2] = j;
if (j != numSegments - 1)
{
quad[3] = j + 1;
}
else
{
quad[3] = 0;
}
}
var offs = (i * numSegments + j) * 6;
indices[offs] = quad[0];
indices[offs + 1] = quad[1];
indices[offs + 2] = quad[2];
indices[offs + 3] = quad[3];
indices[offs + 4] = quad[2];
indices[offs + 5] = quad[1];
}
}
if (_data.RampType != RampType.RampType1Wire)
{
return(new Tuple <Mesh, Mesh>(
new Mesh(vertBuffer, indices),
new Mesh(vertBuffer2, indices)
));
}
return(new Tuple <Mesh, Mesh>(new Mesh(vertBuffer, indices), null));
}
