void DebugVertices(StreamWriter s, Render.VertexBufferInterface.VertexBuffersGen3 gr, bool denormalize)
{
int index = 0;
foreach (s_tag_d3d_vertex_buffer_reference vbr in VertexBuffers)
{
var vb = vbr.Reference.Value;
if (vb == null)
{
s.WriteLine("VertexBuffer\t{0}\tNull", index.ToString("X8"));
s.WriteLine(); s.WriteLine();
index++;
continue; // wtf??
}
else s.WriteLine("VertexBuffer\t{0}", index.ToString("X8"));
var def = gr.DefinitionFind((short)vb.VertxType.Value) as Render.VertexBufferInterface.VertexBuffersGen3.Definition;
s.WriteLine("\tSize\t{0}\tCount\t{1}\tType\t{2}",
vb.VertexSize.Value.ToString("X4"), vb.VertexCount.Value.ToString("X8"), vb.VertxType.Value.ToString("X2"));
s.WriteLine("\tDefinition Size\t{0}", def.Size.ToString("X4"));
s.WriteLine();
//DebugVerticesOld(s, gr, denormalize, def, vb); // from before StreamReader was written!
DebugVertices(s, gr, denormalize, def, vb);
index++;
}
}
public Fade(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderFade;
Ox.OnEvent += new OxLoader.OxEventHandler(Ox_OnEvent);
}
public override void DrawRegionRepresentation(System.Drawing.Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
{
if (m_Param.Path.IsVisible((System.Drawing.Point)mousePosition))
{
gc.DrawString(ToString(), r.FontType, new System.Drawing.SolidBrush(r.RegionGuides.Color), new System.Drawing.PointF((float)mousePosition.X, (float)mousePosition.Y - 15));
}
}
void DebugVertices(StreamWriter s, Render.VertexBufferInterface.VertexBuffersGen3 gr, bool denormalize,
Render.VertexBufferInterface.VertexBuffersGen3.Definition def,
s_tag_d3d_vertex_buffer vb)
{
var stream_r = new Render.VertexBufferInterface.StreamReader(def);
using (var er = new IO.EndianReader(vb.VertexBuffer.Value, IO.EndianState.Big, this))
{
for (int x = 0; x < vb.VertexCount.Value; x++) // foreach vertex...
{
s.WriteLine("\tVertex\t{0}", x.ToString("X8"));
{
stream_r.Read(er);
if (denormalize)
{
foreach (string str in stream_r.GetDenormalizedStrings())
s.WriteLine("\t\t{0}", str);
}
else
foreach (string str in stream_r.GetNormalizedStrings())
s.WriteLine("\t\t{0}", str);
}
s.WriteLine();
}
s.WriteLine(); s.WriteLine();
}
}
void DebugVerticesOld(StreamWriter s, Render.VertexBufferInterface.VertexBuffersGen3 gr, bool denormalize,
Render.VertexBufferInterface.VertexBuffersGen3.Definition def,
s_tag_d3d_vertex_buffer vb)
{
LowLevel.Math.real_quaternion quat;
var elements = new Render.DeclarationTypes.IDeclType[def.Elements.Length];
for (int x = 0; x < elements.Length; x++)
elements[x] = def.Elements[x].DeclarationType.AllocateDeclType();
using (var er = new IO.EndianReader(vb.VertexBuffer.Value, IO.EndianState.Big, this))
{
for (int x = 0; x < vb.VertexCount.Value; x++) // foreach vertex...
{
s.WriteLine("\tVertex\t{0}", x.ToString("X8"));
foreach (Render.DeclarationTypes.IDeclType dt in elements) // and foreach type in the vertex...
{
dt.Read(er); // load the type data
if (denormalize)
{
dt.Denormalize(out quat);
s.WriteLine("\t\t{0}", dt.ToString(quat));
}
else s.WriteLine("\t\t{0}", dt.ToString());
s.Flush();
}
s.WriteLine();
}
s.WriteLine(); s.WriteLine();
}
}
// EditMode() should be used in conjuction with Draw()
public static RenderParameter EditMode(Render.RenderHint subState )
{
if (subState == Render.RenderHint.Start)
return DrawMode();
else
return DetailedMode();
}
public TitlePhotoAlbum(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.Render + 1;
Ox.OnEvent += new OxLoader.OxEventHandler(Ox_OnEvent);
}
public Sea(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderSea;
dir = Path.Combine(Path.Combine(Ox.Paths.Application, "media"), "sea");
}
public override void DrawRegionRepresentation(Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
{
if (m_Param.Path.PointCount > 0)
{
GraphicsPath fill = new GraphicsPath();
RectangleF rect = m_Param.Path.GetBounds();
PointD refPt = (PointD)rect.Location + ((PointD)rect.Size.ToPointF()) / 2;
// this will draw beyond the shape's location
for (double i = -rect.Height; i < rect.Height; i++)
{
PointD pt1 = refPt + PointD.Orthogonal(m_Param.V) * i * drawMethods.Spacing(m_Param.C);
PointD pt2 = pt1 + m_Param.V * rect.Width * rect.Height;
PointD pt3 = pt1 - m_Param.V * rect.Width * rect.Height;
fill.StartFigure();
fill.AddLine((Point)pt2, (Point)pt3);
}
GraphicsContainer c = gc.BeginContainer();
gc.SetClip((Tools.Model.VectorPath)m_Param.Path);
gc.DrawPath(r.RegionGuides, fill);
gc.EndContainer(c);
}
}
public Terrain(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderTerrain;
dir = Path.Combine(Path.Combine(Ox.Paths.Application, "media"), "terrain");
}
public TilePicker(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderPick;
Ox.OnEvent += new OxEventHandler(Ox_OnEvent);
dir = Path.Combine(Path.Combine(Ox.Paths.Application, "media"), "picker");
}
public Avatar(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderAvatar;
Ox.OnEvent += new OxEventHandler(ox_OnEvent);
dir = Path.Combine(Path.Combine(Ox.Paths.Application, "media"), "model_default");
}
public Prim(Ox ox, Render render)
: base(ox, render)
{
Priority = (int)PriorityBase.RenderPrim;
ox.OnEvent += new OxEventHandler(ox_OnEvent);
dir = Path.Combine(Path.Combine(Ox.Paths.Application, "media"), "test");
}
public override void Draw(System.Drawing.Graphics gc, Render.RenderParameter r, Render.RenderHint editState, Render.IDrawVisitor drawMethods, PointD mousePosition)
{
if (m_Param.Path != null)
{
/*if (editState.GetAttributes() == States.StateAttributes.Start)
{
if (r.StrokeFill != null)
gc.FillPath(r.StrokeFill, (Tools.Model.VectorPath) m_Param.Path);
gc.DrawPath(r.StrokeOutline, (Tools.Model.VectorPath)m_Param.Path);
}
else*/ if (editState == Render.RenderHint.Start)
{
Pen dashPen = (Pen)r.StrokeOutline.Clone();
dashPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
if (m_Param.Path.PointCount > 0)
{
PointD firstPoint = (PointD)m_Param.Path.GetFirstPoint();
gc.DrawEllipse(dashPen, (float)firstPoint.X - Tools.Render.DrawHelper.TARGET_SIZE / 2.0f, (float)firstPoint.Y - Tools.Render.DrawHelper.TARGET_SIZE / 2.0f, (float)Tools.Render.DrawHelper.TARGET_SIZE, (float)Tools.Render.DrawHelper.TARGET_SIZE);
if (r.StrokeFill != null)
gc.FillPath(r.StrokeFill, (Tools.Model.VectorPath)m_Param.Path);
gc.DrawPath(r.StrokeOutline, (Tools.Model.VectorPath)m_Param.Path);
DrawRegionRepresentation(gc, r, drawMethods, mousePosition);
}
}
/*else if (editState.GetAttributes() == States.StateAttributes.Change)
{
drawMethods.DrawNegativeSpace(gc, m_Param, r);
drawMethods.DrawPositiveSpace(gc, m_Param, r);
if (editState is States.RegionChange)
{
DrawRegionRepresentation(gc, r, mousePosition);
((States.RegionChange)editState).Handles.DrawHandles(gc, m_Param, r);
}
}*/
else if (editState == Render.RenderHint.Feedback)
{
drawMethods.DrawNegativeSpace(gc, m_Param.Path.InternalPath, r);
drawMethods.DrawPositiveSpace(gc, m_Param.Path.InternalPath, r);
if (!(this is ConveyorBeltFilter))
DrawRegionRepresentation(gc, r,drawMethods, mousePosition);
}
else
{
drawMethods.DrawNegativeSpace(gc, m_Param.Path.InternalPath, r);
drawMethods.DrawPositiveSpace(gc, m_Param.Path.InternalPath, r);
DrawRegionRepresentation(gc, r, drawMethods, mousePosition);
// TODO ((States.IFilterHandles)editState).Handles.DrawHandles(gc, m_Param, r);
}
drawMethods.DrawHandles(gc, this, r);
}
}
internal void WriteUvW(Render.DeclarationTypes.IDeclType decl)
{
if (decl != null)
{
LowLevel.Math.real_quaternion v;
decl.Denormalize(out v);
WriteUvW(v);
}
}
protected override Brush GetBrush(Render.RenderParameter r)
{
//Image texture = new Bitmap(Properties.Resources.ice);
//Graphics textureContext = Graphics.FromImage(texture);
//textureContext.FillRectangle(new SolidBrush(Color.FromArgb(192, Color.White)), textureContext.VisibleClipBounds);
//textureContext.Dispose();
//TextureBrush brush = new TextureBrush(texture);
//return brush;
return Brushes.Transparent;
}
private Pendulum(Particle point_a_, Particle point_b_, Vector3f equilibrium_position_, Render callback_, params IConstraint[] constraints_)
{
point_a = point_a_;
point_b = point_b_;
callback = callback_;
equilibrium_position = equilibrium_position_;
constraints = new IConstraint[constraints_.Length];
for(int i = 0; i < constraints_.Length; ++i)
{
constraints[i] = constraints_[i];
}
}
public override void DrawArrowForces(System.Drawing.Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods)
{
if (m_visibleThickPath != null)
{
GraphicsState o = gc.Save();
gc.SetClip(m_visibleThickPath);
if ((m_traceLines != null) && (m_traceLines.Length > 0) && (m_traceLines[0].Count > 1))
{
for (int k = 0; k < m_traceLines.Length; k++)
{
gc.DrawLines(r.RegionGuides, m_traceLines[k].ToArray());
}
}
gc.Restore(o);
}
}
public override void DoOnPaint(Render.Graphics.IGraphics e)
{
if (this.renderTarget.Size.Height != this.Size.Height || this.renderTarget.Size.Width != this.Size.Width)
this.renderTarget.Resize(this.Size);
this.renderTarget.BeginDraw();
try
{
this.renderTarget.Clear(new Color4(this.BackColor));
e.DrawImage(this.BackgroundImage, this.DisplayRectangle);
base.DoOnPaint(this.e);
}
finally
{
this.renderTarget.EndDraw();
}
}
public override bool Draw(Render.MyRenderObject renderObject = null)
{
if (base.Draw(renderObject))
{
// Draw muzzle flash
int deltaTime = MyMinerGame.TotalGamePlayTimeInMilliseconds - m_lastTimeShoot;
if (deltaTime <= MyMachineGunConstants.MUZZLE_FLASH_MACHINE_GUN_LIFESPAN)
{
MyParticleEffects.GenerateMuzzleFlash(GetMuzzlePosition(), WorldMatrix.Forward, MyMwcUtils.GetRandomFloat(0.8f, 1.2f), MyMwcUtils.GetRandomFloat(1, 2), MyRender.GetCurrentLodDrawPass() == MyLodTypeEnum.LOD_NEAR);
}
return true;
}
return false;
}
public static void RenderText(
String text, float X, float Y, float wrapAt, float scale, Render.RenderContext context, BitmapFont font, float depth = 0)
{
//wrapAt /= scale;
context.Texture = font.fontData;
var x = X;
var y = Y;
var kx = (font.glyphWidth - font.kerningWidth) / 2;
int col = (int)font.fontData.Width / (int)font.glyphWidth;
for (var i = 0; i < text.Length; ++i)
{
if (x >= wrapAt)
{
y += font.glyphHeight * scale;
x = X;
}
var code = text[i];
if (code == '\n')
{
x = X;
y += font.glyphHeight * scale;
}
else if (code == ' ')
{
x += font.kerningWidth * scale;
}
else if (code < 0x80)
{
var fx = (code % col) * font.fgWidth;
var fy = (code / col) * font.fgHeight;
context.ImmediateMode.Glyph(x, y, font.glyphWidth * scale, font.glyphHeight * scale,
fx,
fy,
font.fgWidth,
font.fgHeight,
depth);
x += font.kerningWidth * scale;
}
}
}
public override void Draw(Render.RenderContext Context)
{
Context.Color = Vector3.One;
Context.Texture = renderTarget;
Context.NormalMap = Context.NeutralNormals;
Context.World = WorldTransform;
Context.LightingEnabled = false;
if (RenderOnTop)
Context.Device.DepthStencilState = DepthStencilState.None;
else
Context.Device.DepthStencilState = DepthStencilState.Default;
Context.ApplyChanges();
Context.Draw(Mesh);
Context.Device.DepthStencilState = DepthStencilState.Default;
}
public override void DrawRegionRepresentation(System.Drawing.Graphics gc, Render.RenderParameter r, Render.IDrawVisitor drawMethods, PointD mousePosition)
{
RectangleF bounds = m_Param.Path.GetBounds();
for (double i = bounds.Width / (Render.DrawHelper.X_ARROWS + 1); i < bounds.Width; i += bounds.Width / (Render.DrawHelper.X_ARROWS + 1))
{
for (double j = bounds.Height / (Render.DrawHelper.Y_ARROWS + 1); j < bounds.Height; j += bounds.Height / (Render.DrawHelper.Y_ARROWS + 1))
{
Point thePoint = new Point((int) (bounds.Left + i), (int) (bounds.Top + j));
if (m_Param.Path.IsVisible(thePoint))
{
Position.VirtualMousePosition mouse = new Position.VirtualMousePosition((Point)thePoint);
PointD vector = GetVelocity(mouse) * Render.DrawHelper.SPEED_AMPLIFIER * (m_Param.C + 0.1);
drawMethods.DrawArrow(gc, r, (PointD)thePoint, vector);
}
}
}
}
/*
gc.DrawLine(Pens.Green, new Point(100, 100), new Point(300, 200));
gc.DrawEllipse(Pens.Green, (float)mappedToLine.X, (float)mappedToLine.Y, 4f, 4f);
gc.DrawLine(Pens.Green, 100f, 100f, 100f + (float)normalComponent.X, 100f + (float)normalComponent.Y);
*/
protected override void SecondCache(Render.IDrawVisitor drawMethods)
{
if (m_Param.Path.PointCount == 0)
return;
PointF[] array = ((Tools.Model.VectorPath)m_Param.Path).InternalPath.PathPoints;
// calculate number of lines to show for feedback
int spacing = (int)drawMethods.Spacing(m_Param.C);
int numLines = (int)m_Param.PathThickness / spacing;
// build a number of trace lines
m_traceLines = new List<PointF>[numLines];
for (int j = 0; j < numLines; j++)
m_traceLines[j] = new List<PointF>(array.Length);
// render all the points
for (int i = 1; i < array.Length; i += 2)
{
PointD tangent = new PointD(array[i].X - array[i - 1].X, array[i].Y - array[i - 1].Y);
tangent = tangent / tangent.Magnitude();
PointD normalVector = PointD.Orthogonal(tangent);
PointD pointOnLine = new PointD((array[i].X + array[i - 1].X) / 2.0, (array[i].Y + array[i - 1].Y) / 2.0);
for (int k = 0; k < numLines; k++)
{
PointD testPt = pointOnLine + normalVector * spacing * (k - numLines / 2);
m_traceLines[k].Add((PointF)testPt);
}
//PointD testNormal1 = (testPt1 - pointOnLine);
//testNormal1 = testNormal1 / testNormal1.Magnitude();
//PointD testNormal2 = (testPt2 - pointOnLine);
//testNormal2 = testNormal2 / testNormal2.Magnitude();
//PointD scaledVector1 = testNormal1 * (GetScalar() * 7 * m_Param.C / Math.Pow((m_Param.PtRadius / 2.0) + 10, 0.5));
//PointD scaledVector2 = testNormal2 * (GetScalar() * 7 * m_Param.C / Math.Pow((m_Param.PtRadius / 2.0) + 10, 0.5));
//drawMethods.DrawArrow(gc, r, testPt1, scaledVector1 * Render.DrawHelper.SPEED_AMPLIFIER);
//drawMethods.DrawArrow(gc, r, testPt2, scaledVector2 * Render.DrawHelper.SPEED_AMPLIFIER);
}
}
public static void RenderText(
String text, float X, float Y, float wrapAt, Render.ImmediateMode2d context, BitmapFont font, float depth = 0)
{
context.Texture = font.fontData;
var x = X;
var y = Y;
var kx = (font.glyphWidth - font.kerningWidth) / 2;
int col = (int)font.fontData.Width / (int)font.glyphWidth;
for (var i = 0; i < text.Length; ++i)
{
if (x >= wrapAt)
{
y += font.glyphHeight;
x = X;
}
var code = text[i];
if (code == '\n')
{
x = X;
y += font.glyphHeight;
}
else if (code == ' ')
{
x += font.kerningWidth;
}
else if (code < 0x80)
{
float fx = (code % col) * font.glyphWidth;
float fy = (code / col) * font.glyphHeight;
context.Glyph(x, y, font.glyphWidth, font.glyphHeight, fx / font.fontData.Width,
fy / font.fontData.Height, (float)font.glyphWidth / (float)font.fontData.Width,
(float)font.glyphHeight / (float)font.fontData.Height, depth);
x += font.kerningWidth;
}
}
}
private string RenderCoordinates(JArray coordinates)
=> Render.Object(coordinates
.Select(RenderCoordinate)
.ToArray());
private string RenderInstructionsAct(TestMethod testMethod)
{
var actual = Render.Object(testMethod.Input["instructions"]);
return($"sut.Simulate({actual});");
}
private UnescapedValue RenderDirection(string direction)
=> Render.Enum("Direction", direction);
private UnescapedValue RenderAsMultilineArray(dynamic value) => new UnescapedValue(Render.ArrayMultiLine(value as string[] ?? Array.Empty <string>()));
/// <summary>
/// An image
/// </summary>
/// <param name="report"></param>
/// <param name="render"></param>
/// <param name="pos"></param>
/// <param name="image"></param>
/// <returns></returns>
public ReportImage(Report report, Render render, Rectangle pos, byte[] image) : base(report, render, pos)
{
m_image = image;
}
protected void registerOutput(string name, Render s)
{
this.outputs.Add(name, s);
}
public void ReleaseRenderTexture()
{
m_descriptionChanged = true;
Render.ReleaseRenderTexture();
Render.ChangeTexture(GetPathForID(DEFAULT_OFFLINE_TEXTURE));
}
/// <summary>
/// Initializes drawings.
/// </summary>
public void Drawings()
{
/// <summary>
/// Loads the Q drawing.
/// </summary>
if (SpellClass.Q.Ready &&
MenuClass.Drawings["q"].As <MenuBool>().Enabled)
{
Render.Circle(UtilityClass.Player.Position, SpellClass.Q.Range, 30, Color.LightGreen);
}
/// <summary>
/// Loads the W drawing.
/// </summary>
if (SpellClass.W.Ready &&
MenuClass.Drawings["w"].As <MenuBool>().Enabled)
{
Render.Circle(UtilityClass.Player.Position, SpellClass.W.Range, 30, Color.Yellow);
}
/// <summary>
/// Loads the E drawing.
/// </summary>
if (SpellClass.E.Ready &&
MenuClass.Drawings["e"].As <MenuBool>().Enabled)
{
Render.Circle(UtilityClass.Player.Position, SpellClass.E.Range, 30, Color.Cyan);
}
/// <summary>
/// Loads the R drawings.
/// </summary>
if (SpellClass.R.Ready)
{
/// <summary>
/// Loads the R range drawing.
/// </summary>
if (MenuClass.Drawings["r"].As <MenuBool>().Enabled)
{
Render.Circle(UtilityClass.Player.Position, SpellClass.R.Range, 30, Color.Red);
}
/// <summary>
/// Loads the R minimap drawing.
/// </summary>
if (MenuClass.Drawings["rmm"].As <MenuBool>().Enabled)
{
Geometry.DrawCircleOnMinimap(UtilityClass.Player.Position, SpellClass.R.Range, Color.White);
}
}
/// <summary>
/// Loads the WorkedGrounds drawing.
/// </summary>
if (MenuClass.Drawings["grounds"].As <MenuBool>().Enabled)
{
foreach (var ground in WorkedGrounds)
{
Render.Circle(ground.Value, WorkedGroundWidth, 30, Color.Brown);
}
}
/// <summary>
/// Loads the MineFields drawing.
/// </summary>
if (MenuClass.Drawings["boulders"].As <MenuBool>().Enabled)
{
foreach (var boulder in MineField)
{
Render.Circle(boulder.Value, BouldersWidth, 30, Color.Brown);
}
}
}
public static void RenderBasics()
{
if (Global.Player.IsDead)
{
return;
}
if (MenuConfig.FleeMode.Active)
{
var spot = WallExtension.GetBestWallHopPos(Global.Player.ServerPosition, 275);
if (!spot.IsZero)
{
Render.WorldToScreen(spot.Extend(Global.Player.ServerPosition, 65), out var startPointVector2);
Render.WorldToScreen(spot, out var endPointVector2);
Render.Line(startPointVector2, endPointVector2, Color.Orange);
Render.Circle(spot, 50, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
}
}
if (MenuConfig.Drawings["Mouse"].Enabled && Global.Orbwalker.Mode != OrbwalkingMode.None)
{
if (!SpellConfig.Q.Ready && Extensions.CurrentQCount == 1)
{
return;
}
var temp = Global.Orbwalker.GetOrbwalkingTarget();
if (temp != null && temp.IsHero && temp.Distance(Global.Player) > Global.Player.AttackRange - 100)
{
var pos = Global.Player.ServerPosition.Extend(temp.ServerPosition, 450);
Render.Circle(pos, 200, (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
Render.WorldToScreen(pos, out var posV2);
Render.Text("Put Mouse Here", new Vector2(posV2.X - 50, posV2.Y), RenderTextFlags.Center, Color.White);
}
}
if (MenuConfig.Drawings["Pattern"].Enabled)
{
Render.WorldToScreen(Global.Player.Position, out var playerV2);
if (MenuConfig.BurstMode.Active)
{
RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetSelectedTarget());
Render.Text("PATTERN: " + Enums.BurstPattern, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
}
switch (Global.Orbwalker.Mode)
{
case OrbwalkingMode.Mixed:
RenderHelper.RenderArrowFromPlayer(Global.TargetSelector.GetTarget(Extensions.EngageRange + 800));
Render.Text("PATTERN: " + Enums.Current, new Vector2(playerV2.X - 65, playerV2.Y + 30), RenderTextFlags.Center, Color.Aqua);
break;
}
}
if (MenuConfig.Drawings["Engage"].Enabled)
{
if (Extensions.AllIn || MenuConfig.BurstMode.Active)
{
Render.Circle(Global.Player.Position, Extensions.FlashRange(), (uint)MenuConfig.Drawings["Segments"].Value, Color.Yellow);
}
else
{
Render.Circle(Global.Player.Position, Extensions.EngageRange, (uint)MenuConfig.Drawings["Segments"].Value, Color.White);
}
}
if (MenuConfig.Drawings["R2"].Enabled && SpellConfig.R2.Ready && Enums.UltimateMode == UltimateMode.Second)
{
Render.Circle(Global.Player.Position, SpellConfig.R2.Range, (uint)MenuConfig.Drawings["Segments"].Value, Color.OrangeRed);
}
}
public override void StartRendering()
{
Render.DrawEllipse(_ellipse, BorderBrush);
Render.FillEllipse(_ellipse, BackgroundBrush);
}
/// <summary>
/// Initializes the drawings.
/// </summary>
public void Drawings()
{
/// <summary>
/// Loads the Q drawing.
/// </summary>
if (SpellClass.Q.Ready)
{
/// <summary>
/// Loads the Q drawing.
/// </summary>
if (MenuClass.Drawings["q"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.LightGreen, SpellClass.Q.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the Extended Q drawing.
/// </summary>
if (MenuClass.Drawings["qcone"].As <MenuBool>().Enabled)
{
foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.Q2.Range))
{
var unitsToIterate = Extensions.GetAllGenericUnitTargetsInRange(SpellClass.Q.Range)
.Where(m => !m.IsMoving && QCone(m).IsInside((Vector2)target.Position))
.OrderBy(m => m.HP)
.ToList();
foreach (var minion in unitsToIterate)
{
DrawQCone(minion).Draw(QCone(minion).IsInside((Vector2)target.Position) && MenuClass.Spells["q2"]["whitelist"][target.CharName.ToLower()].Enabled
? Color.Green
: Color.Red);
}
}
}
}
/// <summary>
/// Loads the E drawing.
/// </summary>
if (SpellClass.E.Ready &&
MenuClass.Drawings["e"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.Cyan, SpellClass.E.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the R drawing.
/// </summary>
if (SpellClass.R.Ready &&
MenuClass.Drawings["r"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.Red, SpellClass.R.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the Passive drawing.
/// </summary>
if (MenuClass.Drawings["passivetarget"].As <MenuBool>().Enabled)
{
var target = ObjectManager.Get <AIBaseClient>().FirstOrDefault(u => u.NetworkID == LoveTapTargetNetworkId);
if (target != null)
{
Render.Circle(target.Position, target.BoundingRadius, 30, Color.Black);
}
}
}
/// <summary>
/// 容器渲染结束
/// </summary>
public void End()
{
Render.RenderEndTag(_writer);
}
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
base.Init(builder, cubeGrid);
ProfilerShort.Begin("FP.Init");
CheckConnectionAllowed = true;
var ob = builder as MyObjectBuilder_FracturedBlock;
if (ob.Shapes.Count == 0)
{
ProfilerShort.End();
if (ob.CreatingFracturedBlock)
{
return;
}
Debug.Fail("No relevant shape was found for fractured block. It was probably reexported and names changed.");
throw new Exception("No relevant shape was found for fractured block. It was probably reexported and names changed.");
}
OriginalBlocks = new List <MyDefinitionId>();
Orientations = new List <MyBlockOrientation>();
var lst = new List <HkdShapeInstanceInfo>();
foreach (var def in ob.BlockDefinitions)
{
var blockDef = MyDefinitionManager.Static.GetCubeBlockDefinition(def);
var model = blockDef.Model;
if (VRage.Game.Models.MyModels.GetModelOnlyData(model).HavokBreakableShapes == null)
{
MyDestructionData.Static.LoadModelDestruction(model, blockDef, Vector3.One);
}
var shape = VRage.Game.Models.MyModels.GetModelOnlyData(model).HavokBreakableShapes[0];
var si = new HkdShapeInstanceInfo(shape, null, null);
lst.Add(si);
m_children.Add(si);
shape.GetChildren(m_children);
if (blockDef.BuildProgressModels != null)
{
foreach (var progress in blockDef.BuildProgressModels)
{
model = progress.File;
if (VRage.Game.Models.MyModels.GetModelOnlyData(model).HavokBreakableShapes == null)
{
MyDestructionData.Static.LoadModelDestruction(model, blockDef, Vector3.One);
}
shape = VRage.Game.Models.MyModels.GetModelOnlyData(model).HavokBreakableShapes[0];
si = new HkdShapeInstanceInfo(shape, null, null);
lst.Add(si);
m_children.Add(si);
shape.GetChildren(m_children);
}
}
OriginalBlocks.Add(def);
}
foreach (var or in ob.BlockOrientations)
{
Orientations.Add(or);
}
if (ob.MultiBlocks.Count > 0)
{
MultiBlocks = new List <MultiBlockPartInfo>();
foreach (var mbpart in ob.MultiBlocks)
{
if (mbpart != null)
{
MultiBlocks.Add(new MultiBlockPartInfo()
{
MultiBlockDefinition = mbpart.MultiBlockDefinition, MultiBlockId = mbpart.MultiBlockId
});
}
else
{
MultiBlocks.Add(null);
}
}
}
m_shapes.AddRange(ob.Shapes);
for (int i = 0; i < m_children.Count; i++)
{
var child = m_children[i];
Func <MyObjectBuilder_FracturedBlock.ShapeB, bool> x = s => s.Name == child.ShapeName;
var result = m_shapes.Where(x);
if (result.Count() > 0)
{
var found = result.First();
var m = Matrix.CreateFromQuaternion(found.Orientation);
m.Translation = child.GetTransform().Translation;
var si = new HkdShapeInstanceInfo(child.Shape.Clone(), m);
if (found.Fixed)
{
si.Shape.SetFlagRecursively(HkdBreakableShape.Flags.IS_FIXED);
}
lst.Add(si);
m_shapeInfos.Add(si);
m_shapes.Remove(found);
}
else
{
child.GetChildren(m_children);
}
}
if (m_shapeInfos.Count == 0)
{
m_children.Clear();
ProfilerShort.End();
Debug.Fail("No relevant shape was found for fractured block. It was probably reexported and names changed.");
throw new Exception("No relevant shape was found for fractured block. It was probably reexported and names changed.");
}
foreach (var shape in m_shapeInfos)
{
if (!string.IsNullOrEmpty(shape.Shape.Name))
{
Render.AddPiece(shape.Shape.Name, Matrix.CreateFromQuaternion(Quaternion.CreateFromRotationMatrix(shape.GetTransform().GetOrientation())));
}
}
if (CubeGrid.CreatePhysics)
{
HkdBreakableShape compound = new HkdCompoundBreakableShape(null, m_shapeInfos);
((HkdCompoundBreakableShape)compound).RecalcMassPropsFromChildren();
Shape = compound;
var mp = new HkMassProperties();
compound.BuildMassProperties(ref mp);
Shape = new HkdBreakableShape(compound.GetShape(), ref mp);
compound.RemoveReference();
foreach (var si in m_shapeInfos)
{
var siRef = si;
Shape.AddShape(ref siRef);
}
Shape.SetStrenght(MyDestructionConstants.STRENGTH);
CreateMountPoints();
}
m_children.Clear();
foreach (var si in m_shapeInfos)
{
si.Shape.RemoveReference();
}
foreach (var si in lst)
{
si.RemoveReference();
}
m_shapeInfos.Clear();
ProfilerShort.End();
}
private static void Render_OnPresent()
{
if (Setup.Draw["W"].As <MenuBool>().Enabled&& Spells.W.Ready)
{
Render.Circle(Player.Position, Spells.W.Range, 30, Color.Cyan);
}
if (Setup.Draw["E"].As <MenuBool>().Enabled&& Spells.E.Ready)
{
Render.Circle(Player.Position, Spells.E.Range, 30, Color.Pink);
}
if (Setup.Draw["R"].As <MenuBool>().Enabled&& Spells.R.Ready)
{
Render.Circle(Player.Position, Spells.R.Range, 30, Color.DarkBlue);
}
if (Setup.Draw["Key"].As <MenuBool>().Enabled)
{
Vector2 TextPos;
var playerpos = Render.WorldToScreen(Player.Position, out TextPos);
var xOffset = (int)TextPos.X;
var yOffset = (int)TextPos.Y;
if (Setup.Clear["Key"].Enabled)
{
Render.Text(xOffset - 50, yOffset + 20, Color.LimeGreen, "Clear Key Toggle = On");
}
if (!Setup.Clear["Key"].Enabled)
{
Render.Text(xOffset - 50, yOffset + 20, Color.Red, "Clear Key Toggle = Off");
}
if (Setup.Harass["Key"].Enabled)
{
Render.Text(xOffset - 50, yOffset + 40, Color.LimeGreen, "Harass Key Toggle = On");
}
if (!Setup.Harass["Key"].Enabled)
{
Render.Text(xOffset - 50, yOffset + 40, Color.Red, "Harass Key Toggle = Off");
}
}
if (Setup.Draw["Damage"].As <MenuBool>().Enabled)
{
ObjectManager.Get <Obj_AI_Base>()
.Where(h => h is Obj_AI_Hero && h.IsValidTarget() && h.IsVisible && h.IsOnScreen)
.ToList()
.ForEach(
unit =>
{
var heroUnit = unit as Obj_AI_Hero;
int width = 103;
int xOffset = SxOffset(heroUnit);
int yOffset = SyOffset(heroUnit);
var barPos = unit.FloatingHealthBarPosition;
barPos.X += xOffset;
barPos.Y += yOffset;
var drawEndXPos = barPos.X + width * (unit.HealthPercent() / 100);
var drawQStartXPos =
(float)(barPos.X + (unit.Health >
Qdmg(unit)
? width * ((unit.Health - (Qdmg(unit)
)) /
unit.MaxHealth * 100 / 100)
: 0));
Render.Line(drawQStartXPos, barPos.Y, drawEndXPos, barPos.Y, 12, true,
unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
? Color.Purple
: Color.LimeGreen);
var drawWStartXPos =
(float)(barPos.X + (unit.Health >
Qdmg(unit) + Wdmg(unit)
? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit)
)) /
unit.MaxHealth * 100 / 100)
: 0));
Render.Line(drawWStartXPos, barPos.Y, drawQStartXPos, barPos.Y, 12, true,
unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
? Color.Purple
: Color.Cyan);
var drawEStartXPos =
(float)(barPos.X + (unit.Health >
Qdmg(unit) + Wdmg(unit) + Edmg(unit)
? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit) + Edmg(unit)
)) /
unit.MaxHealth * 100 / 100)
: 0));
Render.Line(drawEStartXPos, barPos.Y, drawWStartXPos, barPos.Y, 12, true,
unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
? Color.Purple
: Color.Pink);
var drawRStartXPos =
(float)(barPos.X + (unit.Health >
Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
)) /
unit.MaxHealth * 100 / 100)
: 0));
Render.Line(drawRStartXPos, barPos.Y, drawEStartXPos, barPos.Y, 12, true,
unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
? Color.Purple
: Color.DarkBlue);
});
}
}
/// <summary>
/// Raise the event <see cref="Render"/>.
/// </summary>
protected virtual void OnRender()
{
Render?.Invoke(this, new NativeWindowEventArgs(_DeviceContext, _RenderContext));
}
public BattlefieldViewer(ITurnDataModel turnDataModel)
{
InitializeComponent();
render = new Render(turnDataModel, pictureBox1, new DefaultDrawer());
}
public void It_can_render_unencoded_text()
{
var result = Render.StringToString("{{{foo}}}", new { foo = "<bar>" });
Assert.AreEqual("<bar>", result);
}
public void draw(Render render)
{
pond.draw(render);
}
public void Compile(string channel, Size insize, Size outsize, bool finalTarget)
{
RETRY:
Program.Clear();
//prep filters for initialization
foreach (var f in Filters)
{
f.BeginInitialization(this);
f.Initialize();
}
//propagate input size forwards through filter chain to allow a 'flex' filter to determine what its input will be
Size presize = insize;
for (int i = 0; i < Filters.Count; i++)
{
var filter = Filters[i];
presize = filter.PresizeInput(channel, presize);
}
//propagate output size backwards through filter chain to allow a 'flex' filter to determine its output based on the desired output needs
presize = outsize;
for (int i = Filters.Count - 1; i >= 0; i--)
{
var filter = Filters[i];
presize = filter.PresizeOutput(channel, presize);
}
SurfaceState currState = null;
for (int i = 0; i < Filters.Count; i++)
{
BaseFilter f = Filters[i];
//check whether this filter needs input. if so, notify it of the current pipeline state
var iosi = f.FindInput(channel);
if (iosi != null)
{
iosi.SurfaceFormat = currState.SurfaceFormat;
f.SetInputFormat(channel, currState);
if (f.IsNOP)
{
continue;
}
//check if the desired disposition needs to change from texture to render target
//(if so, insert a render filter)
if (iosi.SurfaceDisposition == SurfaceDisposition.RenderTarget && currState.SurfaceDisposition == SurfaceDisposition.Texture)
{
var renderer = new Render();
Filters.Insert(i, renderer);
goto RETRY;
}
//check if the desired disposition needs to change from a render target to a texture
//(if so, the current render target gets resolved, and made no longer current
else if (iosi.SurfaceDisposition == SurfaceDisposition.Texture && currState.SurfaceDisposition == SurfaceDisposition.RenderTarget)
{
var resolver = new Resolve();
Filters.Insert(i, resolver);
goto RETRY;
}
}
//now, the filter will have set its output state depending on its input state. check if it outputs:
iosi = f.FindOutput(channel);
if (iosi != null)
{
if (currState == null)
{
currState = new SurfaceState();
currState.SurfaceFormat = iosi.SurfaceFormat;
currState.SurfaceDisposition = iosi.SurfaceDisposition;
}
else
{
//if output disposition is unspecified, change it to whatever we've got right now
if (iosi.SurfaceDisposition == SurfaceDisposition.Unspecified)
{
iosi.SurfaceDisposition = currState.SurfaceDisposition;
}
bool newTarget = false;
if (iosi.SurfaceFormat.Size != currState.SurfaceFormat.Size)
{
newTarget = true;
}
else if (currState.SurfaceDisposition == SurfaceDisposition.Texture && iosi.SurfaceDisposition == SurfaceDisposition.RenderTarget)
{
newTarget = true;
}
if (newTarget)
{
currState = new SurfaceState();
iosi.SurfaceFormat = currState.SurfaceFormat = iosi.SurfaceFormat;
iosi.SurfaceDisposition = currState.SurfaceDisposition = iosi.SurfaceDisposition;
Program.Add(new ProgramStep(ProgramStepType.NewTarget, currState.SurfaceFormat.Size));
}
else
{
currState.SurfaceDisposition = iosi.SurfaceDisposition;
}
}
}
Program.Add(new ProgramStep(ProgramStepType.Run, i, f.GetType().Name));
} //filter loop
//if the current output disposition is a texture, we need to render it
if (currState.SurfaceDisposition == SurfaceDisposition.Texture)
{
var renderer = new Render();
Filters.Insert(Filters.Count, renderer);
goto RETRY;
}
//patch the program so that the final rendertarget set operation is the framebuffer instead
if (finalTarget)
{
for (int i = Program.Count - 1; i >= 0; i--)
{
var ps = Program[i];
if (ps.Type == ProgramStepType.NewTarget)
{
var size = (Size)ps.Args;
Debug.Assert(size == outsize);
ps.Type = ProgramStepType.FinalTarget;
ps.Args = size;
break;
}
}
}
}
internal void OnPaint(CefBrowser browser, IntPtr buffer, int width, int height, CefRectangle[] dirtyRects)
{
Render?.Invoke(this, new RenderEventArgs(buffer, width, height, dirtyRects));
}
private static void Game_RenderFrame(object sender, FrameEventArgs e)
{
Render?.Invoke(e.Time);
}
/// <summary>
/// Initializes the drawings.
/// </summary>
public void Drawings()
{
/// <summary>
/// Loads the Q drawing.
/// </summary>
if (SpellClass.Q.Ready &&
MenuClass.Drawings["q"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.LightGreen, SpellClass.Q.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the E drawing.
/// </summary>
if (SpellClass.E.Ready &&
MenuClass.Drawings["e"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.Cyan, SpellClass.E.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the R drawing.
/// </summary>
if (SpellClass.R.Ready)
{
if (MenuClass.Drawings["r"].As <MenuBool>().Enabled)
{
CircleRendering.Render(Color.Red, SpellClass.R.Range, UtilityClass.Player);
}
/// <summary>
/// Loads the R damage to healthbar.
/// </summary>
if (MenuClass.Drawings["rdmg"].As <MenuBool>().Enabled)
{
foreach (var hero in Extensions.GetEnemyHeroesTargetsInRange(SpellClass.R.Range).Where(h =>
!Invulnerable.Check(h) &&
h.InfoBarPosition.OnScreen()))
{
var width = DrawingClass.SWidth;
var height = DrawingClass.SHeight;
var xOffset = DrawingClass.SxOffset(hero);
var yOffset = DrawingClass.SyOffset(hero);
var barPos = hero.InfoBarPosition;
barPos.X += xOffset;
barPos.Y += yOffset;
var unitHealth = hero.GetRealHealth();
var totalDamage = GetTotalNoxianGuillotineDamage(hero);
var barLength = 0;
if (unitHealth > totalDamage)
{
barLength = (int)(width * ((unitHealth - totalDamage) / hero.MaxHP * 100 / 100));
}
var drawEndXPos = barPos.X + width * (hero.HPPercent() / 100);
var drawStartXPos = barPos.X + barLength;
Render.Line(drawStartXPos, barPos.Y, drawEndXPos, barPos.Y, height, true, unitHealth < totalDamage ? Color.Blue : Color.Orange);
Render.Line(drawStartXPos, barPos.Y, drawStartXPos, barPos.Y + height + 1, 1, true, Color.Lime);
}
}
}
}
public void Update(Tank Tank)
{
Render.DrawTank(Tank);
}
internal void Reconstruct(lightmap_vertex_buffer_bucket_block buffer_bucket,
geometry_block_resource_block gb,
IO.EndianReader er,
Render.VertexBufferInterface.StreamReader[] stream_readers)
{
short stream_source = gb.SecondaryLocater.Value;
var stream_r = stream_readers[stream_source];
if (!stream_r.UsesNullDefinition)
{
stream_r.Read(er);
stream_r.Denormalize();
ReconstructRawVertex(buffer_bucket, stream_source, stream_r);
}
}
public override void EnterMessageLoop(bool runInBackground)
{
IntPtr wmDeleteWindow = XInternAtom(_display, "WM_DELETE_WINDOW", false);
XSetWMProtocols(_display, _window, new IntPtr[] { wmDeleteWindow }, 1);
IntPtr e = System.Runtime.InteropServices.Marshal.AllocHGlobal(24 * sizeof(long));
bool running = true;
while (running)
{
while (XPending(_display) != 0)
{
XNextEvent(_display, e);
if (XFilterEvent(e, IntPtr.Zero))
{
continue;
}
XAnyEvent anyEvent = (XAnyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XAnyEvent));
switch ((Event)anyEvent.type)
{
case Event.ClientMessage:
{
XClientMessageEvent clientEvent = (XClientMessageEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XClientMessageEvent));
if (clientEvent.l0 == wmDeleteWindow)
{
bool cancel = false;
Closing?.Invoke(this, ref cancel);
if (!cancel)
{
Closed?.Invoke(this);
running = false;
}
}
break;
}
case Event.ConfigureNotify:
{
XConfigureEvent configureEvent = (XConfigureEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XConfigureEvent));
LocationChanged?.Invoke(this, configureEvent.x, configureEvent.y);
SizeChanged?.Invoke(this, configureEvent.width, configureEvent.height);
break;
}
case Event.FocusIn:
{
Activated?.Invoke(this);
break;
}
case Event.FocusOut:
{
Deactivated?.Invoke(this);
break;
}
case Event.MotionNotify:
{
XMotionEvent motionEvent = (XMotionEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XMotionEvent));
MouseMove?.Invoke(this, motionEvent.x, motionEvent.y);
break;
}
case Event.ButtonPress:
{
XButtonEvent buttonEvent = (XButtonEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XButtonEvent));
switch ((Button)buttonEvent.button)
{
case Button.Button1:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Left);
break;
}
case Button.Button2:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Middle);
break;
}
case Button.Button3:
{
MouseButtonDown?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Right);
break;
}
case Button.Button4:
{
MouseWheel?.Invoke(this, buttonEvent.x, buttonEvent.y, 120);
break;
}
case Button.Button5:
{
MouseWheel?.Invoke(this, buttonEvent.x, buttonEvent.y, -120);
break;
}
}
break;
}
case Event.ButtonRelease:
{
XButtonEvent buttonEvent = (XButtonEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XButtonEvent));
switch ((Button)buttonEvent.button)
{
case Button.Button1:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Left);
break;
}
case Button.Button2:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Middle);
break;
}
case Button.Button3:
{
MouseButtonUp?.Invoke(this, buttonEvent.x, buttonEvent.y, MouseButton.Right);
break;
}
}
break;
}
case Event.KeyPress:
{
XKeyEvent keyEvent = (XKeyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XKeyEvent));
KeySym ks = XLookupKeysym(ref keyEvent, 0);
Key key = NoesisKey(ks);
if (key != Key.None)
{
KeyDown?.Invoke(this, key);
}
if (_xic != IntPtr.Zero)
{
Status status = 0;
byte[] buffer = new byte[256];
KeySym ret_ks = (KeySym)0;
int size = Xutf8LookupString(_xic, e, buffer, 255, ref ret_ks, ref status);
if (size > 0 && ((int)status == XLookupChars || (int)status == XLookupBoth))
{
buffer[size] = 0;
Decoder decoder = _utf8.GetDecoder();
char[] text = new char[256];
int bytesUsed = 0;
int charsUsed = 0;
bool completed = false;
decoder.Convert(buffer, 0, size, text, 0, 255, true, out bytesUsed, out charsUsed, out completed);
for (int i = 0; i < charsUsed; ++i)
{
Char?.Invoke(this, text[i]);
}
}
}
break;
}
case Event.KeyRelease:
{
XKeyEvent keyEvent = (XKeyEvent)System.Runtime.InteropServices.Marshal.PtrToStructure(e, typeof(XKeyEvent));
KeySym ks = XLookupKeysym(ref keyEvent, 0);
Key key = NoesisKey(ks);
if (key != Key.None)
{
KeyUp?.Invoke(this, key);
}
break;
}
}
}
Render?.Invoke(this);
}
System.Runtime.InteropServices.Marshal.FreeHGlobal(e);
XCloseDisplay(_display);
}
public void Request(Render fRender)
{
_cPreferences._bExists = true;
XmlNode cXNData = ingenie.plugins.Data.Get(_sRequest, _nTemplate, _sValue);
XmlNode[] aItems = cXNData.NodesGet("item");
Cache cCached;
bool bClear = false;
lock (_aCache)
if ((bClear = (1 > _aCache.Count)) || null == (cCached = _aCache.FirstOrDefault(o => _cPreferences._sOutputTarget == o.sOutput && _sRequest == o.sRequest && _nTemplate == o.nTemplate)))
_aCache.Add(cCached = new Cache() { sOutput = _cPreferences._sOutputTarget, sRequest = _sRequest, nTemplate = _nTemplate, aHashcodes = new int[aItems.Length + 1] });
lock (cCached)
{
int nHash = cXNData.OuterXml.GetHashCode();
if (Directory.Exists(_cPreferences._sOutputTarget) && nHash == cCached.aHashcodes[0])
return;
if (cCached.aHashcodes.Length != aItems.Length)
Array.Resize<int>(ref cCached.aHashcodes, aItems.Length + 1);
cCached.aHashcodes[0] = nHash;
string sPython, sPythonFile, sFolder;
sPython = sPythonFile = sFolder = null;
for (int nID = 0; aItems.Length > nID; nID++)
{
if (cCached.aHashcodes[nID + 1] == (nHash = aItems[nID].OuterXml.GetHashCode()))
continue;
if (null == sFolder)
{
sFolder = Path.Combine(_cPreferences._sOutputTarget, ".render");
if (Directory.Exists(sFolder))
Directory.Delete(sFolder, true);
Directory.CreateDirectory(sFolder);
sPythonFile = Path.Combine(sFolder, "python.py");
}
sPython = _cPreferences._sPython;
foreach (XmlNode cXNMacro in aItems[nID].NodesGet("item"))
sPython = sPython.Replace("{%_" + cXNMacro.AttributeValueGet("id") + "_%}", cXNMacro.InnerText.FromXML());
File.WriteAllText(sPythonFile, sPython, System.Text.Encoding.GetEncoding(1251));
fRender(_cPreferences._sBlendFile, sPythonFile, sFolder, aItems[nID].AttributeValueGet("output"), _cPreferences._bUseOutput);//, _cPreferences._sEngine, _cPreferences._sThreads));
cCached.aHashcodes[nID + 1] = nHash;
}
if (bClear)
{
foreach (FileInfo cFI in (new DirectoryInfo(_cPreferences._sOutputTarget)).GetFiles())
{
try
{
cFI.Delete();
}
catch (Exception ex)
{
(new Logger()).WriteWarning(ex);
}
}
}
if (null != sFolder)
{
File.Delete(sPythonFile);
foreach (string sFile in Directory.GetFiles(sFolder))
{
for (int nI = 0; nI < 10; nI++)
{
try
{
//File.Copy(sFile, Path.Combine(_cPreferences._sOutputTarget, Path.GetFileName(sFile)), true);
new CopyFileExtended(sFile, Path.Combine(_cPreferences._sOutputTarget, Path.GetFileName(sFile)), 0, 1000);
break;
}
catch (Exception ex)
{
(new Logger()).WriteError(ex);
System.Threading.Thread.Sleep(300);
}
}
try
{
File.Delete(sFile);
}
catch (Exception ex)
{
(new Logger()).WriteError(ex);
}
System.Threading.Thread.Sleep(1); // проверка //DNF
}
}
}
}
public virtual async Task DrawAsync(CancellationToken token)
{
await Render.RenderAsync(drawClock(token), token);
}
public void CreateRenderObjects()
{
//Create the minimap sprite.
if (Range == 1100)
{
_minimapSprite = new Render.Sprite(WardData.Bitmap, MinimapPosition);
_minimapSprite.Scale = new Vector2(_scale, _scale);
_minimapSprite.Add(0);
}
//Create the circle:
_defaultCircle = new Render.Circle(Position, 200, Color, 5, true);
_defaultCircle.VisibleCondition +=
sender =>
WardTracker.Config.Item("Enabled").GetValue <bool>() &&
!WardTracker.Config.Item("Details").GetValue <KeyBind>().Active&& Render.OnScreen(Drawing.WorldToScreen(Position));
_defaultCircle.Add(0);
_defaultCircleFilled = new Render.Circle(Position, 200, Color.FromArgb(25, Color), -142857, true);
_defaultCircleFilled.VisibleCondition +=
sender =>
WardTracker.Config.Item("Enabled").GetValue <bool>() &&
!WardTracker.Config.Item("Details").GetValue <KeyBind>().Active&& Render.OnScreen(Drawing.WorldToScreen(Position));
_defaultCircleFilled.Add(-1);
//Create the circle that shows the range
_rangeCircle = new Render.Circle(Position, Range, Color, 10, false);
_rangeCircle.VisibleCondition +=
sender =>
WardTracker.Config.Item("Enabled").GetValue <bool>() &&
WardTracker.Config.Item("Details").GetValue <KeyBind>().Active;
_rangeCircle.Add(0);
_rangeCircleFilled = new Render.Circle(Position, Range, Color.FromArgb(25, Color), -142857, true);
_rangeCircleFilled.VisibleCondition +=
sender =>
WardTracker.Config.Item("Enabled").GetValue <bool>() &&
WardTracker.Config.Item("Details").GetValue <KeyBind>().Active;
_rangeCircleFilled.Add(-1);
//Missile line;
if (IsFromMissile)
{
_missileLine = new Render.Line(new Vector2(), new Vector2(), 2, new ColorBGRA(255, 255, 255, 255));
_missileLine.EndPositionUpdate = () => Drawing.WorldToScreen(Position);
_missileLine.StartPositionUpdate = () => Drawing.WorldToScreen(StartPosition);
_missileLine.VisibleCondition +=
sender =>
WardTracker.Config.Item("Enabled").GetValue <bool>() &&
WardTracker.Config.Item("Details").GetValue <KeyBind>().Active;
_missileLine.Add(0);
}
//Create the timer text:
if (Duration != int.MaxValue)
{
_timerText = new Render.Text(10, 10, "t", 18, new ColorBGRA(255, 255, 255, 255));
_timerText.OutLined = true;
_timerText.PositionUpdate = () => Drawing.WorldToScreen(Position);
_timerText.Centered = true;
_timerText.VisibleCondition += sender => WardTracker.Config.Item("Enabled").GetValue <bool>() && Render.OnScreen(Drawing.WorldToScreen(Position));
_timerText.TextUpdate =
() =>
(IsFromMissile ? "?? " : "") + Utils.FormatTime((EndT - Environment.TickCount) / 1000f) +
(IsFromMissile ? " ??" : "");
_timerText.Add(2);
}
}
void OnRender(object sender, LiveFeedScaler e)
{
Render?.Invoke(sender, e);
}
public Information(Ox ox, Render view)
: base(ox, view)
{
}
bool IMyEntity.IsVisible()
{
return(Render.IsVisible());
}
public void SetInput(string name, Render s)
{
if (this.inputs.ContainsKey(name))
{
this.inputs[name] = s;
}
else
{
throw new Exception("Use of a unregistered input. Inputs must to registered by the node before it can be used.");
}
}
VRageMath.Vector3 IMyEntity.GetDiffuseColor()
{
return(Render.GetDiffuseColor());
}
public static void OnDamageIndicator()
{
Render.OnPresent += delegate
{
if (ObjectManager.GetLocalPlayer().IsDead || !MyLogic.DrawMenu["FlowersVladimir.DrawMenu.ComboDamage"].Enabled)
{
return;
}
foreach (var target in GameObjects.EnemyHeroes.Where(h => h.IsValid && h.IsFloatingHealthBarActive))
{
Vector2 pos;
Render.WorldToScreen(target.ServerPosition, out pos);
if (!Render.IsPointInScreen(pos))
{
return;
}
if (target.IsMelee)
{
YOffset = 12;
}
else if (target.ChampionName == "Annie" || target.ChampionName == "Jhin")
{
YOffset = 5;
}
else
{
YOffset = 18;
}
var damage = MyExtraManager.GetComboDamage(target);
if (damage > 2)
{
var barPos = target.FloatingHealthBarPosition;
var percentHealthAfterDamage = Math.Max(0, target.Health - damage) / target.MaxHealth;
var yPos = barPos.Y + YOffset;
var xPosDamage = barPos.X + XOffset + Width * percentHealthAfterDamage;
var xPosCurrentHp = barPos.X + XOffset + Width * target.Health / target.MaxHealth;
if (damage > target.Health)
{
var X = (int)barPos.X + XOffset;
var Y = (int)barPos.Y + YOffset - 15;
var text = "KILLABLE: " + (target.Health - damage);
Render.Text(X, Y, Color.Red, text);
}
Render.Line(xPosDamage, yPos, xPosDamage, yPos + Height, 5, true, Color);
if (MyLogic.DrawMenu["FlowersVladimir.DrawMenu.FillDamage"].Enabled)
{
var differenceInHp = xPosCurrentHp - xPosDamage;
var pos1 = barPos.X + 9 + 107 * percentHealthAfterDamage;
for (var i = 0; i < differenceInHp; i++)
{
Render.Line(pos1 + i, yPos, pos1 + i, yPos + Height, 5, true, FillColor);
}
}
}
}
};
}
public void RefreshModels(string model, string modelCollision)
{
if (model != null)
{
Render.ModelStorage = MyModels.GetModelOnlyData(model);
PositionComp.LocalVolumeOffset = Render.GetModel().BoundingSphere.Center;
}
if (modelCollision != null)
{
m_modelCollision = MyModels.GetModelOnlyData(modelCollision);
}
if (Render.ModelStorage != null)
{
this.PositionComp.LocalAABB = Render.GetModel().BoundingBox;
bool idAllocationState = MyEntityIdentifier.AllocationSuspended;
try
{
MyEntityIdentifier.AllocationSuspended = false;
if (Subparts == null)
{
Subparts = new Dictionary <string, MyEntitySubpart>();
}
else
{
foreach (var existingSubpart in Subparts)
{
Hierarchy.RemoveChild(existingSubpart.Value);
existingSubpart.Value.Close();
}
Subparts.Clear();
}
MyEntitySubpart.Data data = new MyEntitySubpart.Data();
foreach (var dummy in Render.GetModel().Dummies)
{
// Check of mirrored matrix of dummy object is under fake, because characters have mirrored dummies
if (MyFakes.ENABLE_DUMMY_MIRROR_MATRIX_CHECK)
{
// This should not be here but if you want to check bad matrices of other types
if (!(this is MyCharacter))
{
Debug.Assert(!dummy.Value.Matrix.IsMirrored());
}
}
if (!MyEntitySubpart.GetSubpartFromDummy(model, dummy.Key, dummy.Value, ref data))
{
continue;
}
MyEntitySubpart subpart = new MyEntitySubpart();
subpart.Render.EnableColorMaskHsv = Render.EnableColorMaskHsv;
subpart.Render.ColorMaskHsv = Render.ColorMaskHsv;
subpart.Init(null, data.File, this, null);
// Set this to false becase no one else is responsible for rendering subparts
subpart.Render.NeedsDrawFromParent = false;
subpart.PositionComp.LocalMatrix = data.InitialTransform;
Subparts[data.Name] = subpart;
if (InScene)
{
subpart.OnAddedToScene(this);
}
}
}
finally
{
MyEntityIdentifier.AllocationSuspended = idAllocationState;
}
if (Render.GetModel().GlassData != null)
{
Render.NeedsDraw = true;
Render.NeedsDrawFromParent = true;
}
}
else
{ //entities without model has box with side length = 1 by default
float defaultBoxHalfSize = 0.5f;
this.PositionComp.LocalAABB = new BoundingBox(new Vector3(-defaultBoxHalfSize), new Vector3(defaultBoxHalfSize));
}
}
