public override void UpdateGeometry()
{
GeometryList.Clear();
GeometryList.Add(Name + "Up", new Geometry2D(Name, "StandardMenu", PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z));
GeometryList.Add(Name + "Down", new Geometry2D(Name, "StandardMenu", PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z));
float Buffer = SX * 0.1f;
float LetterGap = 0.75f;
LetterGap = Text.Length > 1 ? LetterGap : 1;
float DX = (SX - Buffer) / Text.Length;
float OY = (SY - DX) / 2.0f;
float DY = DX;
DY = DY > SY / 4.0f ? DY : SY / 4.0f;
for (int i = 0; i < Text.Length; i++)
{
int Index = Text[i] - 1;
string Bit = Text[i].ToString();
/*
* if ( Int32.TryParse(Bit, out int n))
* {
* Index = 64 + Int32.Parse(Bit);
* }
*/
GeometryList.Add(Name + i, new Geometry2D(Name + i, "StandardText", (PX + Buffer / 2) * ScreenWidth + (DX * LetterGap * i * ScreenWidth), (PY + OY) * ScreenHeight, DX * (2.0f - LetterGap) * ScreenWidth, DY * ScreenHeight, 0.0625f * (Index % 16), 0.0625f * (Index / 16), 0.0625f, 0.0625f, Z + 0.1f));
}
NeedsNodeUpdate = true;
}
public override HistoryMemento OnExecute(IHistoryWorkspace historyWorkspace)
{
if ((this.layerIndex < 1) || (this.layerIndex >= historyWorkspace.Document.Layers.Count))
{
object[] objArray1 = new object[] { "layerIndex must be greater than or equal to 1, and a valid layer index. layerIndex=", this.layerIndex, ", allowableRange=[0,", historyWorkspace.Document.Layers.Count, ")" };
throw new ArgumentException(string.Concat(objArray1));
}
int layerIndex = this.layerIndex - 1;
RectInt32 rect = historyWorkspace.Document.Bounds();
GeometryList list = new GeometryList();
list.AddRect(rect);
RectInt32[] changedRegion = list.EnumerateInteriorScans().ToArrayEx <RectInt32>();
BitmapHistoryMemento memento = new BitmapHistoryMemento(null, null, historyWorkspace, layerIndex, changedRegion);
BitmapLayer layer = (BitmapLayer)historyWorkspace.Document.Layers[this.layerIndex];
BitmapLayer layer2 = (BitmapLayer)historyWorkspace.Document.Layers[layerIndex];
RenderArgs args = new RenderArgs(layer2.Surface);
base.EnterCriticalRegion();
foreach (RectInt32 num4 in changedRegion)
{
layer.Render(args, num4.ToGdipRectangle());
}
layer2.Invalidate();
args.Dispose();
args = null;
list = null;
HistoryMemento memento2 = new DeleteLayerFunction(this.layerIndex).Execute(historyWorkspace);
return(new CompoundHistoryMemento(StaticName, StaticImage, new HistoryMemento[] { memento, memento2 }));
}
protected virtual Geometry Transform(GeometryCollection geom, Geometry parent)
{
GeometryList transGeomList = new GeometryList();
for (int i = 0; i < geom.NumGeometries; i++)
{
Geometry transformGeom = Transform(geom[i]);
if (transformGeom == null)
{
continue;
}
if (pruneEmptyGeometry && transformGeom.IsEmpty)
{
continue;
}
transGeomList.Add(transformGeom);
}
if (preserveGeometryCollectionType)
{
return(geomFactory.CreateGeometryCollection(transGeomList.ToArray()));
}
return(geomFactory.BuildGeometry(transGeomList));
}
/// <summary>
/// Validates the specified geometry or returns <c>null</c> for invalid geometries.
/// </summary>
/// <remarks>
/// The algorithm fixes the issues produced by the application of <see cref="PrecisionModel"/>.
/// </remarks>
/// <param name="geometry">The geometry.</param>
/// <returns>A valid geometry or <c>null</c>.</returns>
public static IGeometry Validate(IGeometry geometry)
{
if (geometry is IPolygon)
{
return(Validate(geometry as IPolygon));
}
else if (geometry is IGeometryCollection <IGeometry> )
{
IGeometryFactory factory = geometry.Factory;
var collection = new GeometryList <IGeometry>(factory, null);
foreach (IGeometry subGeometry in (IGeometryCollection <IGeometry>)geometry)
{
try
{
collection.Add(Validate(subGeometry));
}
catch (ArgumentNullException) { } // null value cannot be added to the collection
}
if (collection.Count == 0)
{
collection = null;
}
return(collection);
}
else
{
return(geometry.IsValid ? geometry : null);
}
}
/// <summary>
/// Perform the polygonization, if it has not already been carried out.
/// </summary>
public void Polygonize()
{
// check if already computed
if (polyList != null)
{
return;
}
//? polyList = new ArrayList();
m_arrDangles = graph.DeleteDangles();
m_arrCutEdges = graph.DeleteCutEdges();
ArrayList edgeRingList = graph.EdgeRings;
ArrayList validEdgeRingList = new ArrayList();
m_arrInvalidRingLines = new GeometryList();
FindValidRings(edgeRingList, validEdgeRingList, m_arrInvalidRingLines);
FindShellsAndHoles(validEdgeRingList);
AssignHolesToShells(holeList, shellList);
polyList = new GeometryList();
for (IEnumerator i = shellList.GetEnumerator(); i.MoveNext();)
{
EdgeRing er = (EdgeRing)i.Current;
polyList.Add(er.Polygon);
}
}
/// <summary>
/// Create a polygonizer with the same <see cref="GeometryFactory"/> as
/// the input geometries.
/// </summary>
public Polygonizer()
{
lineStringAdder = new LineStringAdder(this);
m_arrDangles = new ArrayList();
m_arrCutEdges = new ArrayList();
m_arrInvalidRingLines = new GeometryList();
}
public QuadtreeNestedRingTester(GeometryGraph graph)
{
rings = new GeometryList();
totalEnv = new Envelope();
this.graph = graph;
}
/// <summary>
/// Builds a geometry (<see cref="LineString"/> or <see cref="MultiLineString"/> )
/// representing the sequence.
///
/// </summary>
/// <param name="sequences">a List of Lists of DirectedEdges with
/// LineMergeEdges as their parent edges.
/// </param>
/// <returns> the sequenced geometry, or <code>null</code> if no sequence exists
/// </returns>
private Geometry BuildSequencedGeometry(IList sequences)
{
GeometryList lines = new GeometryList();
for (IEnumerator i1 = sequences.GetEnumerator(); i1.MoveNext();)
{
IList seq = (IList)i1.Current;
for (IEnumerator i2 = seq.GetEnumerator(); i2.MoveNext();)
{
DirectedEdge de = (DirectedEdge)i2.Current;
LineMergeEdge e = (LineMergeEdge)de.Edge;
LineString line = e.Line;
LineString lineToAdd = line;
if (!de.EdgeDirection && !line.IsClosed)
{
lineToAdd = Reverse(line);
}
lines.Add(lineToAdd);
}
}
if (lines.Count == 0)
{
return(factory.CreateMultiLineString(new LineString[0]));
}
return(factory.BuildGeometry(lines));
}
private Polygon EditPolygon(Polygon polygon, IGeometryEdit operation)
{
Polygon newPolygon = (Polygon)operation.Edit(polygon, m_objFactory);
if (newPolygon.IsEmpty)
{
//RemoveSelectedPlugIn relies on this behaviour. [Jon Aquino]
return(newPolygon);
}
LinearRing shell = (LinearRing)Edit(newPolygon.ExteriorRing, operation);
if (shell.IsEmpty)
{
//RemoveSelectedPlugIn relies on this behaviour. [Jon Aquino]
return(m_objFactory.CreatePolygon(null, null));
}
GeometryList holes = new GeometryList();
for (int i = 0; i < newPolygon.NumInteriorRings; i++)
{
LinearRing hole = (LinearRing)Edit(newPolygon.InteriorRing(i), operation);
if (hole.IsEmpty)
{
continue;
}
holes.Add(hole);
}
return(m_objFactory.CreatePolygon(shell, holes.ToLinearRingArray()));
}
/// <summary>
/// Creates a MultiLineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">
/// Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <MultiLineString Text>.
/// </param>
/// <returns>
/// A MultiLineString specified by the next token in the stream.
/// </returns>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
/// <exception cref="GeometryIOException">
/// If an unexpected token was encountered.
/// </exception>
private MultiLineString ReadMultiLineString(StreamTokenizer tokenizer)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals(WktEmpty))
{
return(m_objFactory.CreateMultiLineString(
new LineString[] {}));
}
GeometryList lineStrings = new GeometryList();
LineString lineString = ReadLineString(tokenizer);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(TokenComma))
{
lineString = ReadLineString(tokenizer);
lineStrings.Add(lineString);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(m_objFactory.CreateMultiLineString(
lineStrings.ToLineStringArray()));
}
/// <summary>
/// Creates a Polygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">
/// Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Polygon Text>.
/// </param>
/// <returns>
/// A Polygon specified by the next token in the stream.
/// </returns>
/// <exception cref="GeometryIOException">
/// If the coordinates used to create the Polygon shell and holes do
/// not form closed linestrings, or if an unexpected token was
/// encountered.
/// </exception>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
private Polygon ReadPolygon(StreamTokenizer tokenizer)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals(WktEmpty))
{
LinearRing objRing = m_objFactory.CreateLinearRing(new Coordinate[] {});
return(m_objFactory.CreatePolygon(objRing, new LinearRing[] {}));
}
GeometryList holes = new GeometryList();
LinearRing shell = ReadLinearRing(tokenizer);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(TokenComma))
{
LinearRing hole = ReadLinearRing(tokenizer);
holes.Add(hole);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(m_objFactory.CreatePolygon(shell,
holes.ToLinearRingArray()));
}
private static bool AreTheSameGeometry(GeometryList geometry1, PointDouble[] polygon2)
{
if (geometry1.PolygonCount != 1)
{
return(false);
}
if (geometry1.TotalPointCount != polygon2.Length)
{
return(false);
}
RectDouble num = polygon2.Bounds();
if (geometry1.Bounds != num)
{
return(false);
}
IList <PointDouble[]> polygonList = geometry1.GetPolygonList();
if (polygonList.Count != 1)
{
throw new InternalErrorException();
}
PointDouble[] numArray = polygonList[0];
for (int i = 0; i < numArray.Length; i++)
{
if (numArray[i] != polygon2[i])
{
return(false);
}
}
return(true);
}
public void SetMapSize()
{
Layer TopLayer = GetTopLayer();
if (TopLayer != null)
{
for (int i = 0; i < GeometryList.Count(); i++)
{
if (!(GeometryList.ElementAt(i).Key == (Name + "Selector")))
{
GeometryList.ElementAt(i).Value.TX = 1.0f / Scale * AX;
GeometryList.ElementAt(i).Value.TY = 1.0f / Scale * AY;
GeometryList.ElementAt(i).Value.TSX = 1.0f / Scale;
GeometryList.ElementAt(i).Value.TSY = 1.0f / Scale;
//GeometryList.ElementAt(i).Value.TX = (float)1.0 / TopLayer.TileSizeX / Scale * AX;
}
else
{
}
//GeometryList.ElementAt(i).Value.PX = 0;
//GeometryList.ElementAt(i).Value.PY = 0;
//GeometryList.ElementAt(i).Value.SX = SX * ScreenWidth * Scale;
//GeometryList.ElementAt(i).Value.SY = SY * ScreenHeight * Scale;
//GeometryList.ElementAt(i).Value.TX = AX * TX / Scale;
//GeometryList.ElementAt(i).Value.TY = AY * TY / Scale;
}
}
}
/// <summary>
/// Creates a MultiPolygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">
/// Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <MultiPolygon Text>.
/// </param>
/// <returns>
/// A MultiPolygon specified by the next token in the stream, or if
/// the coordinates used to create the Polygon shells and holes do
/// not form closed linestrings.
/// </returns>
/// <exception cref=IOException"">
/// If an I/O error occurs.
/// </exception>
/// <exception cref="GeometryIOException">
/// if an unexpected token was encountered.
/// </exception>
private MultiPolygon ReadMultiPolygon(StreamTokenizer tokenizer)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals(WktEmpty))
{
return(m_objFactory.CreateMultiPolygon(new Polygon[] {}));
}
GeometryList polygons = new GeometryList();
Polygon polygon = ReadPolygon(tokenizer);
polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(TokenComma))
{
polygon = ReadPolygon(tokenizer);
polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(m_objFactory.CreateMultiPolygon(
polygons.ToPolygonArray()));
}
public void ToggleLayer(string LayerName)
{
if (GeometryList.ContainsKey(LayerName))
{
GeometryList[LayerName].HasCull = !GeometryList[LayerName].HasCull;
}
}
/// <summary>
/// Replace the geometries in the scene with the ones contained in the given Assimp scene.
/// </summary>
/// <param name="scene"></param>
public void ReplaceGeometries(Assimp.Scene scene)
{
var skinToBoneMatrices = ComputeSkinToBoneMatrices(scene);
GeometryList.Clear();
Atomics.Clear();
for (var i = 0; i < scene.Meshes.Count; i++)
{
var assimpMesh = scene.Meshes[i];
var rootNode = FindMeshRootNode(scene.RootNode, i) ?? scene.RootNode;
TransformMeshVertices(assimpMesh, rootNode);
var geometryNode = new RwGeometryNode(this, assimpMesh, scene.Materials[assimpMesh.MaterialIndex], FrameList, skinToBoneMatrices, out bool singleWeight);
GeometryList.Add(geometryNode);
var atomicNode = new RwAtomicNode(this, 0, i, 5);
if (singleWeight)
{
if (assimpMesh.Bones.Count != 0)
{
atomicNode.FrameIndex = FrameList.GetFrameIndexByName(assimpMesh.Bones[0].Name);
}
else if (rootNode != null)
{
atomicNode.FrameIndex = FrameList.GetFrameIndexByName(rootNode.Name);
}
}
Atomics.Add(atomicNode);
}
mStructNode = new RwClumpStructNode(this);
}
public override void UpdateGeometry()
{
GeometryList.Clear();
GeometryList.Add(Name + "Background", new Geometry2D(Name + "StandardMenu", "StandardMenu", PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z));
if (Lines.Count > 0)
{
float LetterGap = 0.5f;
float DY = SY / MaxLineCount;
float DX = DY;
for (int i = CurrentIndex; i < CurrentIndex + MaxLineCount && i < Lines.Count; i++)
{
string Line = Lines[i];
float AllowedLength = SX / (DX * LetterGap);
for (int j = 0; j < AllowedLength && j < Line.Length; j++)
{
//get text texcoord
int Index = Line[j] - 1;
GeometryList.Add(Name + i + "-" + j, new Geometry2D(Name + i + "-" + j, "StandardText", (PX + DX * LetterGap * j) * ScreenWidth, (PY + DY * i) * ScreenHeight, DX * ScreenWidth, DY * ScreenHeight, 0.0625f * (Index % 16), 0.0625f * (Index / 16), 0.0625f, 0.0625f, Z + 0.1f));
//GeometryList.Add(Name + i, new Geometry2D(Name + i, "StandardText", (PX + DX * j + Buffer / 2) * ScreenWidth + (DX * i * ScreenWidth), (PY + OY) * ScreenHeight, DX * (2.0f - LetterGap) * ScreenWidth, DY * ScreenHeight, 0.0625f * (Index % 16), 0.0625f * (Index / 16), 0.0625f, 0.0625f, Z + 0.1f));
}
}
GeometryList.Add(Name + "HighLight", new Geometry2D(Name + "HighLight", "StandardMenu", PX * ScreenWidth, (PY + (SY / MaxLineCount * CurrentLocalIndex)) * ScreenHeight, SX * ScreenWidth, SY / MaxLineCount * ScreenHeight, 0.75f, 0, 0.1875f, 0.0625f, Z));
}
NeedsNodeUpdate = true;
}
public Geometry2D GetGeometry(string Name)
{
if (GeometryList.ContainsKey(Name))
{
return(GeometryList[Name]);
}
return(null);
}
public override void GenerateGeometry()
{
if (GeometryList.Count > 0)
{
GeometryList.Clear();
}
GeometryList.Add(Name, new Geometry2D(Name, TextureName, PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, 0, 0, 1.0f, 1.0f, Z));
}
public override void GenerateGeometry()
{
if (GeometryList.Count > 0)
{
GeometryList.Clear();
}
UpdateGeometry();
}
public virtual void ToggleVisibility(bool IsVisible)
{
IsActive = IsVisible;
for (int i = 0; i < GeometryList.Count; i++)
{
GeometryList.ElementAt(i).Value.HasCull = !IsVisible;
}
}
public virtual void GenerateGeometry()
{
if (GeometryList.Count > 0)
{
GeometryList.Clear();
}
GeometryList.Add(Name, new Geometry2D(Name, TextureName, PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z));
}
public void AddLayer(string LayerName, string LayerTexture)
{
//geometry
if (GeometryList.ContainsKey(LayerName))
{
GeometryList.Remove(LayerName);
}
GeometryList.Add(LayerName, new Geometry2D(LayerName, LayerTexture, PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z));
}
private static Surface CreateThumbnail(MaskedSurface maskedSurface)
{
int thumbSideLength = UIUtil.ScaleWidth(120);
Surface surfaceReadOnly = maskedSurface.SurfaceReadOnly;
GeometryList geometryMaskCopy = maskedSurface.GetGeometryMaskCopy();
RectInt32 maskBounds = maskedSurface.GeometryMaskBounds.Int32Bound;
return(CreateThumbnail(surfaceReadOnly, geometryMaskCopy, maskBounds, thumbSideLength));
}
/// <summary>
/// Adds a hole to the polygon formed by this ring.
/// </summary>
/// <param name="hole">the {@link LinearRing} forming the hole.
/// </param>
public void AddHole(LinearRing hole)
{
if (holes == null)
{
holes = new GeometryList();
}
holes.Add(hole);
}
public override void Init(string[] Data, int Width, int Height, Dictionary <string, Effect> Shaders)
{
base.Init(Data, Width, Height, Shaders);
PickerTexture = Data[11];
ScreenWidth = Width;
ScreenHeight = Height;
GeometryList.Add(Name + "Selector", new Geometry2D(Name, "StandardMenu", PX * ScreenWidth, PY * ScreenHeight, 0, 0, TX, TY, TSX, TSY, Z + 0.25f));
}
public LineBuilder(OverlayOp op, GeometryFactory geometryFactory,
PointLocator ptLocator)
{
lineEdgesList = new ArrayList();
resultLineList = new GeometryList();
this.op = op;
this.geometryFactory = geometryFactory;
this.ptLocator = ptLocator;
}
private static BitVector2D PixelatedGeometryListToBitVector2D(GeometryList geometry, int width, int height, CancellationToken cancellationToken)
{
BitVector2D vectord = new BitVector2D(width, height);
foreach (RectInt32 num in geometry.EnumerateInteriorScans())
{
cancellationToken.ThrowIfCancellationRequested();
vectord.Set(num, true);
}
return(vectord);
}
public void AddLayer(string LayerName, string LayerTexture, int TileX, int TileY, float TileZ, int TileSizeX, int TileSizeY, int PixelScale)
{
//geometry
if (GeometryList.ContainsKey(LayerName))
{
GeometryList.Remove(LayerName);
}
GeometryList.Add(LayerName, new Geometry2D(LayerName, LayerTexture, PX * ScreenWidth, PY * ScreenHeight, SX * ScreenWidth, SY * ScreenHeight, TX, TY, TSX, TSY, Z + TileZ));
Layers.Add(new Layer(TileX, TileY, TileZ, TileSizeX, TileSizeY, LayerName, PixelScale));
Layers = Layers.OrderBy(x => x.TileZ).ToList();
}
public void RemoveLayer(string LayerName)
{
for (int i = 0; i < Layers.Count; i++)
{
if (Layers[i].Name == LayerName)
{
Layers.RemoveAt(i);
break;
}
}
GeometryList.Remove(LayerName);
}
public override Value Evaluate(FSharpList<Value> args)
{
GeometryList geometry = new GeometryList();
System.String file_name = ((Value.String)args[0]).Item;
var input = (args[1] as Value.List).Item;
foreach (Value v in input)
{
Geometry g = ((Value.Container)v).Item as Geometry;
geometry.Add(g);
}
ASMExporter.export_geometry(file_name, geometry);
return args[1];
}
