private void picWorld_SizeChanged(object sender, EventArgs e)
{
_worldScale = new WorldScale(1, picWorld.Width / 2, picWorld.Height / 2);
//SetScreenSize(picWorld.Size);
picWorld.Invalidate();
}
public override void Paint(Graphics g, WorldScale scale)
{
base.Paint(g, scale);
double x = (Owner == GameBoard.ColorLeftBlue ? 55 : 3000 - 55);
double dx = (Owner == GameBoard.ColorLeftBlue ? 85 : -85);
for (int i = 0; i < _loads.Count; i++)
{
for (int j = 0; j < _loads[i].Count; j++)
{
new Circle(new RealPoint(x + dx * i, _position.Y - (j - 2) * 75), 36).Paint(g, Color.Black, 1, _loads[i][j], scale);
}
}
x = _position.X + (Owner == GameBoard.ColorLeftBlue ? -130 : 130);
dx = (Owner == GameBoard.ColorLeftBlue ? 85 : -85);
if (_loadOnTop != null)
{
for (int j = 0; j < _loadOnTop.Count; j++)
{
new Circle(new RealPoint(x + dx * j, _position.Y - 280), 36).Paint(g, Color.Black, 1, _loadOnTop[j], scale);
}
}
if (_loadOnBottom != null)
{
for (int j = 0; j < _loadOnBottom.Count; j++)
{
new Circle(new RealPoint(x + dx * j, _position.Y + 280), 36).Paint(g, Color.Black, 1, _loadOnBottom[j], scale);
}
}
}
/// <summary>
/// Dessine le polygone sur un Graphic
/// </summary>
/// <param name="g">Graphic sur lequel dessiner</param>
/// <param name="outlineColor">Couleur du contour du polygone</param>
/// <param name="outlineWidth">Epaisseur du contour</param>
/// <param name="fillColor">Couleur de remplissage du polygone</param>
/// <param name="scale">Echelle de conversion</param>
public void Paint(Graphics g, Pen outline, Brush fill, WorldScale scale)
{
if (Sides.Count == 0)
{
return;
}
Point[] listePoints = new Point[Sides.Count + 1];
listePoints[0] = scale.RealToScreenPosition(Sides[0].StartPoint);
for (int i = 0; i < Sides.Count; i++)
{
Segment s = Sides[i];
listePoints[i] = scale.RealToScreenPosition(s.EndPoint);
}
listePoints[listePoints.Length - 1] = listePoints[0];
if (fill != null)
{
g.FillPolygon(fill, listePoints, System.Drawing.Drawing2D.FillMode.Winding);
}
if (outline != null)
{
g.DrawPolygon(outline, listePoints);
}
}
/// <summary>
/// Peint l'élément sur le Graphic donné à l'échelle donnée
/// </summary>
/// <param name="g">Graphic sur lequel peindre</param>
/// <param name="scale">Echelle de peinture</param>
public override void Paint(Graphics g, WorldScale scale)
{
Pen pBlack = new Pen(Color.Black);
Pen pWhite = new Pen(Color.White);
Pen pWhiteBold = new Pen(Color.White);
pWhite.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
pWhiteBold.Width = 3;
Rectangle rect = new Rectangle(scale.RealToScreenPosition(Position.Translation(-HoverRadius, -HoverRadius)), scale.RealToScreenSize(new SizeF(HoverRadius * 2, HoverRadius * 2)));
if (IsHover)
{
g.DrawEllipse(pWhiteBold, rect);
}
else
{
//g.DrawEllipse(pBlack, rect);
//g.DrawEllipse(pWhite, rect);
}
pBlack.Dispose();
pWhite.Dispose();
pWhiteBold.Dispose();
}
public override void Paint(Graphics g, WorldScale scale)
{
if (_isAvailable)
{
Circle c = new Circle(_position, _hoverRadius);
c.Paint(g, _isHover ? Color.White : Color.Black, 1, _color, scale);
}
}
private void ZoomRight()
{
double dx = _worldScale.ScreenToRealDistance(picWorld.Height / 60f);
double dy = 0;
_worldScale = CreateWorldScale(_worldScale.Factor, RealPoint.Shift(GetCenter(), dx, dy));
picWorld.Invalidate();
}
public override void Init()
{
base.Init();
float scale = WorldScale.MaxComponent();
m_scaledShape = new SphereShape(Radius * Math.Abs(scale));
m_scaledStaticCollidable = m_scaledShape.GetCollidableInstance();
}
private void WorldPanel_MouseDown(object sender, MouseEventArgs e)
{
_pointClicked = Dimensions.WorldScale.ScreenToRealPosition(e.Location);
_centerAtStart = Dimensions.WorldRect.Center();
_scaleAtStart = new WorldScale(Dimensions.WorldScale);
OnStartMove();
}
public override void UpdateStaticCollider()
{
if (m_physicsMesh != null)
{
AffineTransform transform = new AffineTransform(WorldScale.ToBepu(), WorldRotation.ToBepu(), WorldPosition.ToBepu());
m_physicsMesh.WorldTransform = transform;
}
}
/// <summary>
/// Peint le segment sur le Graphic donné
/// </summary>
/// <param name="g">Graphique sur lequel peindre</param>
/// <param name="outlineColor">Couleur du contour</param>
/// <param name="outlineWidth">Epaisseur du segment</param>
/// <param name="fillColor">Couleur de remplissage</param>
/// <param name="scale">Echelle de conversion</param>
public override void Paint(Graphics g, Pen outline, Brush fill, WorldScale scale)
{
Point startPoint = scale.RealToScreenPosition(StartPoint);
Point endPoint = scale.RealToScreenPosition(EndPoint);
if (outline != null)
{
g.DrawLine(outline, startPoint.X, startPoint.Y, endPoint.X, endPoint.Y);
}
}
private void ZoomStep()
{
double dx = _worldScale.ScreenToRealDistance(picWorld.Height / 60f) * _moveHorizontal;
double dy = _worldScale.ScreenToRealDistance(picWorld.Height / 60f) * _moveVertical;
_worldScale = CreateWorldScale(_worldScale.Factor + _moveZoom, RealPoint.Shift(GetCenter(), dx, dy));
//_worldScale = CreateWorldScale(_worldScale.Factor + _moveZoom, GetCenter());
picWorld.Invalidate();
}
protected void SetPhysicsFromLoadedMesh()
{
if (m_physicsMesh != null)
{
m_physicsMesh.Shape = m_meshAssetReference.GetAsset().GetPhysicsInstancedMesh();
m_physicsMesh.Sidedness = TriangleSidedness.Clockwise;
}
else
{
m_physicsMesh = new InstancedMesh(m_meshAssetReference.GetAsset().GetPhysicsInstancedMesh());
}
m_physicsMesh.WorldTransform = new AffineTransform(WorldScale.ToBepu(), WorldRotation.ToBepu(), WorldPosition.ToBepu());
}
/// <summary>
/// Dessine le cercle sur un Graphic
/// </summary>
/// <param name="g">Graphic sur lequel dessiner</param>
/// <param name="outline">Pen utilisé pour dessiner le contour du cercle</param>
/// <param name="fill">Brush utilisé pour remplissage du cercle</param>
/// <param name="scale">Echelle de conversion</param>
public void Paint(Graphics g, Pen outline, Brush fill, WorldScale scale)
{
Point screenPosition = scale.RealToScreenPosition(Center);
int screenRadius = scale.RealToScreenDistance(Radius);
if (fill != null)
{
g.FillEllipse(fill, new Rectangle(screenPosition.X - screenRadius, screenPosition.Y - screenRadius, screenRadius * 2, screenRadius * 2));
}
if (outline != null)
{
g.DrawEllipse(outline, new Rectangle(screenPosition.X - screenRadius, screenPosition.Y - screenRadius, screenRadius * 2, screenRadius * 2));
}
}
public void ChangeWorldScale(WorldScale worldScale)
{
Physics.gravity = originalGravity * worldScale.scale;
if (worldScale.sdkManager)
{
worldScale.sdkManager.LoadedSetupChanged += (s, e) =>
{
if (e.currentSetup == null)
{
return;
}
VRTK.VRTK_DeviceFinder.HeadsetCamera().localScale = new Vector3(worldScale.scale, worldScale.scale, worldScale.scale);
};
// worldScale.sdkManager.transform.localScale = new Vector3(worldScale.scale, worldScale.scale, worldScale.scale);
}
}
public override void Paint(Graphics g, WorldScale scale)
{
base.Paint(g, scale);
double x = _position.X - 110;
double y = 2000 - 10 - 85 / 2;
double dy = -85;
if (_loadOnGreen != null)
{
for (int j = 0; j < _loadOnGreen.Count; j++)
{
if (_loadOnGreen[j] != Color.Transparent)
{
new Circle(new RealPoint(x, y + dy * j), 36).Paint(g, Color.Black, 1, _loadOnGreen[j], scale);
}
}
}
x = _position.X + 110;
if (_loadOnRed != null)
{
for (int j = 0; j < _loadOnRed.Count; j++)
{
if (_loadOnRed[j] != Color.Transparent)
{
new Circle(new RealPoint(x, y + dy * j), 36).Paint(g, Color.Black, 1, _loadOnRed[j], scale);
}
}
}
if (_pendingLeft != Color.Transparent)
{
new Circle(_pendingLeftPos, 36).Paint(g, Color.Black, 1, _pendingLeft, scale);
}
if (_pendingRight != Color.Transparent)
{
new Circle(_pendingRightPos, 36).Paint(g, Color.Black, 1, _pendingRight, scale);
}
}
/// <summary>
/// Dessine la ligne sur un Graphic
/// </summary>
/// <param name="g">Graphic sur lequel dessiner</param>
/// <param name="outline">Pen utilisé pour dessiner le contour de la ligne</param>
/// <param name="fill">Brush utilisé pour remplissage de la ligne</param>
/// <param name="scale">Echelle de conversion</param>
public virtual void Paint(Graphics g, Pen outline, Brush fill, WorldScale scale)
{
// Un peu douteux mais bon
RealPoint p1, p2;
if (this.IsVertical)
{
p1 = GetCrossingPoints(new Line(new RealPoint(-100000, -100000), new RealPoint(+100000, -100000))).FirstOrDefault();
p2 = GetCrossingPoints(new Line(new RealPoint(-100000, +100000), new RealPoint(+100000, +100000))).FirstOrDefault();
}
else
{
p1 = GetCrossingPoints(new Line(new RealPoint(-100000, -100000), new RealPoint(-100000, +100000))).FirstOrDefault();
p2 = GetCrossingPoints(new Line(new RealPoint(+100000, -100000), new RealPoint(+100000, +100000))).FirstOrDefault();
}
if (p1 != null && p2 != null)
{
new Segment(p1, p2).Paint(g, outline, fill, scale);
}
}
private void ZoomStepParam()
{
if (_step < 20)
{
_worldScale = CreateWorldScale(_worldScale.Factor, RealPoint.Shift(GetCenter(), _moveHorizontal, _moveVertical));
}
else if (_step < 40)
{
_worldScale = CreateWorldScale(_worldScale.Factor - _moveZoom, GetCenter());
}
_step++;
if (_step == 40)
{
_moveHorizontal = 0;
_moveVertical = 0;
_moveZoom = 0;
}
picWorld.Invalidate();
}
public void Paint(Graphics g, WorldScale scale)
{
Point previousPoint = Points[0];
using (Pen redPen = new Pen(Color.Red, 2), whitePen = new Pen(Color.White, 4))
{
for (int i = 0; i < Points.Count; i++)
{
Point pointNode = scale.RealToScreenPosition(Points[i]);
if (i >= 1)
{
g.DrawLine(whitePen, pointNode, previousPoint);
g.DrawLine(redPen, pointNode, previousPoint);
}
previousPoint = pointNode;
}
for (int i = 0; i < Points.Count; i++)
{
Point point = scale.RealToScreenPosition(Points[i]);
g.FillEllipse(Brushes.Red, new Rectangle(point.X - 4, point.Y - 4, 8, 8));
g.DrawEllipse(Pens.White, new Rectangle(point.X - 4, point.Y - 4, 8, 8));
}
}
}
private void picWorld_MouseUp(object sender, MouseEventArgs e)
{
if (_startPoint != null)
{
if (_shapeMode == ShapeMode.Zoom)
{
double dx = _rectZoomFinal.Points.Max(pt => pt.X) - _rectZoomFinal.Points.Min(pt => pt.X);
//dx = _worldScale.RealToScreenDistance(dx);
WorldScale finalScale = CreateWorldScale(dx / picWorld.Width, _rectZoomFinal.Barycenter);
_moveZoom = (_worldScale.Factor - finalScale.Factor) / 20;
_moveHorizontal = -finalScale.ScreenToRealDistance((finalScale.OffsetX - _worldScale.OffsetX) / 20);
_moveVertical = -finalScale.ScreenToRealDistance((finalScale.OffsetY - _worldScale.OffsetY) / 20);
_step = 0;
ThreadManager.CreateThread(o => ZoomStepParam()).StartLoop(20, 40);
//_worldScale = finalScale;
_startPoint = null;
_rectZoomFinal = null;
_rectZoomOrg = null;
_shapeMode = ShapeMode.None;
btnZoom.Checked = false;
}
else if (_shapeMode != ShapeMode.None)
{
_shapes.Add(BuildCurrentShape(_shapeMode, _startPoint, PicCoordinates()));
lblItem.Text = "";
_currentShape = null;
_startPoint = null;
}
picWorld.Invalidate();
}
}
public static void Paint(this IShape shape, Graphics g, Color outline, int outlineWidth, Color fill, WorldScale scale)
{
Pen p = new Pen(outline, outlineWidth);
Brush b = new SolidBrush(fill);
shape.Paint(g, p, b, scale);
p.Dispose();
b.Dispose();
}
public override void DrawCollider()
{
float radiusScale = WorldScale.MaxComponent();
CRenderer.Instance.ActiveScene.DebugRenderer.DrawSphere(WorldPosition, radiusScale * Radius, Color.Green.ToColor4(), 0.0f, EDebugDrawCommandFlags.Wireframe);
}
private void UpdateScaledShape()
{
m_scaledShape.Radius = Math.Abs(WorldScale.MaxComponent()) * Radius;
Owner.MarkStaticColliderDirty();
}
private void btnOrigin_Click(object sender, EventArgs e)
{
_worldScale = CreateWorldScale(_worldScale.Factor, new RealPoint());
picWorld.Invalidate();
}
/// <summary>
/// Peint le mouvement en indiquant les différentes positions d'approche, la meilleure, et l'élément concerné
/// </summary>
/// <param name="g">Graphique sur lequel peindre</param>
/// <param name="scale">Echelle de conversion</param>
public void Paint(Graphics g, WorldScale scale)
{
Font font = new Font("Calibri", 8);
Pen penRedDot = new Pen(Color.Red);
penRedDot.DashStyle = DashStyle.Dot;
Pen penBlackDot = new Pen(Color.Black);
penBlackDot.DashStyle = DashStyle.Dot;
Pen penTransparent = new Pen(Color.FromArgb(40, Color.Black));
Brush brushTransparent = new SolidBrush(Color.FromArgb(40, Color.Black));
Point point;
if (Element != null)
{
Point pointElement = scale.RealToScreenPosition(Element.Position);
if (GlobalCost != double.MaxValue && !double.IsInfinity(GlobalCost))
{
Point pointProche = scale.RealToScreenPosition(BestPosition.Coordinates);
foreach (Position p in Positions)
{
point = scale.RealToScreenPosition(p.Coordinates);
if (point != pointProche)
{
g.FillEllipse(Brushes.Red, point.X - 2, point.Y - 2, 4, 4);
g.DrawLine(penRedDot, point, pointElement);
}
}
g.FillEllipse(Brushes.White, pointProche.X - 2, pointProche.Y - 2, 4, 4);
g.DrawLine(Pens.White, pointProche, pointElement);
g.DrawString((GlobalCost / DisplayCostFactor).ToString("0.00"), font, Brushes.White, pointProche);
}
else
{
if (!IsCorrectColor())
{
foreach (Position p in Positions)
{
point = scale.RealToScreenPosition(p.Coordinates);
g.FillEllipse(brushTransparent, point.X - 2, point.Y - 2, 4, 4);
g.DrawLine(penTransparent, point, pointElement);
}
}
else
{
foreach (Position p in Positions)
{
point = scale.RealToScreenPosition(p.Coordinates);
g.FillEllipse(Brushes.Black, point.X - 2, point.Y - 2, 4, 4);
g.DrawLine(penBlackDot, point, pointElement);
}
}
}
}
brushTransparent.Dispose();
penTransparent.Dispose();
penBlackDot.Dispose();
penRedDot.Dispose();
font.Dispose();
}
private void ZoomMinus()
{
_worldScale = CreateWorldScale(_worldScale.Factor * (1 / 0.97), GetCenter());
picWorld.Invalidate();
}
private void ZoomPlus()
{
_worldScale = CreateWorldScale(_worldScale.Factor * 0.97, GetCenter());
picWorld.Invalidate();
}
public override void Paint(Graphics g, WorldScale scale)
{
new Circle(new RealPoint(Position.X, Position.Y), _hoverRadius).Paint(g, Pens.Black, _enable ? Brushes.LimeGreen : Brushes.WhiteSmoke, scale);
}
private void MainForm_Load(object sender, EventArgs e)
{
_worldScale = new WorldScale(1, picWorld.Width / 2, picWorld.Height / 2);
}
/// <summary> /// Peint l'élément sur le Graphic donné à l'échelle donnée /// </summary> /// <param name="g">Graphic sur lequel peindre</param> /// <param name="scale">Echelle de peinture</param> public abstract void Paint(Graphics g, WorldScale scale);
