// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Return) || Input.GetKeyDown(KeyCode.Space))
{
GameManager.Instance.NavigateFromDevice();
return;
}
var input = Input.GetAxis("Vertical");
var yVal = transform.localPosition.y;
var corners = new Vector3[4];
_myRect.GetWorldCorners(corners);
var yBottom = corners.Select(c => c.y).Min();
var yTop = corners.Select(c => c.y).Max();
//Debug.LogFormat("y pos: {0} bot: {1} y top: {2}; in: {3}", yVal, yBottom, yTop, input);
var distanceToApply = input * ScrollUnitsPerSecond * Time.deltaTime;
if (input > 0 && yBottom > 0)
{
return;
}
if (input < 0 && yTop < YBetweenEntries + YFromBottom)
{
return;
}
yVal += distanceToApply;
transform.localPosition = new Vector3(transform.localPosition.x, yVal);
}
public void MoveInsideCanvas()
{
// Make sure that all items are visible
// corners of item in world space
Vector3[] corners = new Vector3[4];
RectTransform.GetWorldCorners(corners);
Vector3[] canvasCorners = new Vector3[4];
Canvas.GetComponent <RectTransform>().GetWorldCorners(canvasCorners);
float right = corners.Select(it => it.x).Max();
float canvasRight = canvasCorners.Select(it => it.x).Max();
if (right > canvasRight)
{
float overlapX = right - canvasRight;
RectTransform.position = new Vector3(RectTransform.position.x - overlapX, RectTransform.position.y, RectTransform.position.z);
}
float bottom = corners.Select(it => it.y).Min();
float canvasBottom = canvasCorners.Select(it => it.y).Min();
if (bottom < canvasBottom)
{
float overlapY = canvasBottom - bottom;
RectTransform.position = new Vector3(RectTransform.position.x, RectTransform.position.y + overlapY, RectTransform.position.z);
}
}
// Update is called once per frame
void Update()
{
var input = Input.GetAxis("Vertical");
var yVal = transform.localPosition.y;
var corners = new Vector3[4];
_myRect.GetWorldCorners(corners);
var yBottom = corners.Select(c => c.y).Min();
var yTop = corners.Select(c => c.y).Max();
//Debug.LogFormat("y pos: {0} bot: {1} y top: {2}; in: {3}", yVal, yBottom, yTop, input);
var distanceToApply = input * ScrollUnitsPerSecond * Time.deltaTime;
if (input > 0 && yBottom > 0)
{
return;
}
if (input < 0 && yTop < FixedOffset)
{
return;
}
yVal += distanceToApply;
transform.localPosition = new Vector3(transform.localPosition.x, yVal);
}
private GameObject GenerateEdge(Vertex source, Vertex target, int id, string label)
{
var edgeEndPoints = new Vector3[] { source.transform.position, target.transform.position };
var edgePosition = edgeEndPoints[0] + (edgeEndPoints[1] - edgeEndPoints[0]) / 2;
// LineRenderer and EdgeCollider2D work with local positions, therefore the edgeEndPoints have to be recalculated from world to local coordinates
var edgeEndPointsLocal = new Vector3[] { edgeEndPoints[0] - edgePosition, edgeEndPoints[1] - edgePosition };
GameObject edgeObject = Instantiate(Graph.EdgePrefab, edgePosition, Quaternion.identity);
edgeObject.name = "Edge" + source.ID + "-" + target.ID;
var lineRenderer = edgeObject.GetComponent <LineRenderer>();
lineRenderer.SetPositions(edgeEndPointsLocal);
var edgeCollider = edgeObject.GetComponent <EdgeCollider2D>();
edgeCollider.points = edgeEndPointsLocal.Select(eep => (Vector2)eep).ToArray();
Edge edge = edgeObject.GetComponent <Edge>();
edge.ID = id;
edge.Source = source;
edge.Target = target;
edge.Label = label;
edge.Weight = 0;
edge.OnSelectEdge += Graph.SelectEdge;
Graph.Edges.Add(edge);
source.Neighbours.Add(target);
source.OutDegree++;
target.InDegree++;
return(edgeObject);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
inputDeps.Complete();
var barrier = m_Barrier.CreateCommandBuffer();
Entities
.WithoutBurst()
.WithAll <MeshAssignTag>()
.ForEach((Entity entity, ref ChunkComponent cc, in RenderMesh rnd, in DynamicBuffer <IntBuffer> triangles, in DynamicBuffer <VectorBuffer> vertices) =>
{
barrier.RemoveComponent <MeshAssignTag>(entity);
var trianglesArray = new int[triangles.Length];; // triangles.Reinterpret<int>().ToArray();
var verticesArray = new Vector3[vertices.Length]; // vertices.Reinterpret<Vector3>().ToArray();
for (int i = 0; i < triangles.Length; i++)
{
trianglesArray[i] = triangles[i];
}
for (int i = 0; i < vertices.Length; i++)
{
verticesArray[i] = vertices[i];
}
rnd.mesh.Clear();
rnd.mesh.vertices = verticesArray;
rnd.mesh.triangles = trianglesArray;
rnd.mesh.normals = verticesArray.Select(x => new Vector3(0, 0, 1)).ToArray();
rnd.mesh.RecalculateBounds();
barrier.SetSharedComponent(entity, rnd);
}).Run();
private static void BakeNormalsToColor(Mesh mesh)
{
var vertices = mesh.vertices;
var normals = mesh.normals;
var colors = new Vector3[normals.Length];
for (var index0 = 0; index0 < normals.Length; index0++)
{
for (var index1 = 0; index1 < normals.Length; index1++)
{
if (Vector3.Distance(vertices[index0], vertices[index1]) > Mathf.Epsilon)
{
continue;
}
var normal0 = colors[index0].magnitude > Mathf.Epsilon ? colors[index0] :
normals[index0];
var normal1 = colors[index1].magnitude > Mathf.Epsilon ? colors[index1] :
normals[index1];
var normal = normal0 + normal1;
colors[index0] = colors[index1] = normal.normalized;
}
}
mesh.colors = colors.Select(x => new Color(x.x, x.y, x.z)).ToArray();
EditorUtility.SetDirty(mesh);
}
public Mesh GetMesh()
{
var supportCornerKeys = GetSupportCornerKeys();
var verticesCount = keys.Count + ((supportCornerKeys != null)? supportCornerKeys.Count: 0);
var vertices = new Vector3[verticesCount];
var colors = new Color32[verticesCount];
var verticesIndex = 0;
foreach (var key in keys)
{
vertices[verticesIndex] = key.position;
colors[verticesIndex] = key.color;
++verticesIndex;
}
if (supportCornerKeys != null)
{
foreach (var key in supportCornerKeys)
{
vertices[verticesIndex] = key.position;
colors[verticesIndex] = key.color;
++verticesIndex;
}
}
var index = VertexUtility.Triangulation(vertices.Select(x => (Vector2)x).ToList());
var result = new Mesh();
result.vertices = vertices;
result.colors32 = colors;
result.SetTriangles(index, 0);
return(result);
}
public IEnumerableWithCount <Vector3> ComputeNormals(List <Vector3> positions, List <int> indices)
{
//The number of the vertices
int nV = positions.Count;
//The number of the triangles
int nT = indices.Count / 3;
Vector3[] norm = new Vector3[nV]; //Array for the normals
//Scan all the triangles. For each triangle add its
//normal to norm's vectors of triangle's vertices
for (int t = 0; t < nT; t++)
{
//Get indices of the triangle t
int i1 = indices[3 * t];
int i2 = indices[3 * t + 1];
int i3 = indices[3 * t + 2];
//Get vertices of the triangle
Vector3 v1 = positions[i1];
Vector3 v2 = positions[i2];
Vector3 v3 = positions[i3];
//Compute the triangle's normal
Vector3 dir = Vector3.Normalize(Vector3.Cross(v2 - v1, v3 - v1));
//Accumulate it to norm array for i1, i2, i3
norm[i1] += dir;
norm[i2] += dir;
norm[i3] += dir;
}
return(new EnumerableWithCount <Vector3>(nV, norm.Select(v => Vector3.Normalize(v))));
}
} // end of PredictAllRemoteBodiesWithOwnedBodies
private Vector3 ClosestPointOnBounds(Godot.RigidBody from, Godot.RigidBody to)
{
var toCollisionShape = to.GetChild <CollisionShape>(1);
var aabb = toCollisionShape.Shape.GetDebugMesh().GetAabb();
var aabbPosition = aabb.Position;
var aabbEnd = aabb.End;
Vector3[] collisionPoint = new Vector3[8];
collisionPoint[0] = aabbPosition;
collisionPoint[1] = new Vector3(aabbPosition.x, aabbPosition.y, aabbEnd.z);
collisionPoint[2] = new Vector3(aabbEnd.x, aabbPosition.y, aabbEnd.z);
collisionPoint[3] = new Vector3(aabbEnd.x, aabbPosition.y, aabbPosition.z);
collisionPoint[4] = new Vector3(aabbPosition.x, aabbEnd.y, aabbPosition.z);
collisionPoint[5] = new Vector3(aabbPosition.x, aabbEnd.y, aabbEnd.z);
collisionPoint[6] = new Vector3(aabbEnd.x, aabbEnd.y, aabbPosition.z);
collisionPoint[7] = aabbEnd;
var shortest = to.GlobalTransform.origin.DistanceSquaredTo(from.GlobalTransform.origin);
Vector3 ret = Vector3.Zero;
foreach (var point in collisionPoint.Select(x => x + to.GlobalTransform.origin))
{
var distance = point.DistanceSquaredTo(from.GlobalTransform.origin);
if (shortest > distance)
{
shortest = distance;
ret = point;
}
}
return(ret);
}
private Bounds GetBounds(Transform transform)
{
Vector3 size = transform.lossyScale;
Vector3 min = -size / 2f;
Vector3 max = size / 2f;
Vector3[] vts = new Vector3[]
{
new Vector3(min.x, min.y, min.z),
new Vector3(max.x, min.y, min.z),
new Vector3(min.x, max.y, min.z),
new Vector3(max.x, max.y, min.z),
new Vector3(min.x, min.y, max.z),
new Vector3(max.x, min.y, max.z),
new Vector3(min.x, max.y, max.z),
new Vector3(max.x, max.y, max.z),
};
vts = vts.Select(transform.TransformDirection).ToArray();
min = vts.Aggregate(Vector3.Min);
max = vts.Aggregate(Vector3.Max);
return(new Bounds(transform.position, max - min));
}
private static IEnumerable<Polygon> CreatePolygons(Vector3[] points, int[][] indices, Func<int, Vector3, Vertex> vertexFactory)
{
Vertex[] vertices = points.Select((v, i) => vertexFactory(i, v)).ToArray();
for (int i = 0; i < indices.Length; i += 3)
yield return new Polygon(indices[i].Select(index => vertices[index]));
}
private void solveWithTRS(Vector3 translation,
Quaternion rotation,
out Vector3 solvedTranslation,
out Quaternion solvedRotation)
{
Vector3[] v0 = new Vector3[3];
v0[0] = new Vector3(1, 0, 0);
v0[1] = new Vector3(0, 1, 0);
v0[2] = new Vector3(0, 0, 1);
var v1 = v0.Select(v => rotation * v + translation).ToArray();
for (int i = 0; i < 3; i++)
{
var l0 = (v0[i]).ToCVector();
var l1 = (v1[i]).ToCVector();
KabschC.AddPoint(ref _kabsch, ref l0, ref l1, 1.0f);
}
KabschC.Solve(ref _kabsch);
LEAP_VECTOR leapTranslation;
LEAP_QUATERNION leapRotation;
KabschC.GetTranslation(ref _kabsch, out leapTranslation);
KabschC.GetRotation(ref _kabsch, out leapRotation);
solvedTranslation = leapTranslation.ToVector3();
solvedRotation = leapRotation.ToQuaternion();
}
public void drawBorders()
{
//Just a pinch more readable
int w = tiles.GetLength(0);
int l = tiles.GetLength(1);
int h = tiles.GetLength(2);
Vector3 offset = Util.GridToWorld(-0.5f, -0.5f, -0.8f);
Vector3[] positions = new Vector3[] {
Util.GridToWorld(0, 0, 0),
Util.GridToWorld(0, 0, h),
Util.GridToWorld(w, 0, h),
Util.GridToWorld(w, 0, 0),
Util.GridToWorld(0, 0, 0),
Util.GridToWorld(0, l, 0),
Util.GridToWorld(0, l, h),
Util.GridToWorld(0, 0, h),
Util.GridToWorld(0, l, h),
Util.GridToWorld(w, l, h),
Util.GridToWorld(w, l, 0),
Util.GridToWorld(0, l, 0),
Util.GridToWorld(w, l, 0),
Util.GridToWorld(w, 0, 0),
Util.GridToWorld(w, 0, h),
Util.GridToWorld(w, l, h)
};
positions = positions.Select((pos) => {
return(pos + offset);
}).ToArray();
lineRenderer.SetPositions(positions);
}
public static Vector3[] CornersInCanvasSpace(RectTransform r, RectTransform canvas)
{
Vector3[] worldCorners = new Vector3[4];
r.GetWorldCorners(worldCorners);
return(worldCorners.Select(v => canvas.InverseTransformPoint(v)
+ Vector3.up * canvas.rect.height).ToArray());
}
public Mesh GenerateMesh(TileData data)
{
int quads = data.Width * data.Height;
Vector3[] verts = new Vector3[quads * 4];
Vector2[] uvs = new Vector2[verts.Length];
int[] tris = new int[quads * 2 * 3];
for (int y = 0; y < data.Height; y++)
{
for (int x = 0; x < data.Width; x++)
{
if (data.Tiles[x, y].TileType == GenerateType.TileType)
{
GenerateQuad(x, y, verts, uvs, tris, data.Width, CalculateBitmask(data, x, y));
}
}
}
Vector3[] norms = verts.Select(x => Vector3.back).ToArray();
Mesh mesh = new Mesh();
mesh.vertices = verts;
mesh.normals = norms;
mesh.uv = uvs;
mesh.triangles = tris;
mesh.RecalculateBounds();
return(mesh);
}
// Update is called once per frame
void Update()
{
//Quaternion quat = transform.rotation;
//quat.eulerAngles = new Vector3(quat.eulerAngles.x, quat.eulerAngles.y, quat.eulerAngles.z + randRot * Time.deltaTime);
//transform.rotation = quat;
for (int i = 0; i < 4; i++)
{
cornerAngles[i] += cornerVelocities[i] * Time.deltaTime;
}
lineRenderer = GetComponent <LineRenderer>();
Vector3[] points = new Vector3[] {
new Vector3(-size.x, -size.y) + new Vector3(Mathf.Cos(cornerAngles[0]), Mathf.Sin(cornerAngles[0])) * cornerDistortionFactor,
new Vector3(-size.x, size.y) + new Vector3(Mathf.Cos(cornerAngles[1]), Mathf.Sin(cornerAngles[1])) * cornerDistortionFactor,
new Vector3(size.x, size.y) + new Vector3(Mathf.Cos(cornerAngles[2]), Mathf.Sin(cornerAngles[2])) * cornerDistortionFactor,
new Vector3(size.x, -size.y) + new Vector3(Mathf.Cos(cornerAngles[3]), Mathf.Sin(cornerAngles[3])) * cornerDistortionFactor
};
for (int i = 0; i < points.Length; i++)
{
points[i].z = 0;
}
mesh.vertices = points;
mesh.triangles = new int[] { 0, 1, 2, 2, 3, 0 };
lineRenderer.SetPositions(points.Select((Vector3 v) => transform.rotation * v + transform.position).ToArray());
}
public static Bounds GetBounds(Decal decal)
{
var transform = decal.transform;
var size = transform.lossyScale;
var min = -size / 2f;
var max = size / 2f;
var vts = new Vector3[] {
new Vector3(min.x, min.y, min.z),
new Vector3(max.x, min.y, min.z),
new Vector3(min.x, max.y, min.z),
new Vector3(max.x, max.y, min.z),
new Vector3(min.x, min.y, max.z),
new Vector3(max.x, min.y, max.z),
new Vector3(min.x, max.y, max.z),
new Vector3(max.x, max.y, max.z),
};
vts = vts.Select(transform.TransformDirection).ToArray();
min = vts.Aggregate(Vector3.Min);
max = vts.Aggregate(Vector3.Max);
return(new Bounds(transform.position, max - min));
}
public MeshBlock(Vector3[] mesh, Vector3 color)
{
this.mesh = mesh.Select(p => new BlockVertex()
{
position = p,
color = color
}).ToArray();
for (int i = 0; i < this.mesh.Length; i += 3)
{
Vector3 a = this.mesh[i + 0].position;
Vector3 b = this.mesh[i + 1].position;
Vector3 c = this.mesh[i + 2].position;
Vector3 normal =
Vector3.Cross(
Vector3.Normalize(b - a),
Vector3.Normalize(c - a));
for (int j = 0; j < 3; j++)
{
this.mesh[i + j].normal = normal;
}
}
}
void Start()
{
_lr = GetComponent <LineRenderer>();
_pc = GetComponent <PolygonCollider2D>();
_rb = GetComponent <Rigidbody2D>();
if (AsteroidType == AsteroidType.Offshoot)
{
_size = 0.1f;
}
var positions = new Vector3[6];
for (int i = 0; i < positions.Length; i++)
{
positions[i] = HexCorner(Vector3.zero, _size, i);
}
_lr.positionCount = positions.Length;
_lr.SetPositions(positions);
_pc.SetPath(0, positions.Select(p => new Vector2(p.x, p.y)).ToArray());
_rb.AddForce(_force);
_rb.AddTorque(Random.Range(-_torqueMinMax, _torqueMinMax));
}
/**
* Given a list of control points, this will create a list of pointsPerSegment
* points spaced uniformly along the resulting Catmull-Rom curve.
*
* @param points The list of control points, leading and ending with a
* Vector3inate that is only used for controling the spline and is not visualized.
* @param index The index of control point p0, where p0, p1, p2, and p3 are
* used in order to create a curve between p1 and p2.
* @param pointsPerSegment The total number of uniformly spaced interpolated
* points to calculate for each segment. The larger this number, the
* smoother the resulting curve.
* @param curveType Clarifies whether the curve should use uniform, chordal
* or centripetal curve types. Uniform can produce loops, chordal can
* produce large distortions from the original lines, and centripetal is an
* optimal balance without spaces.
* @return the list of Vector3inates that define the CatmullRom curve
* between the points defined by index+1 and index+2.
*/
private static List <Vector3> InterpolateSegment(List <Vector3> points, int index, int pointsPerSegment, CatmullRomType curveType)
{
List <Vector3> result = new List <Vector3>();
Vector3[] controlPointsInSegment = new Vector3[4];
float[] time = new float[4];
for (int i = 0; i < 4; i++)
{
controlPointsInSegment[i] = points[index + i];
time[i] = i;
}
float tstart = 1;
float tend = 2;
if (curveType != CatmullRomType.Uniform)
{
float total = 0;
for (int i = 1; i < 4; i++)
{
Vector3 delta = controlPointsInSegment[i] - controlPointsInSegment[i - 1];
if (curveType == CatmullRomType.Centripetal)
{
total += Mathf.Pow(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z, 0.25f);
}
else
{
total += Mathf.Pow(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z, 0.5f);
}
time[i] = total;
}
tstart = time[1];
tend = time[2];
}
int segments = pointsPerSegment - 1;
result.Add(points[index + 1]);
for (int i = 1; i < segments; i++)
{
float xi = Interpolate(controlPointsInSegment.Select(p => p.x).ToArray(), time, tstart + (i * (tend - tstart)) / segments);
float yi = Interpolate(controlPointsInSegment.Select(p => p.y).ToArray(), time, tstart + (i * (tend - tstart)) / segments);
float zi = Interpolate(controlPointsInSegment.Select(p => p.z).ToArray(), time, tstart + (i * (tend - tstart)) / segments);
result.Add(new Vector3(xi, yi, zi));
}
result.Add(points[index + 2]);
return(result);
}
public Rainbow(Game game)
: base(game)
{
dash = game.Content.Load<Texture2D>("dash");
var RainbowTexels = new Vector3[] {
new Vector3(1.0F, 0.25F, 0.25F),
new Vector3(1.0F, 0.5F, 0.25F),
new Vector3(0.96F, 0.96F, 0),
new Vector3(0.25F, 1.0F, 0.5F),
new Vector3(0, 0.375F, 1.0F),
new Vector3(0.375F, 0, 0.625F)
};
RainbowTextureFlat = new Texture2D(device, 1, RainbowTexels.Length);
RainbowTextureFlat.SetData(RainbowTexels.Select(t => new Color(new Vector4(t, 1.0F))).ToArray());
//Rainbow bands are made up of the original texels, at half intensity
var RainbowBandTexels = RainbowTexels.Select(t => new Vector4(t * 0.5F, 0F)).ToArray();
//Add gap equal to the rainbow width
RainbowBandTexels = RainbowBandTexels.Concat(Enumerable.Repeat(Vector4.Zero, RainbowBandTexels.Length)).ToArray();
//Multiply it to 11 copies
RainbowBandTexels = Enumerable.Repeat(RainbowBandTexels, 11).SelectMany(c => c).ToArray();
//Remove the last gap
RainbowBandTexels = RainbowBandTexels.Take(RainbowBandTexels.Length - RainbowTexels.Length).ToArray();
RainbowBandTexture = new Texture2D(device, 1, RainbowBandTexels.Length);
RainbowBandTexture.SetData(RainbowBandTexels.Select(t => new Color(t)).ToArray());
Phases = new Phase[] {
//new Phase(0, 2, DoPhase0),
new Phase(0, 2, DoPhase1),
new Phase(2, 17, DoPhase2),
new Phase(15, 17, DoPhase3),
new Phase(17, 40, DoPhase4),
new Phase(38, 40, DoPhase1),
new Phase(40, 62, DoPhase5),
new Phase(60, 62, DoPhase6),
};
RainbowBlendState = GetRainbowBlendState();
}
public static Vector3[] GenerateAlphabet(
int alphabetSize = 128,
int iterations = 256,
float startingStepSize = 0.1f,
float endingStepSize = 0.001f,
System.Random random = null,
params Vector3[] fixedValues)
{
const float EPSILON = 0.001f;
const float EPSILON_SQUARED = EPSILON * EPSILON;
const int DEFAULT_RANDOM_SEED = 11311;
random = random ?? new System.Random(DEFAULT_RANDOM_SEED);
var alphabet = new Vector3[alphabetSize];
for (int idx = 0; idx < alphabet.Length; idx++)
{
alphabet[idx] = new Vector3(
(float)random.NextDouble() - 0.5f,
(float)random.NextDouble() - 0.5f,
(float)random.NextDouble() - 0.5f)
.normalized;
}
for (int idx = 0; idx < fixedValues.Length; idx++)
{
alphabet[idx] = fixedValues[idx];
}
for (int iteration = 0; iteration < iterations; iteration++)
{
float stepSize = Lerp(startingStepSize, endingStepSize, iteration / (iterations - 1f));
for (int idx = fixedValues.Length; idx < alphabetSize; idx++)
{
var here = alphabet[idx];
var force = alphabet.Select(there =>
{
var vec = here - there;
if (vec.sqrMagnitude < EPSILON_SQUARED)
{
return(new Vector3(0f, 0f, 0f));
}
else
{
return(vec / vec.magnitude / vec.sqrMagnitude);
}
}).Aggregate(new Vector3(0f, 0f, 0f), (acc, pt) => acc + pt);
alphabet[idx] = here + stepSize * force;
alphabet[idx].Normalize();
}
}
return(alphabet);
}
public void AddPoint(Vector2 coordinates)
{
LineRenderer.positionCount++;
LineRenderer.SetPosition(LineRenderer.positionCount - 1, coordinates);
Vector3[] positions = new Vector3[LineRenderer.positionCount];
LineRenderer.GetPositions(positions);
EdgeCollider.points = positions.Select(x => new Vector2(x.x, x.y)).ToArray();
}
public void JointBB(List <Corner> newBB)
{
float maxY = Mathf.Max(Corners[2].position.y, newBB[2].position.y);
float minY = Mathf.Min(Corners[0].position.y, newBB[0].position.y);
//Get Top Corners
Vector3[] points = new Vector3[8] {
Corners[2].position,
Corners[4].position,
Corners[5].position,
Corners[7].position,
newBB[2].position,
newBB[4].position,
newBB[5].position,
newBB[7].position
};
//Get best angle with minimun area
float[] rectangle = CalculateRectangleCorners(points);
float[] best_rectangle = rectangle;
float best_area = (rectangle[1] - rectangle[0]) * (rectangle[3] - rectangle[2]);
float best_angle = 0;
for (float angle = 1; angle < 90; angle += 1)
{
rectangle = CalculateRectangleCorners(points.Select(r => Quaternion.Euler(0, angle, 0) * r).ToArray());
float area = (rectangle[1] - rectangle[0]) * (rectangle[3] - rectangle[2]);
if (area < best_area)
{
best_area = area;
best_rectangle = rectangle;
best_angle = angle;
}
}
//min X, max X, min Y, max Y
Vector3[] newBox = new Vector3[8] {
new Vector3(best_rectangle[1] - erosion, minY + erosion, best_rectangle[2] + erosion),
new Vector3(best_rectangle[0] + erosion, minY + erosion, best_rectangle[2] + erosion),
new Vector3(best_rectangle[1] - erosion, maxY - erosion, best_rectangle[2] + erosion),
new Vector3(best_rectangle[1] - erosion, minY + erosion, best_rectangle[3] - erosion),
new Vector3(best_rectangle[0] + erosion, maxY - erosion, best_rectangle[3] - erosion),
new Vector3(best_rectangle[1] - erosion, maxY - erosion, best_rectangle[3] - erosion),
new Vector3(best_rectangle[0] + erosion, minY + erosion, best_rectangle[3] - erosion),
new Vector3(best_rectangle[0] + erosion, maxY - erosion, best_rectangle[2] + erosion)
};
newBox = newBox.Select(r => Quaternion.Euler(0, -best_angle, 0) * r).ToArray();
for (int i = 0; i < Corners.Count; i++)
{
Corners[i] = new Corner(newBox[i], true);
}
}
public Vector2[] GetButtonCornersInWorldSpace(Tool tool)
{
var buttonTransform = toolToButton[tool].GetComponent <RectTransform>();
Vector3[] corners = new Vector3[4];
buttonTransform.GetWorldCorners(corners);
return(corners
.Select(corner => (Vector2)corner)
.ToArray());
}
private Vector3[] GetFrustumCorners()
{
var cameraTransform = drawnCamera.transform;
var frustumCorners = new Vector3[4];
drawnCamera.CalculateFrustumCorners(
new Rect(0, 0, 1, 1),
drawnCamera.farClipPlane,
Camera.MonoOrStereoscopicEye.Mono,
frustumCorners
);
return(frustumCorners.Select(c => cameraTransform.TransformVector(c) + cameraTransform.position).ToArray());
}
public Thor(Vector3 center, float radius1, float radius2, int frequency1, int frequency2) : base()
{
Pivot = Pivot.BasePivot(center);
GlobalVertices = new Vector3[frequency1 * frequency2];
Indexes = new int[frequency1 * frequency2 * 6];
Normals = new Vector3[frequency1 * frequency2];
NormalIndexes = new int[Indexes.Length];
var step1 = (float)Math.PI * 2 / frequency1;
var step2 = (float)Math.PI * 2 / frequency2;
var rPivot1 = Pivot.BasePivot(center);
for (int i = 0; i < frequency1; i++)
{
var rPivot2 = new Pivot(rPivot1.Center + rPivot1.XAxis * radius1, rPivot1.XAxis, rPivot1.YAxis, rPivot1.ZAxis);
for (int g = 0; g < frequency2; g++)
{
var global = GlobalVertices[i * frequency2 + g] = rPivot2.ToGlobalCoords(Vector3.UnitX * radius2);
rPivot2.Rotate(step2, Axis.Z);
}
rPivot1.Rotate(step1, Axis.Y);
}
for (int i = 0; i < frequency1 - 1; i++)
{
for (int g = 0; g < frequency2 - 1; g++)
{
int k = (i * frequency2 + g) * 6;
int i1 = Indexes[k] = i * frequency2 + g;
int i2 = Indexes[k + 1] = i * frequency2 + g + 1;
int i3 = Indexes[k + 2] = (i + 1) * frequency2 + g;
int i4 = Indexes[k + 3] = i * frequency2 + g + 1;
int i5 = Indexes[k + 4] = (i + 1) * frequency2 + g + 1;
int i6 = Indexes[k + 5] = (i + 1) * frequency2 + g;
var normal = VectorMath.GetNormal(GlobalVertices[i4], GlobalVertices[i5], GlobalVertices[i6]);
Normals[i * frequency2 + g] = normal;
NormalIndexes[(i * frequency2 + g) * 6] =
NormalIndexes[(i * frequency2 + g) * 6 + 1] =
NormalIndexes[(i * frequency2 + g) * 6 + 2] =
NormalIndexes[(i * frequency2 + g) * 6 + 3] =
NormalIndexes[(i * frequency2 + g) * 6 + 4] =
NormalIndexes[(i * frequency2 + g) * 6 + 5] = i * frequency2 + 1;
}
}
LocalVertices = GlobalVertices.Select(v => Pivot.ToLocalCoords(v)).ToArray();
}
public static (Vector3 u, Vector3 v) Orthogonal(this Vector3 along)
{
var temp = new Vector3[] {
Vector3.Cross(Vector3.UnitX, along),
Vector3.Cross(Vector3.UnitY, along),
Vector3.Cross(Vector3.UnitZ, along)
};
var metric = temp.Select((vec) => vec.Length()).ToArray();
var index = MaxIndex(metric);
var u = Vector3.Normalize(temp[index]);
var v = Vector3.Normalize(Vector3.Cross(u, along));
return(u, v);
}
public static List <Vector3> CreatePositionsAround(Transform transform, float range)
{
Vector3[] source = new Vector3[8]
{
new Vector3(-0.5f, 0.5f, -0.5f),
new Vector3(-0.5f, 0.5f, 0.5f),
new Vector3(0.5f, 0.5f, 0.5f),
new Vector3(0.5f, 0.5f, -0.5f),
new Vector3(-0.5f, -0.5f, -0.5f),
new Vector3(-0.5f, -0.5f, 0.5f),
new Vector3(0.5f, -0.5f, 0.5f),
new Vector3(0.5f, -0.5f, -0.5f)
};
return(source.Select((Vector3 x) => transform.TransformPoint(x * range)).ToList());
}
/// <summary>
/// Calibrates the accelerometer.
/// You can override default <paramref name="samples"/> and <paramref name="calibrationInterval"/> if required.
/// </summary>
/// <param name="samples">The number of times every axis is measured. The average of these measurements is used to calibrate each axis.</param>
/// <param name="calibrationInterval">The time in milliseconds to wait between each measurement. If null is provided, <see cref="CalibrationIntervalDefault"/> in milliseconds is used.</param>
/// <remarks>
/// Make sure that the sensor is placed horizontally when executing this method.
/// </remarks>
public async Task CalibrateAccelerationSensor(int samples = SamplesDefault, TimeSpan?calibrationInterval = null)
{
var caliBuffer = new Vector3[samples];
calibrationInterval ??= TimeSpan.FromMilliseconds(CalibrationIntervalDefault);
for (int i = 0; i < samples; i++)
{
var acc = GetRawAccelerometer();
caliBuffer[i].X = acc.X;
caliBuffer[i].Y = acc.Y;
caliBuffer[i].Z = acc.Z;
await Task.Delay(calibrationInterval.Value).ConfigureAwait(false);
}
var avgX = caliBuffer.Select(v => v.X).Average();
var avgY = caliBuffer.Select(v => v.Y).Average();
var avgZ = caliBuffer.Select(v => v.Z).Average();
var x = (((avgZ - avgX) + (avgZ - avgY)) / 2);
_factory = x == 0 ? float.PositiveInfinity : 1.0F / x;
}
/// <summary>
/// CollidesWith returns true if the palyer character is sufficiently close to path.
/// </summary>
public bool CollidesWith(IEnumerable <Vector2> path, float size)
{
Vector3[] vectors = new Vector3[]
{
bodyManager.Left.Foot.Anchor,
bodyManager.Left.Foot.Target,
bodyManager.Right.Foot.Anchor,
bodyManager.Right.Foot.Target
};
return(vectors
.Select(vector => Geometry.ProjectOnPath(new Vector2(vector.x, vector.z), path))
.Where(projection => projection.HasValue)
.Any(projection => projection.Value.Item2 < 0.5f * size));
}
/// <summary>
/// Gets distance between hotbar and player by getting hotbar bounds and using <see cref="Bounds.ClosestPoint(Vector3)"/> to get correct distance.
/// </summary>
/// <returns>Distance in units</returns>
float DistanceBetweenHotbarAndPlayer()
{
var screenPosition = Camera.main.WorldToScreenPoint(Player.transform.position);
Vector3[] v = new Vector3[4];
RectTransform.GetWorldCorners(v);
var worldCornersRelativeToCam = v.Select(x => Camera.main.ScreenToWorldPoint(x)).ToArray();
var minDistanceTo = worldCornersRelativeToCam.Min(x => Vector2.Distance(x, Player.transform.position));
RectTransformUtility.ScreenPointToLocalPointInRectangle(CanvasRectTransform, screenPosition, null, out Vector2 localpoint);
var bounds = RectTransformUtility.CalculateRelativeRectTransformBounds(CanvasRectTransform, RectTransform);
var closestPoint = bounds.ClosestPoint(localpoint);
return(Vector3.Distance(closestPoint, localpoint));
}
/// <summary>
/// Returns array of coordinates of screen rectangle of the given `RectTransform`
/// </summary>
/// <param name="transform">`RectTransform` component instance</param>
/// <returns>Array of coords of screen rectangle of given `RectTransform`</returns>
public static Vector2[] ScreenVerticesOfObject(RectTransform transform)
{
Vector3[] worldCoreners = new Vector3[4];
transform.GetWorldCorners(worldCoreners);
var anyCamera = FindAnyGameObject <Camera>();
if (anyCamera != null)
{
Canvas canvas = null;
Transform root = transform;
while (root)
{
var newCanvas = root.GetComponent <Canvas>();
if (newCanvas != null)
{
canvas = newCanvas;
}
root = root.parent;
}
if (canvas != null)
{
switch (canvas.renderMode)
{
case RenderMode.ScreenSpaceCamera:
anyCamera = canvas.worldCamera ?? Camera.main;
break;
case RenderMode.WorldSpace:
anyCamera = Camera.main;
break;
case RenderMode.ScreenSpaceOverlay:
anyCamera = null;
break;
}
var screenCorners = worldCoreners
.Select(worldPoint => RectTransformUtility.WorldToScreenPoint(anyCamera, worldPoint)).ToArray();
return(screenCorners);
}
}
return(null);
}
public static Vector3[] CreateCurve(Vector3[] roadLine, int Segments, float Offset, bool Invert)
{
Vector2[] roadCurve = Misc.GetBezierApproximation(roadLine.Select(p=>p.Xz).ToArray(), Segments);
Vector2[] heightLine = new Vector2[roadLine.Length];
Vector2 prevPoint = roadLine[0].Xz;
for (int i = 0; i < heightLine.Length; i++)
{
heightLine[i] = new Vector2((roadLine[i].Xz - prevPoint).Length, roadLine[i].Y);
prevPoint = roadLine[i].Xz;
}
Vector2[] heightCurve = Misc.GetBezierApproximation(heightLine, Segments);
Vector3[] PathNodes = new Vector3[Segments + 1];
for (int i = 0; i < Segments + 1; i++)
{
Vector2 dir = new Vector2();
if (i== 0) dir = (roadCurve[i] - roadCurve[i+1]);
else if (i == Segments) dir = (roadCurve[i - 1] - roadCurve[i]);
else dir = (roadCurve[i - 1] - roadCurve[i]) + (roadCurve[i] - roadCurve[i + 1]);
dir.Normalize();
dir *= Offset;
PathNodes[(Invert) ? Segments - i : i] = new Vector3(roadCurve[i].X + dir.Y, heightCurve[i].Y, roadCurve[i].Y - dir.X);
}
return PathNodes;
}
public void DrawAllMap(GameTime gt, Camera cam)
{
_passn++;
if (_passn > Sectn*Sectn - 1) {
_passn = 0;
}
_be.Parameters["worldMatrix"].SetValue(Matrix.Identity);
_be.Parameters["viewMatrix"].SetValue(Main.Camera.View);
_be.Parameters["projectionMatrix"].SetValue(Main.Camera.Projection);
_be.Parameters["diffuseColor"].SetValue(Color.White.ToVector4());
_be.Parameters["ambientColor"].SetValue(Color.DarkGray.ToVector4());
var ld = new Vector3(0.5f, -1, -1.2f);
ld.Normalize();
_be.Parameters["lightDirection"].SetValue(ld);
_be.Parameters["shaderTexture"].SetValue(Main.texatlas);
_gd.RasterizerState = RasterizerState.CullCounterClockwise;
_gd.DepthStencilState = DepthStencilState.Default;
_gd.BlendState = BlendState.AlphaBlend;
drawed_sects = 0;
drawed_verts = 0;
foreach (EffectPass pass in _be.CurrentTechnique.Passes) {
pass.Apply();
foreach (MapSector a in N) {
if (cam.Frustum.Contains(new BoundingBox(a.bounding.Min, a.bounding.Max)) !=
ContainmentType.Disjoint) {
if (!a.builded) {
a.RebuildSectorGeo(_gd, Main.z_cam);
sectrebuild++;
}
if (!a.empty) {
drawed_sects++;
_gd.DrawUserPrimitives(PrimitiveType.TriangleList, a.VertexArray, 0, a.index/3);
drawed_verts += a.index/3;
}
}
}
foreach (MapSector a in N) {
if (a.indextransparent > 0) {
_gd.DrawUserPrimitives(PrimitiveType.TriangleList, a.VertexArrayTransparent, 0,
a.indextransparent/3);
drawed_verts += a.indextransparent/3;
}
}
}
_basice2.VertexColorEnabled = true;
_basice2.Alpha = 0.5f;
_basice2.Projection = cam.Projection;
_basice2.View = cam.View;
//_gd.BlendState = BlendState.AlphaBlend;
Color greentop = At(Main.Selector).BlockID == 0
? At(Main.Selector.X, Main.Selector.Y, Main.Selector.Z + 1).BlockID != 0
? Color.Yellow
: Color.Red
: Color.Green;
greentop.A = 128;
Color greencube = greentop*0.5f;
Color selecttop = Color.LightGray;
selecttop.A = 128;
Color selectcube = selecttop*0.5f;
vl1.Clear();
var ramka_3 = new Vector3();
if (Mouse.GetState().RightButton == ButtonState.Pressed) {
Main.ramka_2.X = Math.Max(Main.Selector.X, Main.ramka_1.X);
Main.ramka_2.Y = Math.Max(Main.Selector.Y, Main.ramka_1.Y);
Main.ramka_2.Z = Math.Max(Main.Selector.Z, Main.ramka_1.Z);
ramka_3 = new Vector3(Math.Min(Main.Selector.X, Main.ramka_1.X),
Math.Min(Main.Selector.Y, Main.ramka_1.Y),
Math.Min(Main.Selector.Z, Main.ramka_1.Z));
}
foreach (EffectPass pass in _basice2.CurrentTechnique.Passes) {
pass.Apply();
AddCubeverts(Main.Selector, new Vector3(Main.Selector.X + 1, Main.Selector.Y + 1, Main.Selector.Z + 127),
greencube, greentop, 0.02f);
if (Mouse.GetState().RightButton == ButtonState.Pressed) {
AddCubeverts(ramka_3, new Vector3(Main.ramka_2.X + 1, Main.ramka_2.Y + 1, Main.ramka_2.Z + 1),
selectcube, selecttop, 0.01f);
}
//VertexBuffer vb1 = new VertexBuffer(gd, typeof (VertexPositionColor), 18, BufferUsage.WriteOnly);
//vb1.SetData(vl1,0,18);
//gd.SetVertexBuffer(vb1);
_gd.DrawUserPrimitives(PrimitiveType.TriangleList, vl1.ToArray(), 0, vl1.Count()/3);
}
_basice.VertexColorEnabled = false;
_basice.Projection = cam.Projection;
_basice.View = cam.View;
vl.Clear();
if (Main.debug) {
foreach (EffectPass pass in _basice.CurrentTechnique.Passes) {
pass.Apply();
foreach (MapSector a in N) {
var vv = new Vector3[24];
vv[0] = a.bounding.Min;
vv[11] = a.bounding.Max;
vv[1] = new Vector3(vv[11].X, vv[0].Y, vv[0].Z);
vv[2] = new Vector3(vv[11].X, vv[0].Y, vv[0].Z);
vv[3] = new Vector3(vv[11].X, vv[11].Y, vv[0].Z);
vv[4] = new Vector3(vv[11].X, vv[11].Y, vv[0].Z);
vv[5] = new Vector3(vv[0].X, vv[11].Y, vv[0].Z);
vv[6] = new Vector3(vv[0].X, vv[11].Y, vv[0].Z);
vv[7] = new Vector3(vv[0].X, vv[0].Y, vv[0].Z);
vv[8] = new Vector3(vv[0].X, vv[0].Y, vv[11].Z);
vv[9] = new Vector3(vv[11].X, vv[0].Y, vv[11].Z);
vv[10] = new Vector3(vv[11].X, vv[0].Y, vv[11].Z);
vv[12] = a.bounding.Max;
vv[13] = new Vector3(vv[0].X, vv[11].Y, vv[11].Z);
vv[14] = new Vector3(vv[0].X, vv[11].Y, vv[11].Z);
vv[15] = new Vector3(vv[0].X, vv[0].Y, vv[11].Z);
vv[16] = vv[0];
vv[17] = vv[8];
vv[18] = vv[1];
vv[19] = vv[9];
vv[20] = vv[3];
vv[21] = vv[11];
vv[22] = vv[5];
vv[23] = vv[13];
vl.AddRange(vv.Select(vector3 => new VertexPositionColor(vector3, Color.Red)));
}
if (vl.Count > 0) {
//VertexBuffer vb = new VertexBuffer(gd, typeof (VertexPositionColor), vl.Count,
// BufferUsage.WriteOnly);
//vb.SetData(vl.ToArray());
//gd.SetVertexBuffer(vb);
_gd.DrawUserPrimitives(PrimitiveType.LineList, vl.ToArray(), 0, vl.Count/2);
}
}
}
}
private void AssertDots(float torque, Vector3 position, params float[] expected)
{
var perp = CalculatePerp(position, torque);
var exhaust = new Vector3[] { Vector3.up, Vector3.right, Vector3.down, Vector3.left };
var dots = exhaust.Select(v => Mathf.Max(Vector3.Dot(perp, v), 0)).ToArray();
foreach (var dot in dots)
{
Console.Write(dot + " ");
}
Console.WriteLine();
CollectionAssert.AreEqual(dots, expected);
}
public void SetPositions(Vector3[] vertices)
{
Vector3 norm = new Vector3(0, 0, -1);
SetPositions(vertices, vertices.Select(_ => norm).ToArray(), vertices.Select(_ => System.Drawing.Color.White).ToArray());
}
private void BuildMesh()
{
/*
1. Loop through hex grid in offset-coordinates (http://www.redblobgames.com/grids/hexagons/#map-storage)
2. For each hex pos, get coordinates of each corner
3. Use hash table to get vertex index of corner, store corner with index if not found.
4. Create triangles based on vertex indices stored in hash table.
*/
int numTiles = SizeX * SizeZ;
int numTriangles = numTiles * 4;
//var verticesMap = new Dictionary<Vector3, int>();
var vertices = new Vector3[numTiles * 6];
var triangles = new int[numTriangles * 3];
var hexes = new HexCoord[numTiles];
var uvMap = new Dictionary<int, Vector2>();
int triIndex = 0;
int vIndex = 0;
int x, z, h = 0;
for (x = 0; x < SizeX; x++)
for (z = 0; z < SizeZ; z++)
{
hexes[h] = HexCoord.FromOffsetOddR(x, z);
var corners = hexes[h].Corners().Select(p => new Vector3(p.x * TileScale, 0, p.y * TileScale)).ToArray();
triangles[triIndex++] = vIndex + 0;
triangles[triIndex++] = vIndex + 5;
triangles[triIndex++] = vIndex + 4;
triangles[triIndex++] = vIndex + 0;
triangles[triIndex++] = vIndex + 4;
triangles[triIndex++] = vIndex + 3;
triangles[triIndex++] = vIndex + 0;
triangles[triIndex++] = vIndex + 3;
triangles[triIndex++] = vIndex + 1;
triangles[triIndex++] = vIndex + 1;
triangles[triIndex++] = vIndex + 3;
triangles[triIndex++] = vIndex + 2;
int cornerIndex = 0;
foreach (var v in corners)
{
vertices[vIndex] = v;
var uv = GetUvForCornerAndPlayer(cornerIndex, Player.NoPlayer);
uvMap.Add(vIndex, uv);
vIndex++;
cornerIndex++;
}
h++;
}
var mesh = new Mesh();
mesh.vertices = vertices;
mesh.normals = vertices.Select(i => Vector3.up).ToArray();
mesh.uv = uvMap.OrderBy(pair => pair.Key).Select(pair => pair.Value).ToArray();
mesh.triangles = triangles;
var meshFilter = GetComponent<MeshFilter>();
meshFilter.mesh = mesh;
var meshCollider = GetComponent<MeshCollider>();
meshCollider.sharedMesh = mesh;
}
public static graphLine[] calculateLines(Vector3[] aPoints, Vector3[] bPoints)
{
//Create triangles and reverse if unclockwise
var aPoints2D = getClockwisePoint2D(aPoints);
var bPoints2D = getClockwisePoint2D(bPoints);
//Create edges
var aEdges = new List<graphLine>(aPoints.Length);
for (int i = 0; i < aPoints2D.Length; i++)
{
var edge = new graphLine { aMain = true, a = true, p1 = aPoints2D[i], p2 = aPoints2D[(i + 1) % aPoints2D.Length] };
aEdges.Add(edge);
}
var bEdges = new List<graphLine>(bPoints.Length);
for (int i = 0; i < bPoints2D.Length; i++)
{
var edge = new graphLine { aMain = false, b = true, p1 = bPoints2D[i], p2 = bPoints2D[(i + 1) % bPoints2D.Length] };
bEdges.Add(edge);
}
//Phase 1: Split & cross
int aFirstCrossIndex = -1, bFirstCrossIndex = -1;
for (int i1 = 0; i1 < aEdges.Count; i1++)
{
for (int i2 = 0; i2 < bEdges.Count; i2++)
{
graphLine[] aOut, bOut;
if (_detectIntersectionsIfNeed(aEdges[i1], bEdges[i2], out aOut, out bOut))
{
aEdges.RemoveAt(i1);
bEdges.RemoveAt(i2);
aEdges.InsertRange(i1, aOut);
bEdges.InsertRange(i2, bOut);
aFirstCrossIndex = i1 + 1;
bFirstCrossIndex = i2 + 1;
i2++;
}
}
}
//Phase 2: Fill
if (aFirstCrossIndex != -1)
{
bool cursor = aEdges[aFirstCrossIndex].b;
for (int i = 0; i < aEdges.Count; i++)
{
var index = (i + aFirstCrossIndex)%aEdges.Count;
var edge = aEdges[index];
edge.b = cursor;
if (edge.p2.isCross)
cursor = !cursor;
}
}
if (bFirstCrossIndex != -1)
{
bool cursor = bEdges[bFirstCrossIndex].a;
for (int i = 0; i < bEdges.Count; i++)
{
var index = (i + bFirstCrossIndex) % bEdges.Count;
var edge = bEdges[index];
edge.a = cursor;
if (edge.p2.isCross)
cursor = !cursor;
}
}
if (aFirstCrossIndex == -1 && bFirstCrossIndex == -1)
{
//contains triangle area
var aV2 = aPoints.Select(x => (Vector2) x).ToArray();
var bV2 = bPoints.Select(x => (Vector2) x).ToArray();
if (isConvexPolygon(aV2) && isConvexPolygon(bV2))
{
if (contain.convex(aV2, bV2[0], true))
{
bEdges.ForEach(x => x.a = true);
var advancedEdge = new graphLine { a = true, aMain = true, b = false, p1 = MaxYItem(aPoints2D), p2 = MaxYItem(bPoints2D)};
aEdges.Add(advancedEdge);
} else if (contain.convex(bV2, aV2[0], true))
{
aEdges.ForEach(x => x.b = true);
var advancedEdge = new graphLine { b = true, aMain = false, a = false, p1 = MaxYItem(aPoints2D), p2 = MaxYItem(bPoints2D)};
bEdges.Add(advancedEdge);
}
}
else //if not convex
{
if (contain.nonzeroRule(aV2, bV2[0]))
{
bEdges.ForEach(x => x.a = true);
var advancedEdge = new graphLine { a = true, aMain = true, b = false, p1 = MaxYItem(aPoints2D), p2 = MaxYItem(bPoints2D) };
aEdges.Add(advancedEdge);
}
else if (contain.nonzeroRule(bV2, aV2[0]))
{
aEdges.ForEach(x => x.b = true);
var advancedEdge = new graphLine { b = true, aMain = false, a = false, p1 = MaxYItem(aPoints2D), p2 = MaxYItem(bPoints2D) };
bEdges.Add(advancedEdge);
}
}
}
return aEdges.Concat(bEdges).ToArray();
}
public LightShape(Vector3 C, float size, Vector3 E1, Vector3 E2, Vector3 E3, Func<Vector2, Vector2> texTran)
{
Vertices = new Vector3[]
{
C,
new Vector3(
C.X + size * 0.5f * E1.X + size * 0.5f * E2.X + size * 0.5f * E3.X,
C.Y + size * 0.5f * E1.Y + size * 0.5f * E2.Y + size * 0.5f * E3.Y,
C.Z + size * 0.5f * E1.Z + size * 0.5f * E2.Z + size * 0.5f * E3.Z),
new Vector3(
C.X - size * 0.5f * E1.X + size * 0.5f * E2.X + size * 0.5f * E3.X,
C.Y - size * 0.5f * E1.Y + size * 0.5f * E2.Y + size * 0.5f * E3.Y,
C.Z - size * 0.5f * E1.Z + size * 0.5f * E2.Z + size * 0.5f * E3.Z),
new Vector3(
C.X - size * 0.5f * E1.X - size * 0.5f * E2.X + size * 0.5f * E3.X,
C.Y - size * 0.5f * E1.Y - size * 0.5f * E2.Y + size * 0.5f * E3.Y,
C.Z - size * 0.5f * E1.Z - size * 0.5f * E2.Z + size * 0.5f * E3.Z),
new Vector3(
C.X + size * 0.5f * E1.X - size * 0.5f * E2.X + size * 0.5f * E3.X,
C.Y + size * 0.5f * E1.Y - size * 0.5f * E2.Y + size * 0.5f * E3.Y,
C.Z + size * 0.5f * E1.Z - size * 0.5f * E2.Z + size * 0.5f * E3.Z),
};
Indices = new int[]
{
0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 1, 1, 2, 3, 3, 4, 1
};
Vertices = Indices.Select(i => Vertices[i]).ToArray();
int c = 0;
Indices = Indices.Select(_ => c++).ToArray();
var ids = Dynamight.ImageProcessing.CameraCalibration.Range.OfInts(Indices.Length / 3);
Func<int, Vector3> findN = (i) =>
{
var p0 = Vertices[i * 3 + 0];
var p1 = Vertices[i * 3 + 1];
var p2 = Vertices[i * 3 + 2];
var e1 = p1 - p0;
var e2 = p2 - p0;
var n = Vector3.Cross(e1, e2);
n.Normalize();
return n;
};
Normals = Indices.Select(i => findN((int)Math.Floor((double)i / (double)3))).ToArray();
Texcoords = Vertices.Select(v => texTran(new Vector2(0, 0))).ToArray();
Colors = Vertices.Select(_ => ColorToRgba32(Color.White)).ToArray();
}
public void SetPositions(Vector3[][] verts, Matrix4[] modelviews)
{
SetPositions(verts.SelectMany(v => v));
ModelViews = modelviews;
int c = 0;
Lengths = verts.Select(v => c += v.Length * 6).ToArray();
}
public GemModel CreateBlueGemModel()
{
var gemCorners = new Vector3[] {
new Vector3(0F, 0.7F, 0.5F),
new Vector3(0.35F, 0.4F, 0.35F * (float) Math.Sqrt(3))
};
//Create 6 rotations of those two vertices
gemCorners = (from i in Enumerable.Range(0, 6)
from v in gemCorners
select Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * i / 3F))).ToArray();
//Append top-center and bottom-center vertices
gemCorners = gemCorners.Concat(new Vector3[] {
new Vector3(0, 0.7F, 0),
new Vector3(0, -0.7F, 0)
}).ToArray();
//Tilt entire gem slightly towards the viewer, so we can see the top face
gemCorners = gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationX(0.3F))).ToArray();
//Define 4 triangles, then create 6 rotations of them too
var faceCorners = new int[][] {
new int[] {12, 0, 2},
new int[] {0, 1, 2},
new int[] {1, 3, 2},
new int[] {1, 13, 3}
};
Func<int, int, int> nextStep = (i, n) => (i >= 12 ? i : (i + n * 2) % 12);
faceCorners = (from n in Enumerable.Range(0, 6)
from ints in faceCorners
select ints.Select(i => nextStep(i, n)).ToArray()).ToArray();
var gemVerticesOuterList = new List<VertexPositionNormalTexture>();
var gemVerticesInnerList = new List<VertexPositionNormalTexture>();
foreach (int[] corners in faceCorners)
{
//Inset all edges, except edges 0 and 2 when vertex0 is 12 (top center)
float edge0 = corners[0] != 12 ? 0.03F : 0;
float edge1 = 0.03F;
float edge2 = corners[0] != 12 ? 0.03F : 0;
gemVerticesOuterList.AddRange(MakeTriangle(gemCorners, corners, new float[] { 0.0F, 0.0F, 0.0F }));
gemVerticesInnerList.AddRange(MakeTriangle(gemCorners, corners, new float[] { edge0, edge1, edge2 }, 0.02F));
}
return new GemModel(device, gemVerticesOuterList, gemVerticesInnerList, new Color(48, 48, 255));
}
private static graphPoint[] getClockwisePoint2D(Vector3[] points)
{
return area.simplePolygon(points.Select(x => (Vector2)x).ToArray()) <= 0
? points.Select(x => new graphPoint(x, false)).ToArray()
: points.Select(x => new graphPoint(x, false)).Reverse().ToArray();
}
public GemModel CreateGreenGemModel()
{
var gemCorners = new Vector3[] {
//Top back vertex
new Vector3(0, 0.8F, -0.2F),
//Middle ring two back vertices
new Vector3(0.12F, 0.4F, -0.30F),
new Vector3(-0.12F, 0.4F, -0.30F),
//Bottom ring two back vertices
new Vector3(0.08F, -0.8F, -0.20F),
new Vector3(-0.08F, -0.8F, -0.20F),
};
//Now create more by rotating these 120° and 240° around the Y axis
gemCorners = gemCorners
.Concat(
gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * 2 / 3))).ToArray()
).Concat(
gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * 4 / 3))).ToArray()
).ToArray();
var faceCorners = new int[][] {
//Top face
new int[] { 0, 5, 10 },
//Upper band
new int[] { 0, 1, 2 },
new int[] { 0, 2, 6 },
new int[] { 0, 6, 5 },
new int[] { 5, 6, 7 },
new int[] { 5, 7, 11 },
new int[] { 5, 11, 10 },
new int[] { 10, 11, 12 },
new int[] { 10, 12, 1 },
new int[] { 10, 1, 0 },
//Lower band
new int[] { 1, 3, 4 },
new int[] { 1, 4, 2 },
new int[] { 2, 4, 8 },
new int[] { 2, 8, 6 },
new int[] { 6, 8, 9 },
new int[] { 6, 9, 7 },
new int[] { 7, 9, 13 },
new int[] { 7, 13, 11 },
new int[] { 11, 13, 14 },
new int[] { 11, 14, 12 },
new int[] { 12, 14, 3 },
new int[] { 12, 3, 1 },
//Bottom face
new int[] { 8, 4, 3 },
new int[] { 13, 9, 8 },
new int[] { 3, 14, 13 },
new int[] { 3, 13, 8 }
};
//Just hardcode the list of edges to inset
var insetEdges = new int[][] {
new int[] {0, 1},
new int[] {1, 2},
new int[] {2, 0},
new int[] {1, 3},
new int[] {3, 4},
new int[] {4, 2},
new int[] {0, 5},
new int[] {2, 6},
new int[] {4, 8}
};
//Copy it 3 times
var insetEdges1 = insetEdges.Select(ii => ii.Select(i => (i + 5) % 15).ToArray()).ToArray();
var insetEdges2 = insetEdges.Select(ii => ii.Select(i => (i + 10) % 15).ToArray()).ToArray();
insetEdges = insetEdges.Concat(insetEdges1).Concat(insetEdges2).ToArray();
var gemVerticesOuterList = new List<VertexPositionNormalTexture>();
var gemVerticesInnerList = new List<VertexPositionNormalTexture>();
foreach (int[] corners in faceCorners)
{
float edge0 = GreenGemInsetEdge(corners[0], corners[1], insetEdges);
float edge1 = GreenGemInsetEdge(corners[1], corners[2], insetEdges);
float edge2 = GreenGemInsetEdge(corners[2], corners[0], insetEdges);
gemVerticesOuterList.AddRange(MakeTriangle(gemCorners, corners, new float[] { 0.0F, 0.0F, 0.0F }));
gemVerticesInnerList.AddRange(MakeTriangle(gemCorners, corners, new float[] { edge0, edge1, edge2 }, 0.02F));
}
return new GemModel(device, gemVerticesOuterList, gemVerticesInnerList, Color.Green );
}
/**
* Move a block with a translation around x, y and z, and a rotation around x, y and z.
*/
public bool move(Vector3 translate, Vector3 rotate)
{
//Calculate theoretical movement
//Translation: absolute, so origin
Vector3 newOrigin = origin+translate;
//Rotation: relative, so cubes matrix.
Matrix rotX = Matrix.CreateFromAxisAngle(Vector3.UnitX, (float)(rotate.X * Math.PI / 2));
Matrix rotY = Matrix.CreateFromAxisAngle(Vector3.UnitY, (float)(rotate.Y * Math.PI / 2));
Matrix rotZ = Matrix.CreateFromAxisAngle(Vector3.UnitZ, (float)(rotate.Z * Math.PI / 2));
Matrix rotTotal = rotX * rotY * rotZ; //Total rotation
Vector3[] newCubes = new Vector3[cubes.Length];
Vector3.Transform(cubes,ref rotTotal, newCubes); //Applies rotation matrix
for (int i = 1; i < newCubes.Length; i++) //Round cubes to ints.
{
newCubes[i] = new Vector3((int)newCubes[i].X, (int)newCubes[i].Y, (int)newCubes[i].Z);
}
//Check collision: add the origin and the cubes together and use that set for collission detection.
if(checkCollision(newCubes.Select(newCube=>newCube+newOrigin).ToArray()))
{
return false;
}
//Perform movement with calculated values
this.origin = newOrigin;
this.cubes = newCubes;
return true; //Succes!
}
