okseby/terraria-source-code
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Terraria 1.4.0.5 Source Code

Browse source
This commit is contained in:
MikeyIsBaeYT 2021-10-26 12:45:26 -04:00
commit 05205f009e
1059 changed files with 563450 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

194
Graphics/VertexStrip.cs Normal file
View file

@ -0,0 +1,194 @@
// Decompiled with JetBrains decompiler
// Type: Terraria.Graphics.VertexStrip
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
namespace Terraria.Graphics
{
public class VertexStrip
{
private VertexStrip.CustomVertexInfo[] _vertices = new VertexStrip.CustomVertexInfo[1];
private int _vertexAmountCurrentlyMaintained;
private short[] _indices = new short[1];
private int _indicesAmountCurrentlyMaintained;
private List<Vector2> _temporaryPositionsCache = new List<Vector2>();
private List<float> _temporaryRotationsCache = new List<float>();
public void PrepareStrip(
Vector2[] positions,
float[] rotations,
VertexStrip.StripColorFunction colorFunction,
VertexStrip.StripHalfWidthFunction widthFunction,
Vector2 offsetForAllPositions = default (Vector2),
int? expectedVertexPairsAmount = null,
bool includeBacksides = false)
{
int vertexPaidsAdded = positions.Length;
int newSize = vertexPaidsAdded * 2;
this._vertexAmountCurrentlyMaintained = newSize;
if (this._vertices.Length < newSize)
Array.Resize<VertexStrip.CustomVertexInfo>(ref this._vertices, newSize);
int num = vertexPaidsAdded;
if (expectedVertexPairsAmount.HasValue)
num = expectedVertexPairsAmount.Value;
for (int index = 0; index < vertexPaidsAdded; ++index)
{
if (positions[index] == Vector2.Zero)
{
vertexPaidsAdded = index - 1;
this._vertexAmountCurrentlyMaintained = vertexPaidsAdded * 2;
break;
}
Vector2 pos = positions[index] + offsetForAllPositions;
float rot = MathHelper.WrapAngle(rotations[index]);
int indexOnVertexArray = index * 2;
float progressOnStrip = (float) index / (float) (num - 1);
this.AddVertex(colorFunction, widthFunction, pos, rot, indexOnVertexArray, progressOnStrip);
}
this.PrepareIndices(vertexPaidsAdded, includeBacksides);
}
public void PrepareStripWithProceduralPadding(
Vector2[] positions,
float[] rotations,
VertexStrip.StripColorFunction colorFunction,
VertexStrip.StripHalfWidthFunction widthFunction,
Vector2 offsetForAllPositions = default (Vector2),
bool includeBacksides = false)
{
int length = positions.Length;
this._temporaryPositionsCache.Clear();
this._temporaryRotationsCache.Clear();
for (int index = 0; index < length && !(positions[index] == Vector2.Zero); ++index)
{
Vector2 position1 = positions[index];
float f1 = MathHelper.WrapAngle(rotations[index]);
this._temporaryPositionsCache.Add(position1);
this._temporaryRotationsCache.Add(f1);
if (index + 1 < length && positions[index + 1] != Vector2.Zero)
{
Vector2 position2 = positions[index + 1];
float f2 = MathHelper.WrapAngle(rotations[index + 1]);
int num1 = (int) ((double) Math.Abs(MathHelper.WrapAngle(f2 - f1)) / 0.261799395084381);
if (num1 != 0)
{
float num2 = position1.Distance(position2);
Vector2 vector2_1 = position1 + f1.ToRotationVector2() * num2;
Vector2 vector2_2 = position2 + f2.ToRotationVector2() * -num2;
float num3 = 1f / (float) (num1 + 2);
Vector2 Target = position1;
for (float amount = num3; (double) amount < 1.0; amount += num3)
{
Vector2 Origin = Vector2.CatmullRom(vector2_1, position1, position2, vector2_2, amount);
float num4 = MathHelper.WrapAngle(Origin.DirectionTo(Target).ToRotation());
this._temporaryPositionsCache.Add(Origin);
this._temporaryRotationsCache.Add(num4);
Target = Origin;
}
}
}
}
int count = this._temporaryPositionsCache.Count;
for (int index = 0; index < count; ++index)
{
Vector2 pos = this._temporaryPositionsCache[index] + offsetForAllPositions;
float rot = this._temporaryRotationsCache[index];
int indexOnVertexArray = index * 2;
float progressOnStrip = (float) index / (float) (count - 1);
this.AddVertex(colorFunction, widthFunction, pos, rot, indexOnVertexArray, progressOnStrip);
}
this._vertexAmountCurrentlyMaintained = count * 2;
this.PrepareIndices(count, includeBacksides);
}
private void PrepareIndices(int vertexPaidsAdded, bool includeBacksides)
{
int num1 = vertexPaidsAdded - 1;
int num2 = 6 + includeBacksides.ToInt() * 6;
int newSize = num1 * num2;
this._indicesAmountCurrentlyMaintained = newSize;
if (this._indices.Length < newSize)
Array.Resize<short>(ref this._indices, newSize);
for (short index = 0; (int) index < num1; ++index)
{
short num3 = (short) ((int) index * num2);
int num4 = (int) index * 2;
this._indices[(int) num3] = (short) num4;
this._indices[(int) num3 + 1] = (short) (num4 + 1);
this._indices[(int) num3 + 2] = (short) (num4 + 2);
this._indices[(int) num3 + 3] = (short) (num4 + 2);
this._indices[(int) num3 + 4] = (short) (num4 + 1);
this._indices[(int) num3 + 5] = (short) (num4 + 3);
if (includeBacksides)
{
this._indices[(int) num3 + 6] = (short) (num4 + 2);
this._indices[(int) num3 + 7] = (short) (num4 + 1);
this._indices[(int) num3 + 8] = (short) num4;
this._indices[(int) num3 + 9] = (short) (num4 + 2);
this._indices[(int) num3 + 10] = (short) (num4 + 3);
this._indices[(int) num3 + 11] = (short) (num4 + 1);
}
}
}
private void AddVertex(
VertexStrip.StripColorFunction colorFunction,
VertexStrip.StripHalfWidthFunction widthFunction,
Vector2 pos,
float rot,
int indexOnVertexArray,
float progressOnStrip)
{
while (indexOnVertexArray + 1 >= this._vertices.Length)
Array.Resize<VertexStrip.CustomVertexInfo>(ref this._vertices, this._vertices.Length * 2);
Color color = colorFunction(progressOnStrip);
float num = widthFunction(progressOnStrip);
Vector2 vector2 = MathHelper.WrapAngle(rot - 1.570796f).ToRotationVector2() * num;
this._vertices[indexOnVertexArray].Position = pos + vector2;
this._vertices[indexOnVertexArray + 1].Position = pos - vector2;
this._vertices[indexOnVertexArray].TexCoord = new Vector3(progressOnStrip, num, num);
this._vertices[indexOnVertexArray + 1].TexCoord = new Vector3(progressOnStrip, 0.0f, num);
this._vertices[indexOnVertexArray].Color = color;
this._vertices[indexOnVertexArray + 1].Color = color;
}
public void DrawTrail()
{
if (this._vertexAmountCurrentlyMaintained < 3)
return;
Main.instance.GraphicsDevice.DrawUserIndexedPrimitives<VertexStrip.CustomVertexInfo>(PrimitiveType.TriangleList, this._vertices, 0, this._vertexAmountCurrentlyMaintained, this._indices, 0, this._indicesAmountCurrentlyMaintained / 3);
}
public delegate Color StripColorFunction(float progressOnStrip);
public delegate float StripHalfWidthFunction(float progressOnStrip);
private struct CustomVertexInfo : IVertexType
{
public Vector2 Position;
public Color Color;
public Vector3 TexCoord;
private static VertexDeclaration _vertexDeclaration = new VertexDeclaration(new VertexElement[3]
{
new VertexElement(0, VertexElementFormat.Vector2, VertexElementUsage.Position, 0),
new VertexElement(8, VertexElementFormat.Color, VertexElementUsage.Color, 0),
new VertexElement(12, VertexElementFormat.Vector3, VertexElementUsage.TextureCoordinate, 0)
});
public CustomVertexInfo(Vector2 position, Color color, Vector3 texCoord)
{
this.Position = position;
this.Color = color;
this.TexCoord = texCoord;
}
public VertexDeclaration VertexDeclaration => VertexStrip.CustomVertexInfo._vertexDeclaration;
}
}
}