/// <summary>
/// Define a sharded vertex type and register with CRA.
/// </summary>
/// <param name="vertexDefinition">Name of the vertex type</param>
/// <param name="creator">Lambda that describes how to instantiate the vertex, taking in an object as parameter</param>
public async Task <CRAErrorCode> DefineVertexAsync(
string vertexDefinition,
Expression <Func <IShardedVertex> > creator)
{
if (_artifactUploading)
{
using (var blobStream = await _blobStorage.GetWriteStream(vertexDefinition + "/binaries"))
{ AssemblyUtils.WriteAssembliesToStream(blobStream); }
}
// Add metadata
var newRow = VertexInfo.Create(
instanceName: "",
vertexName: vertexDefinition,
vertexDefinition: vertexDefinition,
address: "",
port: 0,
vertexCreateAction: creator,
vertexParameter: null,
isActive: true,
isSharded: false);
_vertexManager.VertexInfoProvider.InsertOrReplace(newRow).Wait();
//await _vertexManager.VertexInfoProvider.InsertOrReplace(newRow);
return(CRAErrorCode.Success);
}
public static void GenerateTriangleStripFromSpriteVertices(ref VertexInfo V0, out VertexInfo V1, out VertexInfo V2, ref VertexInfo V3)
{
var Color = V3.Color;
var TZ = V0.Texture.Z;
var PZ = V0.Position.Z;
var NZ = V0.Normal.Z;
V1 = new VertexInfo()
{
Texture = new Vector4f(V3.Texture.X, V0.Texture.Y, TZ, 0),
Position = new Vector4f(V3.Position.X, V0.Position.Y, PZ, 0),
Normal = new Vector4f(V3.Normal.X, V0.Normal.Y, NZ, 0),
};
V2 = new VertexInfo()
{
Texture = new Vector4f(V0.Texture.X, V3.Texture.Y, TZ, 0),
Position = new Vector4f(V0.Position.X, V3.Position.Y, PZ, 0),
Normal = new Vector4f(V0.Normal.X, V3.Normal.Y, NZ, 0),
};
V3.Color = V2.Color = V1.Color = V0.Color = Color;
V3.Position.Z = V2.Position.Z = V1.Position.Z = V0.Position.Z = PZ;
V3.Normal.Z = V2.Normal.Z = V1.Normal.Z = V0.Normal.Z = NZ;
V3.Texture.Z = V2.Texture.Z = V1.Texture.Z = V0.Texture.Z = NZ;
}
/// <summary>
/// Метод рисования вершины с настройками по умолчанию
/// </summary>
/// <param name="g">Контекст рисования</param>
/// <param name="vertex">Вершина</param>
private void DrawVertex(Graphics g, VertexInfo vertex)
{
// Узнаём цвет вершины и рисуем
var vertColor = verticesMarkingColors.ContainsKey(vertex) ? verticesMarkingColors[vertex] : vertexColor;
DrawVertex(g, vertex, vertColor);
}
protected internal virtual VertexInfo getVertex(VertexInfo vertexInfo)
{
lock (this)
{
return(cache.get(getKey(vertexInfo)));
}
}
public LineRectangleComponent(PPDDevice device, PPDFramework.Resource.ResourceManager resourceManager, Color4 color) : base(device)
{
this.resourceManager = resourceManager;
UpdateResource(color);
borderThickness = 1;
vertices = device.GetModule <ShaderCommon>().CreateVertex(10);
}
public override string ToString()
{
VertexInfo vinfo = new VertexInfo();
vinfo.processType(vtype);
return(string.Format("VertexArray[{0}, stride {1:D}, id {2:D}, {3}]", vinfo, stride, id, vertexBuffer));
}
VertexInfo[] InitVertexInfos()
{
var vertexInfos = new VertexInfo[vertices.Length];
for (var i = 0; i < vertices.Length; i++)
{
vertexInfos[i] = new VertexInfo(i);
}
for (var iTriangle = 0; iTriangle < triangles.Length; iTriangle += 3)
{
new Face(faceDb, triangles[iTriangle], triangles[iTriangle + 1], triangles[iTriangle + 2]);
}
foreach (var info in vertexInfos)
{
var adjFaces = faceDb.GetAdjacentFaces(info.iVertex);
foreach (var f in adjFaces)
{
info.quad += CalculateQuad(f);
}
}
return(vertexInfos);
}
public MeshBuffers(Device device, TriMesh mesh)
{
int vertexCount = mesh.VertexPositions.Count;
VertexInfo[] vertexInfos = new VertexInfo[vertexCount];
for (int i = 0; i < vertexCount; ++i)
{
vertexInfos[i] = new VertexInfo {
position = mesh.VertexPositions[i],
normal = mesh.VertexNormals[i]
};
}
this.vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, vertexInfos);
int faceCount = mesh.Faces.Count;
int[] indices = new int[faceCount * 3];
for (int i = 0; i < faceCount; ++i)
{
Tri face = mesh.Faces[i];
indices[i * 3 + 0] = face.Index0;
indices[i * 3 + 1] = face.Index1;
indices[i * 3 + 2] = face.Index2;
}
this.indexBuffer = Buffer.Create(device, BindFlags.IndexBuffer, indices);
this.indexCount = indices.Length;
}
/// <summary>
/// 求平面中所有线段的交点
/// </summary>
/// <returns>The intersect points.</returns>
/// <param name="lines">Lines.</param>
public Vector2[] FindIntersectPoints(LineSegment[] lineAry)
{
if (lineAry == null || lineAry.Length == 0)
{
return(null);
}
// 排序
Array.Sort(lineAry, new LineSegComparer());
// 拥有相同上端点的线段
Queue <VertexInfo> infoQueue = new Queue <VertexInfo> ();
for (int i = 0; i < lineAry.Length; i++)
{
VertexInfo topInfo = new VertexInfo(lineAry [i].Up, VertexType.UP);
topInfo.Line = lineAry [i];
infoQueue.Enqueue(topInfo);
_UpLinkLines.AddLinkLine(topInfo.Vertex, topInfo.Line);
VertexInfo downInfo = new VertexInfo(lineAry [i].Down, VertexType.DOWN);
infoQueue.Enqueue(downInfo);
_LowLinkLines.AddLinkLine(downInfo.Vertex, null);
}
while (infoQueue.Count != 0)
{
VertexInfo info = infoQueue.Dequeue();
HandleEventPoint(info);
}
return(null);
}
public static void GenerateTriangleStripFromSpriteVertices(ref VertexInfo v0, out VertexInfo v1,
out VertexInfo v2, ref VertexInfo v3)
{
var color = v3.Color;
var tz = v0.Texture.Z;
var pz = v0.Position.Z;
var nz = v0.Normal.Z;
v1 = new VertexInfo
{
Texture = new Vector4(v3.Texture.X, v0.Texture.Y, tz, 0),
Position = new Vector4(v3.Position.X, v0.Position.Y, pz, 0),
Normal = new Vector4(v3.Normal.X, v0.Normal.Y, nz, 0),
};
v2 = new VertexInfo
{
Texture = new Vector4(v0.Texture.X, v3.Texture.Y, tz, 0),
Position = new Vector4(v0.Position.X, v3.Position.Y, pz, 0),
Normal = new Vector4(v0.Normal.X, v3.Normal.Y, nz, 0),
};
v3.Color = v2.Color = v1.Color = v0.Color = color;
v3.Position.Z = v2.Position.Z = v1.Position.Z = v0.Position.Z = pz;
v3.Normal.Z = v2.Normal.Z = v1.Normal.Z = v0.Normal.Z = nz;
v3.Texture.Z = v2.Texture.Z = v1.Texture.Z = v0.Texture.Z = nz;
}
/// <summary>
/// Define a vertex type and register with CRA.
/// </summary>
/// <param name="vertexDefinition">Name of the vertex type</param>
/// <param name="creator">Lambda that describes how to instantiate the vertex, taking in an object as parameter</param>
public async Task <CRAErrorCode> DefineVertexAsync(string vertexDefinition, Expression <Func <IVertex> > creator)
{
if (_artifactUploading)
{
using (var stream = await _blobStorage.GetWriteStream(vertexDefinition + "/binaries"))
{
AssemblyUtils.WriteAssembliesToStream(stream);
}
}
var newInfo = VertexInfo.Create(
"",
vertexDefinition,
vertexDefinition,
"",
0,
creator,
null,
true,
false);
await _vertexManager.VertexInfoProvider.InsertOrReplace(newInfo);
return(CRAErrorCode.Success);
}
// ------
protected override void SetVertexBuffer(BxCmSeparatePatch_Object patch)
{
if (Buf.HasVertexBuffer() == true)
{
Buf.ReleaseVertexBuffer();
}
Buf.NumVertices = ( int )(patch.NumSurface * 6);
VertexInfo[] vertexAry = new VertexInfo[Buf.NumVertices];
for (uint i = 0; i < patch.NumSurface; i++)
{
GetPosDiff(patch, i, out BxBezier3Line3F hPosBez0, out BxBezier6Line3F hPosBez1, out BxBezier6Line3F hPosBez2, out BxBezier3Line3F hPosBez3, out BxBezier3Line3F vPosBez0,
out BxBezier6Line3F vPosBez1, out BxBezier6Line3F vPosBez2, out BxBezier3Line3F vPosBez3, out BxBezier2Line3F hDiffBez0, out BxBezier5Line3F hDiffBez1,
out BxBezier5Line3F hDiffBez2, out BxBezier2Line3F hDiffBez3, out BxBezier2Line3F vDiffBez0, out BxBezier5Line3F vDiffBez1, out BxBezier5Line3F vDiffBez2,
out BxBezier2Line3F vDiffBez3);
int tessDenom = GetTessDenom(patch, i);
SetVertexBufferOne(hPosBez0, hPosBez1, hPosBez2, hPosBez3, vPosBez0, vPosBez1, vPosBez2, vPosBez3, hDiffBez0, hDiffBez1, hDiffBez2, hDiffBez3, vDiffBez0, vDiffBez1,
vDiffBez2, vDiffBez3, tessDenom, i, vertexAry);
}
GL.GenBuffers(1, Buf.VboID);
GL.BindBuffer(BufferTarget.ArrayBuffer, Buf.VboID[0]);
GL.BufferData(BufferTarget.ArrayBuffer, new IntPtr(Buf.NumVertices * VertexInfo.Length), vertexAry, BufferUsageHint.StaticDraw);
GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
}
public VertexInfoTests()
{
this.graphMock = new Mock <IDirectedGraph <string, Edge <string> > >();
this.sut = new VertexInfo <string, Edge <string> >(
this.graphMock.Object,
Vertex);
}
private IntKey[] FindPlaneIntersectionForTriangle(Vector3[] points, Vector3[] normals, Vector2[] uv, Plane p, int a, int b, int c, ref Dictionary <IntKey, VertexInfo> CollisionPoints)
{
int contactCounter = 0;
var ContactPoints = new IntKey[2];
var testKeys = new IntKey[] { new IntKey(a, b), new IntKey(b, c), new IntKey(a, c) };
for (int i = 0; i < testKeys.Length; i++)
{
if (CollisionPoints.ContainsKey(testKeys[i]))
{
ContactPoints[contactCounter] = testKeys[i];
contactCounter++;
}
else
{
Vector3 contactPoint;
if (GetPointIntersection(points[testKeys[i].A], points[testKeys[i].B], p, out contactPoint))
{
CollisionPoints[testKeys[i]] = new VertexInfo(contactPoint, (normals[testKeys[i].A] + normals[testKeys[i].B]).normalized, (uv[testKeys[i].A] + uv[testKeys[i].B]) / 2);
ContactPoints[contactCounter] = testKeys[i];
contactCounter++;
}
}
}
return(ContactPoints);
}
/// <summary>
/// 4th attempt: set color by most linked, not by color
/// </summary>
/// <param name="mdt"></param>
public static void _SetVertexColorToBarycentric(MeshDataTool mdt)
{
//store info about our verticies into an array
var vertStorage = new VertexInfo[mdt.GetVertexCount()];
for (var vertIdx = 0; vertIdx < vertStorage.Length; vertIdx++)
{
vertStorage[vertIdx] = new VertexInfo(vertIdx, mdt, vertStorage);
//set vert color to alphaBlack
mdt.SetVertexColor(vertIdx, Colors.Transparent);
}
//sort verticies by degree (number of edges). defaults to highest first
var sortedVerts = new List <VertexInfo>(vertStorage);
sortedVerts.Sort();
//color channels used for verticies. 3 is ideal, but aprox 10% of verts wont be colored.
var colorChoices = new Color[] {
//encode 5 channels as 20% red each.
new Color(0.2f, 0, 0, 0),
new Color(0.4f, 0, 0, 0),
new Color(0.6f, 0, 0, 0),
new Color(0.8f, 0, 0, 0),
new Color(1f, 0, 0, 0)
};
////////////// various algorithm choices. best is _WELSH_POWELL_ADJUSTED
//_GREEDY_FACE(sortedVerts, colorChoices, mdt);
//_GREEDY_BASIC(sortedVerts, colorChoices, mdt);
//_CYBERREALITY(sortedVerts, colorChoices, mdt);
//_CYBERREALITY_EDIT(sortedVerts, colorChoices, mdt);
_WELSH_POWELL_ADJUSTED(sortedVerts, colorChoices, mdt);
}
int index; // current index in buffer
public ParticleManager(GraphicsDevice g, int max)
{
particleMax = max;
particles = new Particle[max];
for (int i = 0; i < max; i++)
{
particles[i] = new Particle();
}
vtx = new VertexInfo[max * 4];
for (int i = 0; i < max; i++)
{
vtx[i * 4 + 0] = new VertexInfo(new Vector4(-500, -500, 0, 1), new Vector2(0, 1));
vtx[i * 4 + 1] = new VertexInfo(new Vector4(-500, 500, 0, 1), new Vector2(0, 0));
vtx[i * 4 + 2] = new VertexInfo(new Vector4(500, -500, 0, 1), new Vector2(1, 1));
vtx[i * 4 + 3] = new VertexInfo(new Vector4(500, 500, 0, 1), new Vector2(1, 0));
}
vertexBuffer = new DynamicVertexBuffer(g, typeof(VertexInfo), max * 4, BufferUsage.WriteOnly);
vertexBuffer.SetData(vtx);
ushort[] idx = new ushort[max * 6];
for (ushort i = 0; i < max; i++)
{
idx[i * 6 + 0] = (ushort)(i * 4 + 0);
idx[i * 6 + 1] = (ushort)(i * 4 + 1);
idx[i * 6 + 2] = (ushort)(i * 4 + 2);
idx[i * 6 + 3] = (ushort)(i * 4 + 1);
idx[i * 6 + 4] = (ushort)(i * 4 + 3);
idx[i * 6 + 5] = (ushort)(i * 4 + 2);
}
indexBuffer = new IndexBuffer(g, typeof(ushort), idx.Length, BufferUsage.WriteOnly);
indexBuffer.SetData(idx);
}
/// <summary>
/// If the value of boneOrientationVector was changed while DualQuaternionSkinner is active (started == true), UpdatePerVertexCompensationCoef() must be called in order for the change to take effect.
/// </summary>
public void UpdatePerVertexCompensationCoef()
{
if (this.started == false)
{
return;
}
var vertInfos = new VertexInfo[this.mf.sharedMesh.vertexCount];
this.bufVertInfo.GetData(vertInfos);
for (int i = 0; i < vertInfos.Length; i++)
{
Matrix4x4 bindPose = this.bindPoses[vertInfos[i].boneIndex0].inverse;
Quaternion boneBindRotation = bindPose.ExtractRotation();
Vector3 boneDirection = boneBindRotation * this.boneOrientationVector; // ToDo figure out bone orientation
Vector3 bonePosition = bindPose.ExtractPosition();
Vector3 toBone = bonePosition - (Vector3)vertInfos[i].position;
vertInfos[i].compensation_coef = Vector3.Cross(toBone, boneDirection).magnitude;
}
this.bufVertInfo.SetData(vertInfos);
this.ApplyMorphs();
}
public Circle(PPDDevice device, PPDFramework.Resource.ResourceManager resourceManager) : base(device)
{
loadCircleImageResource = resourceManager.GetResource <ImageResourceBase>(Utility.Path.Combine("logo", "circle.png"));
loadCircleImageVertex = device.GetModule <ShaderCommon>().CreateVertex(362);
invLoadCircleImageVertex = device.GetModule <ShaderCommon>().CreateVertex(362);
var tempLoadCircleVertices = new ColoredTexturedVertex[362];
var tempInvLoadCircleVertices = new ColoredTexturedVertex[362];
for (var i = 0; i < tempLoadCircleVertices.Length; i++)
{
tempLoadCircleVertices[i] = new ColoredTexturedVertex(Vector3.Zero);
tempInvLoadCircleVertices[i] = new ColoredTexturedVertex(Vector3.Zero);
}
tempLoadCircleVertices[0].Position = new Vector3(400, 225, 0.5f);
tempLoadCircleVertices[0].TextureCoordinates = loadCircleImageResource.GetActualUV(new Vector2(0.5f));
for (int i = 1; i < tempLoadCircleVertices.Length; i++)
{
var rad = (float)((i - 1) * Math.PI / 180);
var uv = new Vector2((float)Math.Sin(rad), -(float)Math.Cos(rad));
tempLoadCircleVertices[i].Position = new Vector3(
400 + loadCircleImageResource.Width / 2 * uv.X,
225 + loadCircleImageResource.Height / 2 * uv.Y,
0.5f);
tempLoadCircleVertices[i].TextureCoordinates = loadCircleImageResource.GetActualUV((uv / 2 + new Vector2(0.5f)));
}
Array.Copy(tempLoadCircleVertices, 1, tempInvLoadCircleVertices, 0, 361);
Array.Reverse(tempInvLoadCircleVertices, 0, tempInvLoadCircleVertices.Length);
tempInvLoadCircleVertices[0] = tempLoadCircleVertices[0];
loadCircleImageVertex.Write(tempLoadCircleVertices);
invLoadCircleImageVertex.Write(tempInvLoadCircleVertices);
}
private void UpdateVertices()
{
if (vertices == null)
{
vertices = device.GetModule <ShaderCommon>().CreateVertex(4);
}
float width = MovieDisplayWidth;
float height = MovieDisplayHeight;
float textureWidth = MovieDisplayWidth;
float textureHeight = MovieDisplayHeight;
var scale = new Vector2(MovieDisplayWidth / 800, MovieDisplayHeight / 450);
var left = trimmingdata.GetLeftTrimming(MovieWidth);
var right = trimmingdata.GetRightTrimming(MovieWidth);
var top = trimmingdata.GetTopTrimming(MovieHeight);
var bottom = trimmingdata.GetBottomTrimming(MovieHeight);
var x1 = (float)(left > 0 ? left : 0) / this.width * maxu;
var y1 = (float)(top > 0 ? top : 0) / this.height * maxv;
var x2 = (1.0f - (float)(right > 0 ? right : 0) / this.width) * maxu;
var y2 = (1.0f - (float)(bottom > 0 ? bottom : 0) / this.height) * maxv;
if (Rotated)
{
y1 = 1 - y1;
y2 = 1 - y2;
}
vertices.Write(new[] {
new ColoredTexturedVertex(new Vector3((left < 0 ? -left : 0) * scale.X, (top < 0 ? -top : 0) * scale.Y, 0.5f), new Vector2(x1, y1)),
new ColoredTexturedVertex(new Vector3(width + (right < 0 ? right : 0) * scale.X, (top < 0 ? -top : 0) * scale.Y, 0.5f), new Vector2(x2, y1)),
new ColoredTexturedVertex(new Vector3((left < 0 ? -left : 0) * scale.X, height + (bottom < 0 ? bottom : 0) * scale.Y, 0.5f), new Vector2(x1, y2)),
new ColoredTexturedVertex(new Vector3(width + (right < 0 ? right : 0) * scale.X, height + (bottom < 0 ? bottom : 0) * scale.Y, 0.5f), new Vector2(x2, y2))
});
}
// Inserts the information related to a vertex
public void setVertex(int index, VertexInfo value)
{
if (this.isValidVertexIndex(index))
{
this.vertices [index] = value;
}
}
EdgeInfo _AddEdge(VertexInfo vertexa, VertexInfo vertexb)
{
string edgeString = EdgeInfo.GetEdgeString(vertexa.index, vertexb.index);
EdgeInfo edge;
if (!edges.ContainsKey(edgeString))
{
edge = new EdgeInfo();
edge.vertexAIndex = vertexa.index;
edge.vertexBIndex = vertexb.index;
edge.belongToTriangleIndex = new List <int> ();
edge.isConstraintEdge = false;
edges [edgeString] = edge;
}
else
{
edge = edges[edgeString];
}
if (vertexa.belongToEdgeIndex.Contains(edgeString) == false)
{
vertexa.belongToEdgeIndex.Add(edgeString);
}
if (vertexb.belongToEdgeIndex.Contains(edgeString) == false)
{
vertexb.belongToEdgeIndex.Add(edgeString);
}
return(edge);
}
private void DeltaManipulation(object sender, MouseEventArgs e)
{
if (Source == null)
{
return;
}
var element = (UIElement)sender;
var position = e.GetPosition(element);
if (m_currentVertexIndex != -1)
{
VertexInfo vertex = Source.Vertices[m_currentVertexIndex];
vertex.Position = ScreenPointToWorld(position).ToVector();
}
if (Keyboard.Modifiers == ModifierKeys.Shift)
{
var worldPos = ScreenPointToWorld(position).ToVector();
var closestPoints =
Source.Vertices.Select((p, i) => new { Distance = (p.Position - worldPos).LengthSquared, Index = i, Point = p.Position })
.OrderBy(arg => arg.Distance)
.ToArray();
var closest = closestPoints[0];
var secondClosest = closestPoints.First(arg => Math.Abs(arg.Index - closest.Index) == 1);
var vectorA = worldPos - closest.Point;
var vectorB = secondClosest.Point - closest.Point;
vectorA.Normalize();
vectorB.Normalize();
var dotProduct = vectorA * vectorB;
Children.Remove(m_previewLines);
m_previewLines.Points.Clear();
if ((closest.Index == 0 || closest.Index == Source.Vertices.Count - 1) && dotProduct < 0.5)
{
m_previewLines.Points.Add(worldPos.ToPoint3D());
m_previewLines.Points.Add(Source.Vertices[closest.Index].Position.ToPoint3D());
m_previewInfo.Position = worldPos;
m_previewInfo.InsertionIndex = closest.Index == 0 ? 0 : closest.Index + 1;
}
else
{
m_previewLines.Points.Add(closest.Point.ToPoint3D());
m_previewLines.Points.Add(worldPos.ToPoint3D());
m_previewLines.Points.Add(worldPos.ToPoint3D());
m_previewLines.Points.Add(secondClosest.Point.ToPoint3D());
m_previewInfo.Position = worldPos;
m_previewInfo.InsertionIndex = closest.Index > secondClosest.Index ? closest.Index : secondClosest.Index;
}
Children.Add(m_previewLines);
}
}
protected override void DisposeResource()
{
if (vertices != null)
{
vertices.Dispose();
vertices = null;
}
}
internal MxVertex()
{
Info = new VertexInfo
{
Pos = new double[3],
Proxy = new ProxyStruct(),
};
}
internal MxVertex()
{
Info = new VertexInfo
{
Pos = new double[3],
Proxy = new ProxyStruct(),
};
}
private bool visited; // Indicates if the vertex was processed by the algorithms
public PathVertexInfo(VertexInfo vertex, float distanceToVertex = 0)
{
this.vertex = vertex;
this.previousVertex = null;
//this.costFromPrevious = 0;
this.distanceToVertex = distanceToVertex;
this.visited = false;
}
private void asyncCheckVertex(VertexInfo vertex, VertexInfo vertexInfo, AsyncEntry asyncEntry)
{
if (!vertex.Equals(vertexInfo, asyncEntry.count))
{
VertexAlreadyChecked = vertexInfo;
vertex.setDirty();
asyncLoadVertex(vertexInfo, asyncEntry);
}
}
public void AddTriangleStrip(VertexInfo[] Vertices)
{
List<int> Indices = new List<int>();
foreach (var Vertex in Vertices)
{
Indices.Add(AddVertex(Vertex.Position.ToVector3()));
}
AddFace(Indices.ToArray());
}
public Vertex Instantiate(VertexInfo info)
{
var obj = Instantiate(_vertexPrefab);
var vertex = obj.GetComponent <Vertex>();
_pieceList.Vertexes.Add(info.Coord, vertex);
vertex.Initialize(info);
return(obj);
}
private void FixedUpdate()
{
for (int i = 0; i < vertexInfoList.Count; i++)
{
VertexInfo vertexInfo = vertexInfoList[i];
vertexList[i] = jointList[vertexInfo.jointIndex].localPosition - vertexInfo.difference;
}
mesh.SetVertices(vertexList);
}
/// <summary>
/// Allows the game to run logic such as updating the world,
/// checking for collisions, gathering input, and playing audio.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
///
protected void checkVerticesSilent()
{
Ray r = GetMouseRay(new Vector2(prevMState.Position.X, prevMState.Position.Y), GraphicsDevice.Viewport, effect);
r.Position = new Vector3(r.Position.X, r.Position.Z, r.Position.Y);
r.Direction = new Vector3(r.Direction.X, r.Direction.Z, r.Direction.Y);
// Vector3D x1 = new Vector3D(cameraX + offsetX, cameraY + offsetY, cameraZ + offsetZ);
//Vector3D x2 = new Vector3D(centerX + offsetX, centerY + offsetY, centerZ + offsetZ);
Vector3D x1 = new Vector3D(r.Position);
Vector3D x2 = new Vector3D(r.Position + r.Direction);
//Program.useCheckingPoint = true;
// Program.checkingPoint = new System.Numerics.Vector3(x2.X,x2.Z,x2.Y);
// Program.updateVertices();
Vector3D miniPoint = new Vector3D();
float ptDistance = float.MaxValue;
targetV = null;
targetVinfo = null;
for (int i = 0; i < Program.vertices.Count; i++)
// foreach (SoulsFormats.FLVER.Vertex v in Program.vertices)
{
SoulsFormats.FLVER.Vertex v = Program.vertices[i];
if (v.Positions[0] == null)
{
continue;
}
float dis = Vector3D.calculateDistanceFromLine(new Vector3D(v.Positions[0]), x1, x2);
if (ptDistance > dis)
{
miniPoint = new Vector3D(v.Positions[0]);
ptDistance = dis;
targetV = v;
targetVinfo = Program.verticesInfo[i];
}
}
if (Program.setVertexPos)
{
targetV.Positions[0] = new Vector3D(Program.setVertexX, Program.setVertexY, Program.setVertexZ).toNumV3();
}
Program.useCheckingPoint = true;
Program.checkingPoint = new System.Numerics.Vector3(miniPoint.X, miniPoint.Y, miniPoint.Z);
if (targetV.Normals != null && targetV.Normals.Count > 0)
{
Program.checkingPointNormal = new System.Numerics.Vector3(targetV.Normals[0].X, targetV.Normals[0].Y, targetV.Normals[0].Z);
}
else
{
Program.checkingPointNormal = new System.Numerics.Vector3(0, 0, 0);
}
Program.updateVertices();
}
public Task <MeshData> GenerateTerrainMeshNew(float[,] heightMap, int levelOfDetail)
{
int skipIncrement = (levelOfDetail == 0) ? 1 : levelOfDetail * 2;
var vertexIndicesMap = InitializeVertexIndicesMap(skipIncrement);
var meshData = new MeshData(numVertsPerLine, skipIncrement, settings.useFlatShading);
var meshVertexIndex = 0;
var outOfMeshVertexIndex = -1;
for (var y = 0; y < numVertsPerLine; ++y)
{
for (var x = 0; x < numVertsPerLine; ++x)
{
var v = new VertexInfo(x, y, skipIncrement, heightMap, vertexIndicesMap);
if (v.isSkipped)
{
continue;
}
var vertexIndex = v.VertexIndex;
var percent = new Vector2(x - 1, y - 1) / (numVertsPerLine - 3);
var vertexPosition2D = settings.TopLeft + new Vector2(percent.x, -percent.y) * settings.meshWorldSize;
if (v.isEdgeConnection)
{
var edgeConnectionVertexData = new EdgeConnectionVertexData(vertexIndex, v.VertexIndexCoordA, v.VertexIndexCoordB, v.dstPercentFromAToB);
meshData.DeclareEdgeConnectionVertex(edgeConnectionVertexData);
}
try {
meshData.AddVertex(new Vector3(vertexPosition2D.x, v.height, vertexPosition2D.y), percent, vertexIndex);
}
catch (IndexOutOfRangeException)
{
//Debug.Log(vertexIndex);
}
if (!v.shouldCreateTriangle)
{
continue;
}
int[] corners = v.Corners;
meshData.AddTriangle(corners[0], corners[3], corners[2]);
meshData.AddTriangle(corners[3], corners[0], corners[1]);
}
}
meshData.ProcessMesh();
return(Task.FromResult(meshData));
}
/// <summary>
/// Take a step at reducing the path resolver.
/// </summary>
/// <returns>Returns true if reached goal.</returns>
public bool Step()
{
if (!_calculating)
{
throw new InvalidOperationException("You must begin a SteppingResolver before stepping through it.");
}
if (_steppedCompletedParentNode != null)
{
return(true);
}
if (_open.Count > 0)
{
var u = _open.Pop();
if (u.Node == _goal)
{
_steppedCompletedParentNode = u;
return(true);
}
_closed.Add(u.Node);
_graph.GetNeighbours(u.Node, _neighbours);
var e = _neighbours.GetEnumerator();
while (e.MoveNext())
{
var n = e.Current;
if (_closed.Contains(n))
{
continue;
}
float g = u.g + _heuristic.Distance(u.Node, n) + _heuristic.Weight(n);
int i = GetInfo(_open, n);
if (i < 0)
{
var v = this.CreateInfo(n, g, _goal);
v.Next = u;
_open.Add(v);
}
else if (g < _open[i].g)
{
var v = _open[i];
v.Next = u;
v.g = g;
v.f = g + v.h;
_open.Update(i);
}
}
_neighbours.Clear();
}
return(false);
}
internal MxVertex(double x, double y, double z)
{
Info = new VertexInfo
{
Pos = new double[3],
Proxy = new ProxyStruct(),
};
Info.Pos[X] = x;
Info.Pos[Y] = y;
Info.Pos[Z] = z;
}
public void PutVertex(ref VertexInfo VertexInfo)
{
//GpuState.VertexState.ViewMatrix.Matrix
if (!GpuState->ClearingMode)
{
Vector3 Vector = VertexInfo.Position;
if (!VertexType.Transform2D)
{
Vector = Vector3.Transform(Vector, ModelMatrix);
}
PrimitiveIndices.Add(WavefrontObjWriter.AddVertex(Vector));
}
//throw new NotImplementedException();
}
public bool IsSelfIntersectWithSegment(VertexInfo vertexa, VertexInfo vertexb, Dictionary<int, VertexInfo> vertices)
{
Vector2 o1 = new Vector2(vertexa.vertex.x, vertexa.vertex.z);
Vector2 d1 = new Vector2 ((vertexb.vertex- vertexa.vertex).x, (vertexb.vertex- vertexa.vertex).z);
Vector2 o2 = new Vector2(vertices[vertexAIndex].vertex.x, vertices[vertexAIndex].vertex.z);
Vector2 d2 = new Vector2 ((vertices[vertexBIndex].vertex- vertices[vertexAIndex].vertex).x, (vertices[vertexBIndex].vertex - vertices[vertexAIndex].vertex).z);
Vector2 o = o2 - o1;
float t1 = (o.x * d2.y - o.y * d2.x) / (d1.x * d2.y - d1.y * d2.x);
float t2 = (o.x * d1.y - o.y * d1.x) / (d1.x * d2.y - d1.y * d2.x);
return (t1 >= 0 && t1 <= 1) && (t2 >= 0 && t2 <= 1);
}
VertexInfo FirstNextPointOnContour(VertexInfo vertex, List<VertexInfo> contourVertices)
{
for (int i = 0; i < contourVertices.Count; i++) {
if(vertex.index == contourVertices[i].index)
continue;
if(IsNextContourPoint(vertex, contourVertices[i], contourVertices))
return contourVertices[i];
}
return vertex;
}
EdgeInfo _AddEdge(VertexInfo vertexa, VertexInfo vertexb)
{
string edgeString = EdgeInfo.GetEdgeString (vertexa.index, vertexb.index);
EdgeInfo edge;
if (!edges.ContainsKey (edgeString)) {
edge = new EdgeInfo ();
edge.vertexAIndex = vertexa.index;
edge.vertexBIndex = vertexb.index;
edge.belongToTriangleIndex = new List<int> ();
edge.isConstraintEdge = false;
edges [edgeString] = edge;
} else {
edge = edges[edgeString];
}
if(vertexa.belongToEdgeIndex.Contains(edgeString) == false)
vertexa.belongToEdgeIndex.Add (edgeString);
if(vertexb.belongToEdgeIndex.Contains (edgeString) == false)
vertexb.belongToEdgeIndex.Add (edgeString);
return edge;
}
public override void Prim(GlobalGpuState GlobalGpuState, GpuStateStruct* GpuState, GuPrimitiveType PrimitiveType, ushort VertexCount)
{
VertexType = GpuState->VertexState.Type;
var TextureState = &GpuState->TextureMappingState.TextureState;
VertexReader.SetVertexTypeStruct(
VertexType,
(byte*)Memory.PspAddressToPointerSafe(GlobalGpuState.GetAddressRelativeToBaseOffset(GpuState->VertexAddress), 0)
);
// Set Matrices
this.ShaderProgram.Use();
PrepareStateCommon(GpuState);
if (GpuState->ClearingMode)
{
PrepareStateClear(GpuState);
}
else
{
PrepareStateDraw(GpuState);
}
PrepareStateMatrix(GpuState);
fixed (VertexInfo* VertexInfoBufferPtr = VertexInfoBuffer)
{
switch (PrimitiveType)
{
case GuPrimitiveType.Sprites:
int m = 0;
for (int n = 0; n < VertexCount; n += 2)
{
VertexInfo TopLeft, _TopRight, BottomRight, _BottomLeft;
VertexReader.ReadVertex(n + 0, &TopLeft);
VertexReader.ReadVertex(n + 1, &BottomRight);
TopLeft.Color.W = 1.0f;
BottomRight.Color.W = 1.0f;
//Console.WriteLine("--------------");
//Console.WriteLine("({0},{1}) ({2},{3})", TopLeft.Position.X, TopLeft.Position.Y, TopLeft.Texture.X, TopLeft.Texture.Y);
//Console.WriteLine("({0},{1}) ({2},{3})", BottomRight.Position.X, BottomRight.Position.Y, BottomRight.Texture.X, BottomRight.Texture.Y);
{
//if (GpuState->ClearingMode) Console.WriteLine("{0} - {1}", VertexInfoTopLeft, VertexInfoBottomRight);
var Color = BottomRight.Color;
var TZ = TopLeft.Texture.Z;
var PZ = TopLeft.Position.Z;
var NZ = TopLeft.Normal.Z;
_TopRight = new VertexInfo()
{
Texture = new Vector4f(BottomRight.Texture.X, TopLeft.Texture.Y, TZ, 0),
Position = new Vector4f(BottomRight.Position.X, TopLeft.Position.Y, PZ, 0),
Normal = new Vector4f(BottomRight.Normal.X, TopLeft.Normal.Y, NZ, 0),
};
_BottomLeft = new VertexInfo()
{
Texture = new Vector4f(TopLeft.Texture.X, BottomRight.Texture.Y, TZ, 0),
Position = new Vector4f(TopLeft.Position.X, BottomRight.Position.Y, PZ, 0),
Normal = new Vector4f(TopLeft.Normal.X, BottomRight.Normal.Y, NZ, 0),
};
_BottomLeft.Color = BottomRight.Color = _TopRight.Color = TopLeft.Color = Color;
_BottomLeft.Position.Z = BottomRight.Position.Z = _TopRight.Position.Z = TopLeft.Position.Z = PZ;
_BottomLeft.Normal.Z = BottomRight.Normal.Z = _TopRight.Normal.Z = TopLeft.Normal.Z = NZ;
_BottomLeft.Texture.Z = BottomRight.Texture.Z = _TopRight.Texture.Z = TopLeft.Texture.Z = NZ;
}
//VertexInfoBufferPtr[m++] = _TopRight;
//VertexInfoBufferPtr[m++] = BottomRight;
//VertexInfoBufferPtr[m++] = TopLeft;
//VertexInfoBufferPtr[m++] = _BottomLeft;
VertexInfoBufferPtr[m++] = _TopRight;
VertexInfoBufferPtr[m++] = TopLeft;
VertexInfoBufferPtr[m++] = BottomRight;
VertexInfoBufferPtr[m++] = _BottomLeft;
//Console.WriteLine("-----");
//Console.WriteLine("({0},{1}) ({2},{3})", _TopRight.Position.X, _TopRight.Position.Y, _TopRight.Texture.X, _TopRight.Texture.Y);
//Console.WriteLine("({0},{1}) ({2},{3})", TopLeft.Position.X, TopLeft.Position.Y, TopLeft.Texture.X, TopLeft.Texture.Y);
//Console.WriteLine("({0},{1}) ({2},{3})", BottomRight.Position.X, BottomRight.Position.Y, BottomRight.Texture.X, BottomRight.Texture.Y);
//Console.WriteLine("({0},{1}) ({2},{3})", _BottomLeft.Position.X, _BottomLeft.Position.Y, _BottomLeft.Texture.X, _BottomLeft.Texture.Y);
//VertexInfoBufferPtr[m++] = _BottomLeft;
//VertexInfoBufferPtr[m++] = BottomRight;
//VertexInfoBufferPtr[m++] = _TopRight;
//VertexInfoBufferPtr[m++] = TopLeft;
//VertexInfoBufferPtr[m++] = _BottomLeft;
//VertexInfoBufferPtr[m++] = TopLeft;
//VertexInfoBufferPtr[m++] = BottomRight;
//VertexInfoBufferPtr[m++] = _TopRight;
//VertexInfoBufferPtr[m++] = _BottomLeft;
//VertexInfoBufferPtr[m++] = TopLeft;
//VertexInfoBufferPtr[m++] = BottomRight;
//VertexInfoBufferPtr[m++] = _TopRight;
}
VertexCount = (ushort)m;
break;
default:
VertexReader.ReadVertices(0, VertexInfoBufferPtr, VertexCount);
break;
}
//if (PrimitiveType == GuPrimitiveType.LineStrip)
{
aPositionLocation.Pointer(3, GL.GL_FLOAT, false, sizeof(VertexInfo), ((byte*)VertexInfoBufferPtr) + (int)Marshal.OffsetOf(typeof(VertexInfo), "Position"));
aPositionLocation.Enable();
if (VertexType.ColorSize != 0)
{
aColorLocation.Pointer(4, GL.GL_FLOAT, false, sizeof(VertexInfo), ((byte*)VertexInfoBufferPtr) + (int)Marshal.OffsetOf(typeof(VertexInfo), "Color"));
aColorLocation.Enable();
u_has_vertex_color.SetBool(true);
}
else
{
aColorLocation.Disable();
u_has_vertex_color.SetBool(false);
}
u_transform_2d.SetBool(VertexType.Transform2D);
if (GpuState->TextureMappingState.Enabled)
{
aTexCoord.Pointer(3, GL.GL_FLOAT, false, sizeof(VertexInfo), ((byte*)VertexInfoBufferPtr) + (int)Marshal.OffsetOf(typeof(VertexInfo), "Texture"));
aTexCoord.Enable();
u_has_texture.SetBool(true);
u_texture.SetInt(0);
u_texture_effect.SetInt((int)TextureState->Effect);
}
else
{
aTexCoord.Disable();
u_has_texture.SetBool(false);
}
GL.glDrawArrays(PrimitiveTypeTranslate[(int)PrimitiveType], 0, VertexCount);
}
//TestingRender();
}
}
void FindContactPointAndNormalOnEdge(VertexInfo vertexa, VertexInfo vertexb, Plane cutPlane, out Vector3 pos, out Vector3 normal)
{
float rayDistance;
Ray aRay = new Ray (vertexa.vertex, vertexb.vertex - vertexa.vertex);
cutPlane.Raycast (aRay, out rayDistance);
pos = aRay.GetPoint (rayDistance);
float ratio = rayDistance / (vertexb.vertex - vertexa.vertex).magnitude;
normal = Vector3.Lerp (vertexa.vertex, vertexb.vertex, ratio);
}
/*EdgeInfo AddEdge(VertexInfo vertexa, VertexInfo vertexb)
{
List<int> vertexaAdjancentVertices = vertexa.belongToEdgeIndex.Select (eIndex => edges [eIndex].GetOtherPoint (vertexa.index)).ToList();
List<int> vertexbAdjancentVertices = vertexb.belongToEdgeIndex.Select (eIndex => edges [eIndex].GetOtherPoint (vertexb.index)).ToList();
List<int> commonVertex = vertexaAdjancentVertices.Intersect (vertexbAdjancentVertices).ToList ();
if (commonVertex.Count > 0) {
foreach(int vIndex in commonVertex)
{
VertexInfo[] newTriangle = new VertexInfo[3]{vertexa, vertexb, vertices[vIndex]};
AddTriangle(newTriangle);
}
return edges[EdgeInfo.GetEdgeString(vertexa.index, vertexb.index)];
} else {
return _AddEdge(vertexa, vertexb);
}
}*/
string RemoveEdge(VertexInfo vertexa, VertexInfo vertexb)
{
string edgeString = EdgeInfo.GetEdgeString(vertexa.index, vertexb.index);
if (edges.ContainsKey (edgeString)) {
EdgeInfo edge = edges[edgeString];
List<int> belongToTriangleIndex = edge.belongToTriangleIndex;
edge.belongToTriangleIndex = new List<int> ();
for(int i = 0; i < belongToTriangleIndex.Count; i++)
{
int triangle = belongToTriangleIndex[i];
RemoveTriangle(triangles[triangle]);
}
vertexa.belongToEdgeIndex.Remove (edgeString);
vertexb.belongToEdgeIndex.Remove (edgeString);
edges.Remove (edgeString);
}
return edgeString;
}
VertexInfo AddVertex(Vector3 pos, Vector3 normal)
{
VertexInfo vertex = new VertexInfo();
vertex.vertex = pos;
vertex.normal = normal;
vertex.index = VertexInfo.nextIndex++;
vertex.belongToTriangleIndex = new List<int> ();
vertex.belongToEdgeIndex = new List<string> ();
vertices.Add (vertex.index, vertex);
return vertex;
}
bool IsNextContourPoint(VertexInfo lastContourPoint, VertexInfo currentPoint, List<VertexInfo> contourPointSet)
{
for (int i = 0; i<contourPointSet.Count; i++)
{
//Debug.Log (Vector3.Dot(plane.normal, Vector3.Cross (currentPoint - lastContourPoint, input[i] - lastContourPoint)).ToString());
if(IsRightOfVector(lastContourPoint, currentPoint, contourPointSet[i]))
{
return false;
}
}
return true;
}
private VertexInfo[,] GetControlPoints(int UCount, int VCount)
{
var ControlPoints = new VertexInfo[UCount, VCount];
var VertexPtr = (byte*)GpuDisplayList.GpuProcessor.Memory.PspAddressToPointerSafe(GpuState->GetAddressRelativeToBaseOffset(GpuState->VertexAddress), 0);
var VertexReader = new VertexReader();
VertexReader.SetVertexTypeStruct(GpuState->VertexState.Type, VertexPtr);
for (int u = 0; u < UCount; u++)
{
for (int v = 0; v < VCount; v++)
{
ControlPoints[u, v] = VertexReader.ReadVertex(v * UCount + u);
//Console.WriteLine("getControlPoints({0}, {1}) : {2}", u, v, controlPoints[u, v]);
}
}
return ControlPoints;
}
public object m_Value = null; // The value of the info
#endregion Fields
#region Methods
/// <summary>
/// Compares with another vertex info of the same type
/// The comparison strategy is to declare the infos as "equal" if they're not of the same type
/// or don't have the same index.
/// The only case when these infos are not equal is when they differ by value.
/// Thus, it allows us to compare all infos of a vertex against all the infos of another vertex
/// and to know if the vertices are actually equal to each other because they have the exact same values.
/// </summary>
/// <param name="_o"></param>
/// <returns></returns>
public bool Compare( VertexInfo _Info )
{
if ( _Info.m_Type != m_Type )
return true; // Not a vertex info of the same type...
if ( _Info.m_Index != m_Index )
return true;
switch ( m_Type )
{
case VERTEX_INFO_TYPE.POSITION:
return (_Info.m_Value as Point) == (m_Value as Point);
case VERTEX_INFO_TYPE.NORMAL:
case VERTEX_INFO_TYPE.TANGENT:
case VERTEX_INFO_TYPE.BINORMAL:
return !ms_CompareTangentSpace || (_Info.m_Value as Vector) == (m_Value as Vector);
case VERTEX_INFO_TYPE.TEXCOORD3D:
return !ms_CompareUVs || (_Info.m_Value as Vector) == (m_Value as Vector);
case VERTEX_INFO_TYPE.TEXCOORD2D:
return !ms_CompareUVs || (_Info.m_Value as Vector2D) == (m_Value as Vector2D);
case VERTEX_INFO_TYPE.TEXCOORD1D:
return !ms_CompareUVs || Math.Abs( (float) _Info.m_Value - (float) m_Value ) < 1e-6f;
case VERTEX_INFO_TYPE.COLOR:
return !ms_CompareColors || _Info.m_Value.Equals( m_Value );
case VERTEX_INFO_TYPE.COLOR_HDR:
return !ms_CompareColors || (_Info.m_Value as Vector4D) == (m_Value as Vector4D);
}
return true;
}
// Approximate a curved face with recursively sub-divided triangles.
private void Make(VertexInfo v1, VertexInfo v2, VertexInfo v3)
{
var face = new Face3(v1.Index, v2.Index, v3.Index, v1.Position, v2.Position, v3.Position);
faces.Add(face);
var centroid = v1.Position;
centroid.Add(v2.Position);
centroid.Add(v3.Position);
centroid.Divide(3);
var azi = Azimuth(centroid);
var uvA = CorrectUV(v1.UV, v1.Position, azi);
var uvB = CorrectUV(v2.UV, v2.Position, azi);
var uvC = CorrectUV(v3.UV, v3.Position, azi);
var faceSet = new UVFaceSet(uvA,uvB,uvC);
var uvs = faceVertexUvs[0];
uvs.Add(faceSet);
}
TriangleInfo AddTriangle(VertexInfo[] verticesToAdd)
{
if (!IsRightOfVector (verticesToAdd [0], verticesToAdd [1], verticesToAdd [2])) {
VertexInfo tmp = verticesToAdd[2];
verticesToAdd[2] = verticesToAdd[1];
verticesToAdd[1] = tmp;
}
TriangleInfo triangle = new TriangleInfo();
triangle.vertices = new List<int> ();
triangle.edges = new List<string> ();
triangle.index = TriangleInfo.nextIndex++;
for (int i = 0; i<3; i++) {
triangle.vertices.Add(verticesToAdd[i].index);
EdgeInfo edge = _AddEdge (verticesToAdd[i], verticesToAdd[(i+1)%3]);
triangle.edges.Add(edge.GetSelfEdgeString());
edge.belongToTriangleIndex.Add (triangle.index);
}
triangles.Add (triangle.index, triangle);
return triangle;
}
bool IsLeftOfVector(VertexInfo vertexCenter, VertexInfo vertexEnd, VertexInfo vertex)
{
bool result = Vector3.Dot (Vector3.Cross (victim.TransformVector(vertexEnd.vertex - vertexCenter.vertex), victim.TransformVector(vertex.vertex - vertexCenter.vertex)), transform.forward) > epslion;
return result;
}
VertexInfo FindPrevVertex(VertexInfo vertexCenter, VertexInfo vertexEnd, bool isCW, Dictionary<string, EdgeInfo> inputEdges)
{
List<string> adjancentEdges = vertexCenter.belongToEdgeIndex.Where(s => inputEdges.ContainsKey(s)).ToList();
if(adjancentEdges.Count == 1)
return vertices[edges[adjancentEdges[0]].GetOtherPoint(vertexCenter.index)];
List<string> rightEdges = adjancentEdges.Where (e => IsRightOfVector(vertexCenter, vertexEnd, vertices[edges[e].GetOtherPoint(vertexCenter.index)])).ToList();
List<string> rightExceptEdges = adjancentEdges.Except (rightEdges).ToList ();
List<string> leftEdges = adjancentEdges.Where (e => IsLeftOfVector(vertexCenter, vertexEnd, vertices[edges[e].GetOtherPoint(vertexCenter.index)])).ToList();
List<string> leftExceptEdges = adjancentEdges.Except (leftEdges).ToList ();
string nextEdgeString;
Func<string, float> calculateDot = eString => {EdgeInfo e = edges[eString]; return Vector3.Dot((vertexEnd.vertex - vertexCenter.vertex).normalized, (vertices [e.GetOtherPoint (vertexCenter.index)].vertex - vertexCenter.vertex).normalized);};
if (isCW) {
if(rightEdges.Count>0)
{
nextEdgeString = rightEdges.OrderByDescending(calculateDot).First();
}
else
{
nextEdgeString = rightExceptEdges.OrderBy(calculateDot).First();
}
} else {
if(leftEdges.Count>0)
{
nextEdgeString = leftEdges.OrderByDescending(calculateDot).First();
}
else
{
nextEdgeString = leftExceptEdges.OrderBy(calculateDot).First();
}
}
return vertices[edges[nextEdgeString].GetOtherPoint(vertexCenter.index)];
}
internal MxVertex(MxVertex vert)
{
Info = vert.Info;
}
private static void PointMultAdd(ref VertexInfo dest, ref VertexInfo src, float f)
{
dest.Position += src.Position * f;
dest.Texture += src.Texture * f;
dest.Color += src.Color * f;
dest.Normal += src.Normal * f;
}
// Project vector onto sphere's surface
private VertexInfo Prepare(Vector3 vector, List<VertexInfo> vertexSet)
{
var p = vector.Normalized();
var i = vertexSet.Count;
var u = Azimuth(vector) / 2 / Mathf.Pi + 0.5f;
var v = Inclination(vector) / Mathf.Pi + 0.5f;
var vertex = new VertexInfo()
{
Position = p,
Index = i,
// Texture coords are equivalent to map coords, calculate angle and convert to fraction of a circle.
UV = new Vector2(u, 1 - v)
};
vertexSet.Add(vertex);
return vertex;
}
private void DrawBezier(int UCount, int VCount)
{
var DivS = GpuState->PatchState.DivS;
var DivT = GpuState->PatchState.DivT;
if ((UCount - 1) % 3 != 0 || (VCount - 1) % 3 != 0)
{
Logger.Warning("Unsupported bezier parameters ucount=" + UCount + " vcount=" + VCount);
return;
}
if (DivS <= 0 || DivT <= 0)
{
Logger.Warning("Unsupported bezier patches patch_div_s=" + DivS + " patch_div_t=" + DivT);
return;
}
//initRendering();
//boolean useTexture = context.vinfo.texture != 0 || context.textureFlag.isEnabled();
//boolean useNormal = context.lightingFlag.isEnabled();
var anchors = GetControlPoints(UCount, VCount);
// Don't capture the ram if the vertex list is embedded in the display list. TODO handle stall_addr == 0 better
// TODO may need to move inside the loop if indices are used, or find the largest index so we can calculate the size of the vertex list
/*
if (State.captureGeNextFrame && !isVertexBufferEmbedded()) {
Logger.Info("Capture drawBezier");
CaptureManager.captureRAM(context.vinfo.ptr_vertex, context.vinfo.vertexSize * ucount * vcount);
}
*/
// Generate patch VertexState.
var Patch = new VertexInfo[DivS + 1, DivT + 1];
// Number of patches in the U and V directions
int upcount = UCount / 3;
int vpcount = VCount / 3;
float[][] ucoeff = new float[DivS + 1][];
for (int j = 0; j <= DivT; j++)
{
float vglobal = (float)j * vpcount / (float)DivT;
int vpatch = (int)vglobal; // Patch number
float v = vglobal - vpatch;
if (j == DivT)
{
vpatch--;
v = 1.0f;
}
float[] vcoeff = BernsteinCoeff(v);
for (int i = 0; i <= DivS; i++)
{
float uglobal = (float)i * upcount / (float)DivS;
int upatch = (int)uglobal;
float u = uglobal - upatch;
if (i == DivS)
{
upatch--;
u = 1.0f;
}
ucoeff[i] = BernsteinCoeff(u);
var p = default(VertexInfo);
p.Position = Vector4f.Zero;
p.Normal = Vector4f.Zero;
for (int ii = 0; ii < 4; ++ii)
{
for (int jj = 0; jj < 4; ++jj)
{
/*
Console.WriteLine(
"({0}, {1}) : {2} : {3} : {4}",
ii, jj,
p.Position, anchors[3 * upatch + ii, 3 * vpatch + jj].Position,
ucoeff[i][ii] * vcoeff[jj]
);
*/
PointMultAdd(
ref p,
ref anchors[3 * upatch + ii, 3 * vpatch + jj],
ucoeff[i][ii] * vcoeff[jj]
);
}
}
p.Texture.X = uglobal;
p.Texture.Y = vglobal;
Patch[i, j] = p;
/*
Console.WriteLine(
"W: ({0}, {1}) : {2}",
i, j,
patch[i, j]
);
*/
/*
if (useTexture && context.vinfo.texture == 0)
{
p.t[0] = uglobal;
p.t[1] = vglobal;
}
*/
}
}
GpuDisplayList.GpuProcessor.GpuImpl.BeforeDraw(GpuDisplayList.GpuStateStructPointer);
GpuDisplayList.GpuProcessor.GpuImpl.DrawCurvedSurface(GlobalGpuState, GpuDisplayList.GpuStateStructPointer, Patch, UCount, VCount);
}
public void Cut()
{
//initialize public variables
vertices = new Dictionary<int, VertexInfo> ();
edges = new Dictionary<string, EdgeInfo> (StringComparer.Ordinal);
triangles = new Dictionary<int, TriangleInfo> ();
//Get Cutplane
Vector3 planeNormalInSubspace = victim.InverseTransformDirection (transform.forward);
Vector3 planePosInSubspace = victim.InverseTransformPoint (transform.position);
cutPlane = new Plane (planeNormalInSubspace, planePosInSubspace);
//Get Mesh
/*GameObject newMeshLeft = (GameObject)Instantiate (newMeshPrefab, victim.position, victim.rotation);
MeshFilter newMeshLeftFilter = newMeshLeft.GetComponent<MeshFilter> ();
List< TriangleInfo> leftTriangles = new List<TriangleInfo>();
GameObject newMeshRight = (GameObject)Instantiate (newMeshPrefab, victim.position, victim.rotation);
MeshFilter newMeshRightFilter = newMeshRight.GetComponent<MeshFilter> ();
List< TriangleInfo> rightTriangles = new List<TriangleInfo>();*/
//New Generated Points
Dictionary<string, VertexInfo> newGeneratedPoints = new Dictionary<string, VertexInfo> (StringComparer.Ordinal);
//Get Mesh Info
Mesh _mesh = _meshFilter.mesh;
int[] _triangles = _mesh.triangles;
Vector3[] _vertices = _mesh.vertices;
Vector3[] _normals = _mesh.normals;
for (int i = 0; i<_vertices.Count(); i++) {
AddVertex(_vertices [i], _normals[i]);
}
for (int i = 0; i*3<_triangles.Length; i++) {
VertexInfo[] verticesToBeAdd = new VertexInfo [3];
for (int j = 0; j < 3; j++) {
verticesToBeAdd[j] = vertices[_triangles[i*3+j]];
}
AddTriangle(verticesToBeAdd);
}
//Cut Mesh
int triangleNum = triangles.Count;
for(int i = 0; i < triangleNum; i++)
{
int inPositiveHalfSpaceNum = 0;
int aPositiveVertexIndex = 0;
int aNegativeVertexIndex = 0;
TriangleInfo triangle = triangles[i];
for(int j = 0; j < 3; j++)
{
VertexInfo avertex = vertices[triangle.vertices[j]];
float distanceToPlane = cutPlane.GetDistanceToPoint (avertex.vertex);
if(distanceToPlane > 0)
{
aPositiveVertexIndex = j;
inPositiveHalfSpaceNum++;
}
else
{
aNegativeVertexIndex = j;
}
}
if (inPositiveHalfSpaceNum==3) {
//leftTriangles.Add (triangle);
} else if (inPositiveHalfSpaceNum==2) {
List<EdgeInfo> crossEdge = new List<EdgeInfo>();
for(int k = 0; k < 2; k++)
{
string edgeString = EdgeInfo.GetEdgeString(triangle.vertices[aNegativeVertexIndex], triangle.vertices[(aNegativeVertexIndex+1+k)%3]);
EdgeInfo edge = edges[edgeString];
if(!newGeneratedPoints.ContainsKey(edgeString))
{
Vector3 breakPoint;
Vector3 normal;
FindContactPointAndNormalOnEdge(vertices[edge.vertexAIndex], vertices[edge.vertexBIndex], cutPlane, out breakPoint, out normal);
VertexInfo vertex = AddVertex(breakPoint, normal);
newGeneratedPoints[edgeString] = vertex;
}
crossEdge.Add (edge);
}
/*VertexInfo[] triangleA = new VertexInfo[3]{newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
vertices[crossEdge[0].GetOtherPoint(triangle.vertices[aNegativeVertexIndex])],
vertices[crossEdge[1].GetOtherPoint(triangle.vertices[aNegativeVertexIndex])]};
VertexInfo[] triangleB = new VertexInfo[3]{newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
vertices[crossEdge[1].GetOtherPoint(triangle.vertices[aNegativeVertexIndex])],
newGeneratedPoints[crossEdge[1].GetSelfEdgeString()]};
VertexInfo[] triangleC = new VertexInfo[3]{vertices[triangle.vertices[aNegativeVertexIndex]],
newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
newGeneratedPoints[crossEdge[1].GetSelfEdgeString()]};
leftTriangles.Add (AddTriangle(triangleA));
leftTriangles.Add (AddTriangle(triangleB));
rightTriangles.Add (AddTriangle(triangleC));*/
} else if (inPositiveHalfSpaceNum==1) {
List<EdgeInfo> crossEdge = new List<EdgeInfo>();
for(int k = 0; k < 2; k++)
{
string edgeString = EdgeInfo.GetEdgeString(triangle.vertices[aPositiveVertexIndex], triangle.vertices[(aPositiveVertexIndex+1+k)%3]);
EdgeInfo edge = edges[edgeString];
if(!newGeneratedPoints.ContainsKey(edgeString))
{
Vector3 breakPoint;
Vector3 normal;
FindContactPointAndNormalOnEdge(vertices[edge.vertexAIndex], vertices[edge.vertexBIndex], cutPlane, out breakPoint, out normal);
VertexInfo vertex = AddVertex(breakPoint, normal);
newGeneratedPoints[edgeString] = vertex;
}
crossEdge.Add (edge);
}
/*VertexInfo[] triangleA = new VertexInfo[3]{newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
vertices[crossEdge[0].GetOtherPoint(triangle.vertices[aPositiveVertexIndex])],
vertices[crossEdge[1].GetOtherPoint(triangle.vertices[aPositiveVertexIndex])]};
VertexInfo[] triangleB = new VertexInfo[3]{newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
vertices[crossEdge[1].GetOtherPoint(triangle.vertices[aPositiveVertexIndex])],
newGeneratedPoints[crossEdge[1].GetSelfEdgeString()]};
VertexInfo[] triangleC = new VertexInfo[3]{vertices[triangle.vertices[aPositiveVertexIndex]],
newGeneratedPoints[crossEdge[0].GetSelfEdgeString()],
newGeneratedPoints[crossEdge[1].GetSelfEdgeString()]};
rightTriangles.Add (AddTriangle(triangleA));
rightTriangles.Add (AddTriangle(triangleB));
leftTriangles.Add (AddTriangle(triangleC));*/
} else if (inPositiveHalfSpaceNum==0) {
//Whole triangle is culled by plane, just ignore this situation
//rightTriangles.Add (triangle);
}
}
//Cut mesh end
//Add new face
/*List<VertexInfo> newGenerateFaceContour = FindContourVertex (newGeneratedPoints.Values.ToList());
for(int i = 0; i<newGenerateFaceContour.Count; i++)
{
Debug.DrawLine(newGenerateFaceContour[i].vertex, newGenerateFaceContour[(i+1)%(newGenerateFaceContour.Count)].vertex, Color.red, 1000);
}*/
FindContourMeshDelaunay (newGeneratedPoints.Values.ToList());
/*
List<VertexInfo> newGenerateFaceLeft = new List<VertexInfo> ();
List<VertexInfo> newGenerateFaceRight = new List<VertexInfo> ();
foreach (VertexInfo avertex in newGenerateFaceContour) {
newGenerateFaceLeft.Add (AddVertex (avertex.vertex, cutPlane.normal));
newGenerateFaceRight.Add (AddVertex (avertex.vertex, -1*cutPlane.normal));
}
if (newGenerateFaceContour.Count > 2) {
for(int i = 1; i<newGenerateFaceContour.Count -1; i++)
{
VertexInfo[] triangleLeft = new VertexInfo[3]{newGenerateFaceLeft[0],
newGenerateFaceLeft[i],
newGenerateFaceLeft[i+1]};
VertexInfo[] triangleRight = new VertexInfo[3]{newGenerateFaceRight[0],
newGenerateFaceRight[i+1],
newGenerateFaceRight[i]};
leftTriangles.Add (AddTriangle(triangleLeft));
rightTriangles.Add (AddTriangle(triangleRight));
}
}
//Add new face end
//re-assemble mesh
List<Vector3> leftVertices = new List<Vector3> ();
List<Vector3> leftNormals = new List<Vector3> ();
Dictionary<int, int> verticeIndexCorrespondingDict = new Dictionary<int, int> ();
List<int> leftTriangleIndex = new List<int> ();
for (int i = 0; i < leftTriangles.Count; i++) {
TriangleInfo triangle = leftTriangles[i];
foreach(int vIndex in triangle.vertices)
{
VertexInfo vertexInfo = vertices[vIndex];
if(!verticeIndexCorrespondingDict.ContainsKey(vertexInfo.index))
{
verticeIndexCorrespondingDict.Add(vertexInfo.index, leftVertices.Count);
leftVertices.Add (vertexInfo.vertex);
leftNormals.Add (vertexInfo.normal);
}
leftTriangleIndex.Add (verticeIndexCorrespondingDict[vertexInfo.index]);
}
}
newMeshLeftFilter.mesh.vertices = leftVertices.ToArray();
newMeshLeftFilter.mesh.normals = leftNormals.ToArray ();
newMeshLeftFilter.mesh.triangles = leftTriangleIndex.ToArray();
newMeshLeftFilter.mesh.RecalculateNormals ();
newMeshLeftFilter.mesh.RecalculateBounds ();
verticeIndexCorrespondingDict.Clear ();
List<Vector3> rightVertices = new List<Vector3> ();
List<Vector3> rightNormals = new List<Vector3> ();
List<int> rightTriangleIndex = new List<int> ();
for (int i = 0; i < rightTriangles.Count; i++) {
TriangleInfo triangle = rightTriangles[i];
foreach(int vIndex in triangle.vertices)
{
VertexInfo vertexInfo = vertices[vIndex];
if(!verticeIndexCorrespondingDict.ContainsKey(vertexInfo.index))
{
verticeIndexCorrespondingDict.Add(vertexInfo.index, rightVertices.Count);
rightVertices.Add (vertexInfo.vertex);
rightNormals.Add (vertexInfo.normal);
}
rightTriangleIndex.Add (verticeIndexCorrespondingDict[vertexInfo.index]);
}
}
newMeshRightFilter.mesh.vertices = rightVertices.ToArray();
newMeshRightFilter.mesh.normals = rightNormals.ToArray ();
newMeshRightFilter.mesh.triangles = rightTriangleIndex.ToArray();
newMeshRightFilter.mesh.RecalculateNormals ();
newMeshRightFilter.mesh.RecalculateBounds ();*/
Destroy (victim.gameObject);
}
