/// <summary>
/// This method has to be called when using this triangle renderer
/// for a new set of vertices.
/// The vertices will be rendered using the GE context values defined
/// when creating the triangle renderer.
/// </summary>
/// <param name="v1"> first vertex of the triangle </param>
/// <param name="v2"> second vertex of the triangle </param>
/// <param name="v3"> third vertex of the triangle </param>
public virtual void setVertex(VertexState v1, VertexState v2, VertexState v3)
{
this.v1 = v1;
this.v2 = v2;
this.v3 = v3;
setVertexPositions(v1, v2, v3);
}
private void ApplyVertexState(VertexState state)
{
IModel model = TargetModel;
CHR0Node n = _chr0;
int frame = CurrentFrame;
if (TargetModel != state._targetModel)
{
_resetCamera = false;
TargetModel = state._targetModel;
}
SelectedCHR0 = state._chr0;
CurrentFrame = state._animFrame;
for (int i = 0; i < state._vertices.Count; i++)
{
state._vertices[i].WeightedPosition = state._weightedPositions[i];
}
SetSelectedVertices(state._vertices);
_vertexLoc = null;
if (TargetModel != model)
{
_resetCamera = false;
TargetModel = model;
}
SelectedCHR0 = n;
CurrentFrame = frame;
UpdateModel();
}
public virtual void readVertex(int index, VertexState v)
{
readComponent(weightComponentInfo, index, v.boneWeights);
readComponent(textureComponentInfo, index, v.t);
readComponent(colorComponentInfo, index, v.c);
readComponent(normalComponentInfo, index, v.n);
readComponent(vertexComponentInfo, index, v.p);
if (log.TraceEnabled)
{
log.trace(string.Format("Vertex {0:D}:", index));
if (weightComponentInfo.enabled)
{
log.trace(string.Format(" Weights({0:D}) {1:F}, {2:F}, {3:F}, {4:F}, {5:F}, {6:F}, {7:F}, {8:F}", weightComponentInfo.size, v.boneWeights[0], v.boneWeights[1], v.boneWeights[2], v.boneWeights[3], v.boneWeights[4], v.boneWeights[5], v.boneWeights[6], v.boneWeights[7]));
}
if (textureComponentInfo.enabled)
{
log.trace(string.Format(" Texture {0:F}, {1:F}", v.t[0], v.t[1]));
}
if (colorComponentInfo.enabled)
{
log.trace(string.Format(" Color 0x{0:X8}", PixelColor.getColor(v.c)));
}
if (normalComponentInfo.enabled)
{
log.trace(string.Format(" Normal {0:F}, {1:F}, {2:F}", v.n[0], v.n[1], v.n[2]));
}
if (vertexComponentInfo.enabled)
{
log.trace(string.Format(" Position {0:F}, {1:F}, {2:F}", v.p[0], v.p[1], v.p[2]));
}
}
}
private bool LoadVertexStateChunk()
{
var vertexState = new VertexState
{
Flags = m_chunkReader.ReadInt(),
MatrixIndex = m_chunkReader.ReadInt()
};
m_chunkReader.ReadInt(); // Skip LightMatIdx
m_chunkReader.ReadInt(); // Skip LightCfgIdx
m_chunkReader.ReadInt(); // Skip LightFlags
/*
* // There is an optional 'matrix2' element that must be skipped.
* // This means that we always must read the end-of-chunk marker and
* // LoadChunk should not read the marker
* string element = m_chunkReader.ReadWord();
* if (element != ")")
* m_chunkReader.ReadWord();
*/
m_vertexStates.Add(vertexState);
// Tell loadchunk not to read the end of the chunk
return(true);
}
protected internal virtual void drawArraysTriangleFan(int first, int count)
{
Memory mem = Memory.Instance;
CachedTextureResampled cachedTexture = CachedTexture;
TriangleRenderer triangleRenderer = new TriangleRenderer(context, cachedTexture, useVertexTexture);
VertexState tv1 = null;
VertexState tv2 = null;
VertexState tv3 = v1;
bool readTexture = context.textureFlag.Enabled && !context.clearMode;
for (int i = 0; i < count; i++)
{
readVertex(mem, first + i, tv3, readTexture);
if (tv2 != null)
{
drawTriangle(triangleRenderer, tv1, tv2, tv3, false);
VertexState v = tv2;
tv2 = tv3;
tv3 = v;
}
else if (tv1 == null)
{
tv1 = tv3;
tv3 = v2;
}
else
{
tv2 = tv3;
tv3 = v3;
}
}
}
private bool HotkeyCancelChange()
{
if (!AwaitingRedoSave)
{
return(false);
}
//Undo transformations, make sure to reset keyframes
if (VertexLoc.HasValue && _currentUndo is VertexState)
{
VertexState v = _currentUndo as VertexState;
for (int i = 0; i < v._vertices.Count; i++)
{
v._vertices[i].WeightedPosition = v._weightedPositions[i];
}
_vertexSelection.ResetActions();
CancelChangeState();
UpdateModel();
}
else if (_boneSelection.IsMoving())
{
if (_boneSelection._rotating)
{
CHR0Editor.numRotX.Value = _boneSelection._oldAngles._x;
CHR0Editor.numRotY.Value = _boneSelection._oldAngles._y;
CHR0Editor.numRotZ.Value = _boneSelection._oldAngles._z;
CHR0Editor.BoxChanged(CHR0Editor.numRotX, null);
CHR0Editor.BoxChanged(CHR0Editor.numRotY, null);
CHR0Editor.BoxChanged(CHR0Editor.numRotZ, null);
}
if (_boneSelection._translating)
{
CHR0Editor.numTransX.Value = _boneSelection._oldPosition._x;
CHR0Editor.numTransY.Value = _boneSelection._oldPosition._y;
CHR0Editor.numTransZ.Value = _boneSelection._oldPosition._z;
CHR0Editor.BoxChanged(CHR0Editor.numTransX, null);
CHR0Editor.BoxChanged(CHR0Editor.numTransY, null);
CHR0Editor.BoxChanged(CHR0Editor.numTransZ, null);
}
if (_boneSelection._scaling)
{
CHR0Editor.numScaleX.Value = _boneSelection._oldScale._x;
CHR0Editor.numScaleY.Value = _boneSelection._oldScale._y;
CHR0Editor.numScaleZ.Value = _boneSelection._oldScale._z;
CHR0Editor.BoxChanged(CHR0Editor.numScaleX, null);
CHR0Editor.BoxChanged(CHR0Editor.numScaleY, null);
CHR0Editor.BoxChanged(CHR0Editor.numScaleZ, null);
}
_boneSelection.ResetActions();
CancelChangeState();
}
ModelPanel.CurrentViewport.AllowSelection = true;
return(false);
}
public static VertexState[][] ReturnRectangularVertexStateArray(int size1, int size2)
{
VertexState[][] newArray = new VertexState[size1][];
for (int array1 = 0; array1 < size1; array1++)
{
newArray[array1] = new VertexState[size2];
}
return(newArray);
}
public virtual void exportVertex(VertexState originalV, VertexState transformedV)
{
exportObjLine(string.format(l, "v %f %f %f", transformedV.p[0], transformedV.p[1], transformedV.p[2]));
if (context.vinfo.texture != 0)
{
exportObjLine(string.format(l, "vt %f %f", transformedV.t[0], transformedV.t[1]));
}
if (exportNormal && context.vinfo.normal != 0)
{
exportObjLine(string.format(l, "vn %f %f %f", transformedV.n[0], transformedV.n[1], transformedV.n[2]));
}
}
public Vertex()
{
TerrainCost = 1;
DistanceFrom0 = Mathf.Infinity;
PreviousVertex = -1;
walkable = true;
occupied = false;
traversable = true;
state = VertexState.unpainted;
}
private void Prepare()
{
VertexWithEdges = -1;
PrevVertices = new int[VerticesCount];
PrevVertices[0] = -1;
VisitedEdges = 0;
VerticesStates = new VertexState[VerticesCount];
for (int i = 0; i < VerticesCount; i++)
{
VerticesStates[i] = VertexState.notVisited;
}
}
/// <summary>
/// Call twice; before and after changes
/// </summary>
public void VertexChange(List <Vertex3> vertices)
{
SaveState state = new VertexState
{
_chr0 = _chr0,
_animFrame = CurrentFrame,
_vertices = vertices,
_weightedPositions = vertices.Select(x => x.WeightedPosition).ToList(),
_targetModel = TargetModel
};
AddState(state);
}
protected override void InitSearch()
{
base.InitSearch();
VerticesStates = new VertexState[VerticesCount];
for (int i = 0; i < VerticesCount; i++)
{
VerticesStates[i] = VertexState.notVisited;
}
StartVertex = 0;
ActiveVerticesCount = 0;
}
private void setPositions(VertexState v1, VertexState v2, VertexState v3)
{
setPositions(v1, v2);
pixel.v3x = v3.p[0];
pixel.v3y = v3.p[1];
pixel.v3z = v3.p[2];
pixel.n3x = v3.n[0];
pixel.n3y = v3.n[1];
pixel.n3z = v3.n[2];
if (transform2D)
{
prim.p3x = pixel.v3x;
prim.p3y = pixel.v3y;
prim.p3z = pixel.v3z;
// TODO Need more investigation
// prim.pxMax = max(prim.pxMax, positionCoordinate2D(prim.p3x));
// prim.pxMin = min(prim.pxMin, positionCoordinate2D(prim.p3x));
// prim.pyMax = max(prim.pyMax, positionCoordinate2D(prim.p3y));
// prim.pyMin = min(prim.pyMin, positionCoordinate2D(prim.p3y));
// prim.pzMax = max(prim.pzMax, positionCoordinate2D(prim.p3z));
// prim.pzMin = min(prim.pzMin, positionCoordinate2D(prim.p3z));
prim.pxMax = maxInt(prim.pxMax, prim.p3x);
prim.pxMin = minInt(prim.pxMin, prim.p3x);
prim.pyMax = maxInt(prim.pyMax, prim.p3y);
prim.pyMin = minInt(prim.pyMin, prim.p3y);
prim.pzMax = maxInt(prim.pzMax, prim.p3z);
prim.pzMin = minInt(prim.pzMin, prim.p3z);
}
else
{
float[] screenCoordinates = new float[4];
getScreenCoordinates(screenCoordinates, pixel.v3x, pixel.v3y, pixel.v3z);
prim.p3x = screenCoordinates[0];
prim.p3y = screenCoordinates[1];
prim.p3z = screenCoordinates[2];
prim.p3w = screenCoordinates[3];
prim.p3wInverted = 1.0f / prim.p3w;
prim.pxMax = maxInt(prim.pxMax, prim.p3x);
prim.pxMin = minInt(prim.pxMin, prim.p3x);
prim.pyMax = maxInt(prim.pyMax, prim.p3y);
prim.pyMin = minInt(prim.pyMin, prim.p3y);
prim.pzMax = maxInt(prim.pzMax, prim.p3z);
prim.pzMin = minInt(prim.pzMin, prim.p3z);
}
}
private void setTextures(VertexState v1, VertexState v2, VertexState v3)
{
setTextures(v1, v2);
prim.t3u = v3.t[0];
prim.t3v = v3.t[1];
if (transform2D)
{
prim.tuMax = max(prim.tuMax, Round(prim.t3u));
prim.tuMin = min(prim.tuMin, Round(prim.t3u));
prim.tvMax = max(prim.tvMax, Round(prim.t3v));
prim.tvMin = min(prim.tvMin, Round(prim.t3v));
}
}
private void setTextures(VertexState v1, VertexState v2)
{
prim.t1u = v1.t[0];
prim.t1v = v1.t[1];
prim.t2u = v2.t[0];
prim.t2v = v2.t[1];
if (transform2D)
{
prim.tuMax = max(Round(prim.t1u), Round(prim.t2u));
prim.tuMin = min(Round(prim.t1u), Round(prim.t2u));
prim.tvMax = max(Round(prim.t1v), Round(prim.t2v));
prim.tvMin = min(Round(prim.t1v), Round(prim.t2v));
}
}
internal async Task ClearVertexStateAsync(GrainReference grainReference, VertexState vertexState)
{
var graphElementGrain = grainReference.AsReference <IGraphElementGrain>();
var feedOptions = new FeedOptions
{
PartitionKey = new PartitionKey(graphElementGrain.GetGraphPartition())
};
var dropCommand = $"g.V('{graphElementGrain.ToKeyString()}')";
var writeQuery = client.CreateGremlinQuery <CosmosDbVertex>(graph, dropCommand, feedOptions);
var response = await writeQuery.ExecuteNextAsync <CosmosDbVertex>();
vertexState.Persisted = false;
log.Info($"CosmosDB: Drop Vertex State: Request Charge: {response.RequestCharge}");
}
protected virtual void InitSearch()
{
if (SaveSteps)
{
Steps = new LinkedList <Step>();
UnselectVertices();
}
Cycles = new List <Path>();
PrevVertices = new Stack <int>();
VerticesStates = new VertexState[VerticesCount];
for (int i = 0; i < VerticesCount; i++)
{
VerticesStates[i] = VertexState.notVisited;
}
}
protected internal virtual void readVertex(Memory mem, int index, VertexState v, bool readTexture)
{
if (bufferVertexReader == null)
{
int addr = context.vinfo.getAddress(mem, index);
context.vinfo.readVertex(mem, addr, v, readTexture, VideoEngine.Instance.DoubleTexture2DCoords);
}
else
{
// This is used for spline and bezier curves:
// the VideoEngine is computing the vertices and is pushing them into a buffer.
bufferVertexReader.readVertex(index, v);
}
if (context.vinfo.weight != 0)
{
VideoEngine.doSkinning(context.bone_uploaded_matrix, context.vinfo, v);
}
}
public void ApplyState(Device device, Effect effect)
{
VertexState.ApplyState(device);
device.Indices = Indices;
if (RenderArmor)
{
effect.SetValue("useDiffuse", false);
effect.SetValue("useNormal", false);
effect.SetValue("useSpecular", false);
effect.SetValue("useArmor", true);
effect.SetValue("spacingArmor", Armor.IsSpacingArmor);
effect.SetValue("armorValue", (float)Armor.Value);
effect.SetValue("armorChanceToHitByProjectile", (float)Armor.ChanceToHitByProjectile);
}
else
{
BindTexture(device, effect);
effect.SetValue("useArmor", false);
}
}
internal async Task WriteVertexStateAsync(GrainReference grainReference, VertexState vertexState)
{
var graphElementGrain = grainReference.AsReference <IGraphElementGrain>();
var writeExpression = (vertexState.Persisted ?
CreateUpdateExpression(grainReference, vertexState, graphElementGrain) :
CreateInsertExpression(grainReference, vertexState, graphElementGrain))
.ToString();
var feedOptions = new FeedOptions
{
MaxItemCount = 1,
PartitionKey = new PartitionKey(graphElementGrain.GetGraphPartition())
};
var writeQuery = client.CreateGremlinQuery <CosmosDbVertex>(graph, writeExpression, feedOptions, GraphSONMode.Normal);
log.Info($"CosmosDB: Writing VertexState for grain Id '{graphElementGrain.ToKeyString()}'");
var response = await writeQuery.ExecuteNextAsync <CosmosDbVertex>();
log.Info($"CosmosDB: Writing VertexState complete: Request Charge: {response.RequestCharge}");
vertexState.Persisted = true;
}
private bool LoadIndexedTrilistChunk()
{
m_geometryVertexIndices.Clear();
LoadChildChunks();
if (m_currentDistanceLevelIndex == 0)
{
// Each indexed trilist becomes a geometry node
// We only add the vertices that are actually used in this geometry node.
// This also means that the indices must be renumbered.
int uniqueIndexCount = 0;
var indexRenumbering = new Dictionary <int, int>();
var usedVertexIndices = new List <int>();
for (int indexIndex = 0; indexIndex < m_geometryVertexIndices.Count; indexIndex++)
{
int index = m_geometryVertexIndices[indexIndex];
if (!indexRenumbering.ContainsKey(index))
{
indexRenumbering.Add(index, uniqueIndexCount); // original index, renumbered index
usedVertexIndices.Add(index);
uniqueIndexCount++;
}
}
Debug.Assert(m_geometryVertexUVs.Count <= 2);
int vertexCount = uniqueIndexCount;
var positions = new Vector3[vertexCount];
var normals = new Vector3[vertexCount];
var uv1 = m_geometryVertexUVs.Count >= 1 ? new Vector2[vertexCount] : null;
var uv2 = m_geometryVertexUVs.Count == 2 ? new Vector2[vertexCount] : null;
for (int vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++)
{
int sourceVertexIndex = usedVertexIndices[vertexIndex];
positions[vertexIndex] = m_geometryVertexPositions[sourceVertexIndex];
normals[vertexIndex] = m_geometryVertexNormals[sourceVertexIndex];
if (m_geometryVertexUVs.Count == 1)
{
uv1[vertexIndex] = new Vector2(m_geometryVertexUVs[0][sourceVertexIndex].x, 1 - m_geometryVertexUVs[0][sourceVertexIndex].y);
}
else if (m_geometryVertexUVs.Count == 2)
{
uv2[vertexIndex] = new Vector2(m_geometryVertexUVs[1][sourceVertexIndex].x, 1 - m_geometryVertexUVs[1][sourceVertexIndex].y);
}
}
var indices = new int[m_geometryVertexIndices.Count];
int triangleCount = m_geometryVertexIndices.Count / 3;
for (int triangleIndex = 0; triangleIndex < triangleCount; triangleIndex++)
{
indices[3 * triangleIndex + 0] = indexRenumbering[m_geometryVertexIndices[3 * triangleIndex + 0]];
indices[3 * triangleIndex + 1] = indexRenumbering[m_geometryVertexIndices[3 * triangleIndex + 1]];
indices[3 * triangleIndex + 2] = indexRenumbering[m_geometryVertexIndices[3 * triangleIndex + 2]];
}
PrimitiveState primitiveState = m_primitiveStates[m_currentPrimitiveStateIndex];
VertexState vertexState = m_vertexStates[primitiveState.VertexStateIndex];
var gameObject = m_gameObjects[vertexState.MatrixIndex];
var mesh = new Mesh
{
name = gameObject.name,
vertices = positions,
normals = normals,
triangles = indices,
uv = uv1,
// uv2 = uv2
};
if (gameObject.GetComponent <MeshFilter>() != null)
{
gameObject = new GameObject(gameObject.name);
AddChildToGameObject(vertexState.MatrixIndex, gameObject.transform);
}
var meshFilter = gameObject.AddComponent <MeshFilter>();
meshFilter.mesh = mesh;
var meshRenderer = gameObject.AddComponent <MeshRenderer>();
Debug.Assert(primitiveState.TextureIndexCount == 1);
meshRenderer.sharedMaterial = m_materials[primitiveState.TextureIndices[0]];
}
return(false);
}
internal async Task ReadVertexStateAsync(GrainReference grainReference, VertexState vertexState)
{
var readExpression = $"g.V('{grainReference.ToKeyString()}')";
var graphElementGrain = grainReference.AsReference <IGraphElementGrain>();
var feedOptions = new FeedOptions
{
MaxItemCount = 1,
PartitionKey = new PartitionKey(graphElementGrain.GetGraphPartition())
};
var readQuery = client.CreateGremlinQuery <CosmosDbVertex>(graph, readExpression, feedOptions, GraphSONMode.Normal);
var response = await readQuery.ExecuteNextAsync <CosmosDbVertex>();
log.Info($"CosmosDB: Read Vertex State: Request Charge: {response.RequestCharge}");
var vertex = response.FirstOrDefault();
if (vertex == null)
{
return;
}
vertexState.Persisted = true;
foreach (var edge in vertex.GetInEdges())
{
var edgeReference = grainReferenceConverter.GetGrainFromKeyString(edge.Id.ToString());
edgeReference.BindGrainReference(grainFactory);
var vertexReference = grainReferenceConverter.GetGrainFromKeyString(edge.InVertexId.ToString());
vertexReference.BindGrainReference(grainFactory);
vertexState.AddInEdge(edgeReference.AsReference <IEdge>(), vertexReference.AsReference <IVertex>());
}
foreach (var edge in vertex.GetOutEdges())
{
var edgeReference = grainReferenceConverter.GetGrainFromKeyString(edge.Id.ToString());
edgeReference.BindGrainReference(grainFactory);
var vertexReference = grainReferenceConverter.GetGrainFromKeyString(edge.InVertexId.ToString());
vertexReference.BindGrainReference(grainFactory);
vertexState.AddOutEdge(edgeReference.AsReference <IEdge>(), vertexReference.AsReference <IVertex>());
}
foreach (var property in vertex.GetVertexProperties())
{
if (property.Key[0] == '@' || property.Key == "partition")
{
continue;
}
var vertexProperty = vertexState.SetProperty(property.Key, property.Value.ToString());
try
{
foreach (var subProperty in property.GetProperties())
{
if (subProperty.Key[0] == '@')
{
continue;
}
vertexProperty.SetMeta(subProperty.Key, subProperty.Value.ToString());
}
}
// BUG: The Microsoft.Azure.Graphs library throws an exception when enumerating over empty properties. How do we check or work around this?
catch (NullReferenceException) { }
}
}
private static IVertexResult CreateInsertExpression(GrainReference grainReference, VertexState vertexState, IGraphElementGrain graphElementGrain)
{
var insertExpression = g.AddV(graphElementGrain.GetGraphLabel())
.property("id", grainReference.ToKeyString());
var partition = graphElementGrain.GetGraphPartition();
if (!string.IsNullOrEmpty(partition))
{
insertExpression = insertExpression.property("partition", partition);
}
return(insertExpression.property(vertexState));
}
private static IVertexResult CreateUpdateExpression(GrainReference grainReference, VertexState vertexState, IGraphElementGrain grainWithGraphElement)
{
return(g.V().has(grainWithGraphElement.GetGraphLabel(), "id", grainReference.ToKeyString()).property(vertexState));
}
protected internal virtual bool isSprite(VertexInfo vinfo, VertexState tv1, VertexState tv2, VertexState tv3, VertexState tv4)
{
// Sprites are only available in 2D
if (!vinfo.transform2D)
{
return(false);
}
// Sprites are not culled. Keep triangles when the back face culling is enabled.
if (!context.clearMode && context.cullFaceFlag.Enabled)
{
return(false);
}
// Sprites have no normal
if (vinfo.normal != 0)
{
return(false);
}
// Color doubling not correctly handled on sprites
if (context.textureColorDoubled)
{
return(false);
}
if (vinfo.color != 0)
{
// Color of 4 vertex must be equal
if (!Utilities.sameColor(tv1.c, tv2.c, tv3.c, tv4.c))
{
return(false);
}
}
// x1 == x2 && y1 == y3 && x4 == x3 && y4 == y2
if (tv1.p[0] == tv2.p[0] && tv1.p[1] == tv3.p[1] && tv4.p[0] == tv3.p[0] && tv4.p[1] == tv2.p[1])
{
// z1 == z2 && z1 == z3 && z1 == z4
if (tv1.p[2] == tv2.p[2] && tv1.p[2] == tv3.p[2] && tv1.p[2] == tv3.p[2])
{
if (vinfo.texture == 0)
{
return(true);
}
// u1 == u2 && v1 == v3 && u4 == u3 && v4 == v2
if (tv1.t[0] == tv2.t[0] && tv1.t[1] == tv3.t[1] && tv4.t[0] == tv3.t[0] && tv4.t[1] == tv2.t[1])
{
return(true);
}
// v1 == v2 && u1 == u3 && v4 == v3 && u4 == u2
// if (tv1.t[1] == tv2.t[1] && tv1.t[0] == tv3.t[0] && tv4.t[1] == tv3.t[1] && tv4.t[0] == tv2.t[0]) {
// return true;
// }
}
}
// y1 == y2 && x1 == x3 && y4 == y3 && x4 == x2
if (tv1.p[1] == tv2.p[1] && tv1.p[0] == tv3.p[0] && tv4.p[1] == tv3.p[1] && tv4.p[0] == tv2.p[0])
{
// z1 == z2 && z1 == z3 && z1 == z4
if (tv1.p[2] == tv2.p[2] && tv1.p[2] == tv3.p[2] && tv1.p[2] == tv3.p[2])
{
if (vinfo.texture == 0)
{
return(true);
}
// v1 == v2 && u1 == u3 && v4 == v3 && u4 == u2
if (tv1.t[1] == tv2.t[1] && tv1.t[0] == tv3.t[0] && tv4.t[1] == tv3.t[1] && tv4.t[0] == tv2.t[0])
{
return(true);
}
// u1 == u2 && v1 == v3 && u4 == u3 && v4 == v2
// if (tv1.t[0] == tv2.t[0] && tv1.t[1] == tv3.t[1] && tv4.t[0] == tv3.t[0] && tv4.t[1] == tv2.t[1]) {
// return true;
// }
}
}
return(false);
}
QuadState CheckQuadState(int index, int step, bool affect_by_all_vertex = true)
{
if (step > 1)
{
int divide_index = index;
int size = 2;
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
divide_index = i * step / 2 * m_height + j * step / 2 + index;
QuadState quad_state = CheckQuadState(divide_index, step / 2, false);
if (QuadState.EQS_Normal != quad_state)
{
return(quad_state);
}
}
}
}
//index 设定了quad左下角的起点，step确定quad的大小
int quad_vetex_count = 4;
//起点的索引
int index_x = index % m_width;
int index_y = index / m_width;
//quad 4个点的index
int[] indices =
{
index,
index + step,
(index_y + step) * m_width + index_x,
(index_y + step) * m_width + step + index_x,
};
float range = m_param.Top - m_param.Bottom;
QuadState state = QuadState.EQS_Normal;
int clip_count = 0;
for (int i = 0; i < quad_vetex_count; ++i)
{
Debug.Log("[OptimizeMeshUtil CheckQuadState] origin index : " + index.ToString() + " vertex index : " + indices[i].ToString() + " step : " + step.ToString());
VertexState vertex_state = m_list_vertex_state[indices[i]];
if (VertexState.EQS_Clip == vertex_state)
{
if (affect_by_all_vertex)
{
//判断剔除的时候要4个点都可剔除才剔除
++clip_count;
}
else
{
//判断合并的时候，有一个clip就不可合并
state = QuadState.EQS_Clip;
break;
}
}
if (VertexState.EQS_Dirty == vertex_state)
{
state = QuadState.EQS_Dirty;
break;
}
}
if (affect_by_all_vertex && quad_vetex_count == clip_count)
{
state = QuadState.EQS_Clip;
}
//Debug.Log("[OptimizeMesh-CheckQuadState Res] index : " + index.ToString() + " state : " + state.ToString());
return(state);
}
protected internal virtual void drawArraysTriangleStrips(int first, int count)
{
Memory mem = Memory.Instance;
CachedTextureResampled cachedTexture = CachedTexture;
TriangleRenderer triangleRenderer = new TriangleRenderer(context, cachedTexture, useVertexTexture);
SpriteRenderer spriteRenderer = null;
VertexState tv1 = null;
VertexState tv2 = null;
VertexState tv3 = null;
VertexState tv4 = v1;
bool readTexture = context.textureFlag.Enabled && !context.clearMode;
for (int i = 0; i < count; i++)
{
readVertex(mem, first + i, tv4, readTexture);
if (tv3 != null)
{
// Displaying a sprite (i.e. rectangular area) is faster.
// Try to merge adjacent triangles if they form a sprite.
if (isSprite(context.vinfo, tv1, tv2, tv3, tv4))
{
if (spriteRenderer == null)
{
spriteRenderer = new SpriteRenderer(context, cachedTexture, useVertexTexture);
}
drawSprite(spriteRenderer, tv1, tv4);
v5.copy(tv3);
v6.copy(tv4);
v1.copy(v5);
v2.copy(v6);
tv1 = v1;
tv2 = v2;
tv3 = null;
tv4 = v3;
}
else
{
// The Front face direction is inverted every 2 triangles in the strip.
drawTriangle(triangleRenderer, tv1, tv2, tv3, ((i - 3) & 1) != 0);
VertexState v = tv1;
tv1 = tv2;
tv2 = tv3;
tv3 = tv4;
tv4 = v;
}
}
else if (tv1 == null)
{
tv1 = tv4;
tv4 = v2;
}
else if (tv2 == null)
{
tv2 = tv4;
tv4 = v3;
}
else
{
tv3 = tv4;
tv4 = v4;
}
}
if (tv3 != null)
{
// The Front face direction is inverted every 2 triangles in the strip.
drawTriangle(triangleRenderer, tv1, tv2, tv3, (count & 1) == 0);
}
}
public virtual void setVertex(VertexState v1, VertexState v2)
{
this.v1 = v1;
this.v2 = v2;
setVertexPositions(v1, v2);
}
protected internal virtual void drawTriangle(TriangleRenderer triangleRenderer, VertexState v1, VertexState v2, VertexState v3, bool invertedFrontFace)
{
triangleRenderer.setVertex(v1, v2, v3);
if (!triangleRenderer.isCulled(invertedFrontFace))
{
render(triangleRenderer);
}
}
/// <summary>
/// Initializes a new <see cref="Vertex"/> instance with the specified position on the game
/// field.
/// </summary>
/// <param name="x">The X coordinate of the vertex on the game field.</param>
/// <param name="y">The Y coordinate of the vertex on the game field.</param>
public Vertex(double x, double y)
{
_position = new Point(x, y);
_state = VertexState.Normal;
_lineSegmentsMap = new Dictionary<Vertex, LineSegment>();
}
/// <summary>
/// Changes the current state of a vertex and possibly the states of vertices which are
/// directly connected to it and line segments which are attached to it.
/// </summary>
/// <param name="vertex">The vertex whose state should be changed.</param>
/// <param name="state">The new state of the vertex.</param>
private void ChangeVertexState(Vertex vertex, VertexState state)
{
VertexState oldState = vertex.State;
vertex.State = state;
if (state == VertexState.Dragged || state == VertexState.UnderMouse)
{
if (oldState != VertexState.Dragged && oldState != VertexState.UnderMouse)
{
// The vertex was neither under the mouse, nor was it being dragged by the
// user, but now either of those events has occurred
foreach (Vertex connectedVertex in vertex.ConnectedVertices)
{
connectedVertex.State = VertexState.ConnectedToHighlighted;
}
foreach (LineSegment lineSegment in vertex.LineSegments)
{
lineSegment.State = LineSegmentState.Highlighted;
}
}
}
else if (oldState == VertexState.Dragged || oldState == VertexState.UnderMouse)
{
// The vertex was under the mouse or was being dragged by the user, but
// that is no longer the case
foreach (Vertex connectedVertex in vertex.ConnectedVertices)
{
connectedVertex.State = VertexState.Normal;
}
foreach (LineSegment lineSegment in vertex.LineSegments)
{
lineSegment.State = (_intersections[lineSegment].Count > 0
? LineSegmentState.Intersected
: LineSegmentState.Normal);
}
}
}
protected internal virtual void drawSprite(SpriteRenderer spriteRenderer, VertexState v1, VertexState v2)
{
spriteRenderer.setVertex(v1, v2);
render(spriteRenderer);
}
/// <summary>
/// Set the vertex state.
/// </summary>
/// <param name="state">New vertex state.</param>
public void SetState(VertexState state)
{
this.State = state;
bool cache = this.VertexIsCompleted;
if (this.StdoutFile != null)
this.StdoutFile.ShouldCacheLocally = cache;
if (this.LogDirectory != null)
this.LogDirectory.ShouldCacheLocally = cache;
if (this.WorkDirectory != null)
this.WorkDirectory.ShouldCacheLocally = cache;
}
