public void Draw(Renderer cam)
{
for (int i = 0; i < pt1List.Count; i++)
{
GLUtility.DrawLine(new GLPen(this.color, width), pt1List[i], pt2List[i]);
}
}
public void Draw(Renderer cam)
{
if (mean != null && covariance != null)
{
List <List <Vector2> > meanCpy = new List <List <Vector2> >(mean);
foreach (List <Vector2> list in meanCpy)
{
if (drawMean)
{
for (float i = width; i >= 0; i -= 0.1f)
{
GLUtility.DrawDiamond(new GLPen(meanColor, penThickness), list[0], i);
}
}
if (drawCov)
{
try
{
GLUtility.DrawLineLoop(new GLPen(covColor, penThickness), covariance[meanCpy.IndexOf(list)].ToArray());
}
catch
{ }
}
}
}
}
protected void plane(Vector3 horizontal, Vector3 vertical, bool isDragging, bool isHovering, Color color)
{
if (isDragging && this.isSnapping)
{
GL.Color(new Color(0f, 0f, 0f, 0.5f));
float num = DevkitSelectionToolOptions.instance.snapPosition / base.transform.localScale.x;
int num2 = Mathf.Max(2, Mathf.CeilToInt(2f / num));
Vector3 vector = horizontal * num * (float)num2;
Vector3 vector2 = vertical * num * (float)num2;
for (int i = -num2; i <= num2; i++)
{
Vector3 vector3 = horizontal * num * (float)i;
GLUtility.line(vector3 - vector2, vector3 + vector2);
}
for (int j = -num2; j <= num2; j++)
{
Vector3 vector4 = vertical * num * (float)j;
GLUtility.line(vector4 - vector, vector4 + vector);
}
}
GL.Color((!isDragging) ? ((!isHovering) ? color : Color.yellow) : Color.white);
Vector3 vector5 = horizontal * 0.25f;
Vector3 vector6 = vertical * 0.25f;
GLUtility.line(vector5, vector5 + vector6);
GLUtility.line(vector6, vector6 + vector5);
}
protected override void BackendDraw(ReadOnlySpan <Vertex> vertices, Sampler sampler)
{
Rectangle viewport = new Rectangle();
glGetIntegerv(GL_VIEWPORT, ref viewport.X);
_transform.M11 = 2f / viewport.Width;
_transform.M22 = -2f / viewport.Height;
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, vertices, GL_DYNAMIC_DRAW);
GLUtility.CheckErrors(nameof(glBufferData));
glBindVertexArray(_vertexArray);
glUseProgram(_program);
glUniformMatrix4fv(_vertTranformLocation, 1, false, ref _transform.M11);
GLUtility.CheckErrors(nameof(glUniformMatrix4fv));
glActiveTexture(GL_TEXTURE0);
if (sampler is Texture texture)
{
glBindTexture(GL_TEXTURE_2D, (uint)texture.Handle);
}
glUniform1i(_fragSamplerLocation, 0);
GLUtility.CheckErrors(nameof(glUniform1ui));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer);
glDrawElements(GL_TRIANGLES, (vertices.Length / 4) * 6, GL_UNSIGNED_SHORT, IntPtr.Zero);
GLUtility.CheckErrors(nameof(glDrawElements));
}
internal GLGraphicsContext(Func <string, IntPtr> getProcAddress, int maxVertices)
: base(maxVertices)
{
glInit(getProcAddress, 4, 0);
glClearColor(_clearColor.R, _clearColor.G, _clearColor.B, _clearColor.A);
_vertexBuffer = glGenBuffer();
glBindBuffer(GL_ARRAY_BUFFER, _vertexBuffer);
glBufferData(GL_ARRAY_BUFFER, Vertex.SizeInBytes * maxVertices, IntPtr.Zero, GL_DYNAMIC_DRAW);
GLUtility.CheckErrors(nameof(glBufferData));
_vertexArray = glGenVertexArray();
glBindVertexArray(_vertexArray);
glVertexAttribPointer(0, 3, GL_FLOAT, false, Vertex.SizeInBytes, IntPtr.Zero);
GLUtility.CheckErrors(nameof(glVertexAttribPointer));
glVertexAttribPointer(1, 4, GL_FLOAT, false, Vertex.SizeInBytes, (IntPtr)Marshal.SizeOf <Vector3>());
GLUtility.CheckErrors(nameof(glVertexAttribPointer));
glVertexAttribPointer(2, 2, GL_FLOAT, false, Vertex.SizeInBytes, (IntPtr)(Marshal.SizeOf <Vector3>() + Marshal.SizeOf <Vector4>()));
GLUtility.CheckErrors(nameof(glVertexAttribPointer));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glEnableVertexAttribArray(2);
ushort[] indices = new ushort[1024 * 6];
for (ushort i = 0, vertex = 0; i < indices.Length; i += 6, vertex += 4)
{
indices[i] = vertex;
indices[i + 1] = (ushort)(vertex + 1);
indices[i + 2] = (ushort)(vertex + 3);
indices[i + 3] = (ushort)(vertex + 1);
indices[i + 4] = (ushort)(vertex + 2);
indices[i + 5] = (ushort)(vertex + 3);
}
_indexBuffer = glGenBuffer();
glBindBuffer(GL_ARRAY_BUFFER, _indexBuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(ushort) * indices.Length, indices, GL_STATIC_DRAW);
GLUtility.CheckErrors(nameof(glBufferData));
uint vertexShader = GLUtility.CreateAndCompileShader(GL_VERTEX_SHADER, VertexShaderCode);
uint fragmentShader = GLUtility.CreateAndCompileShader(GL_FRAGMENT_SHADER, FragmentShaderCode);
_program = GLUtility.CreateAndLinkProgram(vertexShader, fragmentShader);
_vertTranformLocation = glGetUniformLocation(_program, "vertTransform");
_fragSamplerLocation = glGetUniformLocation(_program, "fragSampler");
glDisable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CW);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glActiveTexture(GL_TEXTURE0);
}
public void DrawSimulationResults(ITreeNode n, GLPen p)
{
for (int i = 0; i < n.SimulationPoints.Count - 1; i++)
{
GLUtility.DrawLine(p, n.SimulationPoints[i], n.SimulationPoints[i + 1]);
}
}
private void drawRect(int i, int j)
{
double x1, y1, x2, y2, x3, y3, x4, y4;
float heightVal = (float)(grid.GetCellByIdx(i, j));
if (heightVal >= .1)
{
grid.GetReals(i, j, out x1, out y1);
grid.GetReals(i + 1, j, out x2, out y2);
grid.GetReals(i, j + 1, out x3, out y3);
grid.GetReals(i + 1, j + 1, out x4, out y4);
//pen = new GLPen(ColorFromHeight(heightVal), 1f);
//pen.GLApplyPen();
//Gl.glVertex3f((float)x, (float)y, heightVal);
//Gl.glVertex3f((float)x, (float)y, 0);
GLUtility.Draw3DRectangle(new GLPen(ColorFromHeight(heightVal), 1f),
new Vector3(x1, y1, heightVal),
new Vector3(x2, y2, grid.GetCellByIdx(i + 1, j)),
new Vector3(x3, y3, grid.GetCellByIdx(i, j + 1)),
new Vector3(x4, y4, grid.GetCellByIdx(i + 1, j + 1)));
}
}
public void Draw()
{
GLUtility.GoToTransform((float)location.x, (float)location.y);
GLUtility.GoToTransform((float)location.yaw);
GLUtility.FillCone(renderColor, opacity, new PointF(0, 0), (float)range, (float)-fov / 2.0f, (float)fov / 2.0f);
GLUtility.ComeBackFromTransform();
GLUtility.ComeBackFromTransform();
}
public void Draw(Renderer cam)
{
DrawNodeRecrusive(root);
if (goal != null)
{
GLUtility.DrawCircle(goalPen, goal.Point, .1f);
DrawBackFromParent(goal);
}
}
private static void handleGLRender()
{
foreach (DevkitHierarchyVolume devkitHierarchyVolume in PlayerClipVolumeSystem.volumes)
{
if (devkitHierarchyVolume.visibilityGroupOverride.isVisible)
{
GLUtility.matrix = devkitHierarchyVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(devkitHierarchyVolume.isSelected, devkitHierarchyVolume.visibilityGroupOverride);
}
}
}
public void Draw(Renderer r)
{
if (isActive)
{
GLUtility.DrawRectangle(new GLPen(Color.Red, 1.0f),
new RectangleF((float)selectionRectangle.x,
(float)selectionRectangle.y,
(float)selectionRectangle.width,
(float)selectionRectangle.height));
}
}
private void DrawChildren(SimpleTreeNode <Vector2> node)
{
foreach (SimpleTreeNode <Vector2> child in node.Children)
{
Vector2[] treeLine = new Vector2[2];
treeLine[0] = node.Value;
treeLine[1] = child.Value;
GLUtility.DrawLines(new GLPen(Color.Blue, 1.0f), treeLine);
DrawChildren(child);
}
}
public void Draw(Renderer cam)
{
Vector2 bodyPnt = new Vector2(pose.x, pose.y);
Vector2 bodyHeading = new Vector2(bodyPnt.X + Math.Cos(pose.yaw), bodyPnt.Y + Math.Sin(pose.yaw));
GLUtility.DrawLineLoop(new GLPen(color, drawLineWidth), bodyPlygn.ToArray());
// Draw heading
GLUtility.DrawLine(new GLPen(Color.Red, drawLineWidth), bodyPnt, bodyHeading);
// Draw the name
GLUtility.DrawString(name, Color.Black, new PointF((float)bodyPnt.X, (float)bodyPnt.Y));
}
private static void handleGLRender()
{
if (!WaterSystem.waterVisibilityGroup.isVisible)
{
return;
}
foreach (WaterVolume waterVolume in WaterSystem.volumes)
{
GLUtility.matrix = waterVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(waterVolume.isSelected, WaterSystem.waterVisibilityGroup);
}
}
/// <summary>
/// Draw the sketch pixels
/// </summary>
/// <param name="r"></param>
#region sketch drawing code
public void Draw(Renderer r)
{
if (pixelListWorld.Count > 0)
{
foreach (Vector4 v in pixelListWorld)
{
PointF pixelPointWorld = new PointF((float)v.X, (float)v.Y);
pixelRect = new RectangleF((float)pixelPointWorld.X - pixelWidth / 2, (float)pixelPointWorld.Y - pixelWidth / 2, pixelWidth, pixelWidth);
GLUtility.FillRectangle(pen.color, pixelRect);
}
}
}
private static void handleGLRender()
{
if (!DeadzoneSystem.deadzoneVisibilityGroup.isVisible)
{
return;
}
foreach (DeadzoneVolume deadzoneVolume in DeadzoneSystem.volumes)
{
GLUtility.matrix = deadzoneVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(deadzoneVolume.isSelected, DeadzoneSystem.deadzoneVisibilityGroup);
}
}
// Token: 0x060008D5 RID: 2261 RVA: 0x0004DCA8 File Offset: 0x0004C0A8
private static void handleGLRender()
{
if (!AmbianceSystem.ambianceVisibilityGroup.isVisible)
{
return;
}
foreach (AmbianceVolume ambianceVolume in AmbianceSystem.volumes)
{
GLUtility.matrix = ambianceVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(ambianceVolume.isSelected, AmbianceSystem.ambianceVisibilityGroup);
}
}
private static void handleGLRender()
{
if (!KillVolumeSystem.killVisibilityGroup.isVisible)
{
return;
}
foreach (KillVolume killVolume in KillVolumeSystem.volumes)
{
GLUtility.matrix = killVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(killVolume.isSelected, KillVolumeSystem.killVisibilityGroup);
}
}
// Token: 0x060009C6 RID: 2502 RVA: 0x000505A0 File Offset: 0x0004E9A0
private static void handleGLRender()
{
if (!EffectVolumeSystem.effectVisibilityGroup.isVisible)
{
return;
}
foreach (EffectVolume effectVolume in EffectVolumeSystem.volumes)
{
GLUtility.matrix = effectVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(effectVolume.isSelected, EffectVolumeSystem.effectVisibilityGroup);
}
}
private static void handleGLRender()
{
if (!LandscapeHoleSystem.holeVisibilityGroup.isVisible)
{
return;
}
foreach (LandscapeHoleVolume landscapeHoleVolume in LandscapeHoleSystem.volumes)
{
GLUtility.matrix = landscapeHoleVolume.transform.localToWorldMatrix;
GLUtility.volumeHelper(landscapeHoleVolume.isSelected, LandscapeHoleSystem.holeVisibilityGroup);
}
}
protected void handleGLRender()
{
GLUtility.LINE_FLAT_COLOR.SetPass(0);
GL.Begin(1);
GLUtility.matrix = base.transform.localToWorldMatrix;
this.arrow(new Vector3(this.inversion.x, 0f, 0f), this.drag == DevkitScaleHandle.EDevkitScaleHandleSelection.X, this.hover == DevkitScaleHandle.EDevkitScaleHandleSelection.X, Color.red);
this.arrow(new Vector3(0f, this.inversion.y, 0f), this.drag == DevkitScaleHandle.EDevkitScaleHandleSelection.Y, this.hover == DevkitScaleHandle.EDevkitScaleHandleSelection.Y, Color.green);
this.arrow(new Vector3(0f, 0f, this.inversion.z), this.drag == DevkitScaleHandle.EDevkitScaleHandleSelection.Z, this.hover == DevkitScaleHandle.EDevkitScaleHandleSelection.Z, Color.blue);
GL.Color((this.drag != DevkitScaleHandle.EDevkitScaleHandleSelection.UNIFORM) ? ((this.hover != DevkitScaleHandle.EDevkitScaleHandleSelection.UNIFORM) ? Color.white : Color.yellow) : Color.white);
GLUtility.boxWireframe(this.inversion * 0.125f, new Vector3(0.25f, 0.25f, 0.25f));
GL.End();
}
public void Draw(Renderer cam)
{
/*Gl.glPushMatrix();
* Gl.glTranslatef(0f, 0f, 0.0f);
* Gl.glScalef(50, 50, 0.0f);
* Gl.glRotatef(0f, 0.0f, 0.0f, 1.0f);
* Gl.glBindTexture(Gl.GL_TEXTURE_2D, textureID);
* Gl.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
* Gl.glCallList(textureGeom);
* Gl.glPopMatrix();*/
GLUtility.FillTexturedRectangle(textureID, new RectangleF(0f, 0f, 300f, 400f));
}
public void Draw(Renderer cam)
{
Vector2 lastPoint = currentPoints.Count > 0 ? currentPoints.ElementAt <Vector2>(0) : new Vector2();
foreach (Vector2 p in currentPoints)
{
GLUtility.DrawCircle(new GLPen(Color.Chartreuse, 1.0f), new PointF((float)p.X, (float)p.Y), 0.25f);
if (!p.Equals(currentPoints.ElementAt <Vector2>(0)))
{
GLUtility.DrawLine(new GLPen(Color.Chartreuse, 1.0f), lastPoint, p);
lastPoint = p;
}
}
}
protected void handleGLRender()
{
GLUtility.LINE_FLAT_COLOR.SetPass(0);
GL.Begin(1);
GLUtility.matrix = base.transform.localToWorldMatrix;
this.plane(new Vector3(0f, this.inversion.y, 0f), new Vector3(0f, 0f, this.inversion.z), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_X, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_X, Color.red);
this.plane(new Vector3(this.inversion.x, 0f, 0f), new Vector3(0f, 0f, this.inversion.z), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_Y, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_Y, Color.green);
this.plane(new Vector3(this.inversion.x, 0f, 0f), new Vector3(0f, this.inversion.y, 0f), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_Z, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.PLANE_Z, Color.blue);
GLUtility.matrix = Matrix4x4.TRS(base.transform.position, Quaternion.identity, base.transform.localScale);
this.arrow(base.transform.right * this.inversion.x, GLUtility.getDirectionFromViewToArrow(MainCamera.instance.transform.position, base.transform.position, base.transform.right * this.inversion.x), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_X, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_X, Color.red);
this.arrow(base.transform.up * this.inversion.y, GLUtility.getDirectionFromViewToArrow(MainCamera.instance.transform.position, base.transform.position, base.transform.up * this.inversion.y), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_Y, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_Y, Color.green);
this.arrow(base.transform.forward * this.inversion.z, GLUtility.getDirectionFromViewToArrow(MainCamera.instance.transform.position, base.transform.position, base.transform.forward * this.inversion.z), this.drag == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_Z, this.hover == DevkitPositionHandle.EDevkitPositionHandleSelection.AXIS_Z, Color.blue);
GL.End();
}
public void Draw(Renderer r)
{
float lineWidth = selected ? 2.0f : 1.0f;
PointF bodyPnt = new PointF(x, y);
PointF bodyHeading = new PointF(bodyPnt.X + (float)Math.Cos(heading), bodyPnt.Y + (float)Math.Sin(heading));
GLUtility.DrawLineLoop(new GLPen(color, lineWidth), bodyPlygn.ToArray());
GLUtility.FillTriangle(color, 0.6f, bodyPlygn[0].ToPointF(), bodyPlygn[1].ToPointF(), bodyPlygn[2].ToPointF());
GLUtility.FillTriangle(color, 0.6f, bodyPlygn[2].ToPointF(), bodyPlygn[3].ToPointF(), bodyPlygn[0].ToPointF());
// Draw heading
//GLUtility.DrawLine(new GLPen(Color.Red, lineWidth), Vector2.FromPointF(bodyPnt), Vector2.FromPointF(bodyHeading));
GLUtility.DrawLine(new GLPen(Color.Red, lineWidth), bodyPnt, bodyHeading);
//// Draw the name
//if (modeString.Equals(""))
// GLUtility.DrawString(MythName + ": " + name, Color.Black, bodyPnt);
//else if (modeQualifier.Equals(""))
// GLUtility.DrawString(name + ": " + modeString, Color.Black, bodyPnt);
//else// if (defaultRenderer != null)
//{
// try
// {
// GLUtility.DrawStringMultiLine(name + ": " + modeString + '\n' + "NOTE: " + modeQualifier, Color.Black, bodyPnt, r.CurrentCamera);
// }
// catch { GLUtility.DrawString(name + ": " + modeString, Color.Black, bodyPnt); }
//}//else
//// GLUtility.DrawString(name + ": " + modeString + "(NOTE: " + modeQualifier + ")", Color.Black, bodyPnt);
GLUtility.DrawString(name, Color.Black, bodyPnt);
DrawFlagLine(x, y, color);
if (drawCameraView && IsSelected)
{
PointF p1 = bodyPnt;
PointF p2 = new PointF(bodyPnt.X + 5 * (float)Math.Cos(heading - 0.5 * (cameraFOVangle * Math.PI / 180)), bodyPnt.Y + 5 * (float)Math.Sin(heading - 0.5 * (cameraFOVangle * Math.PI / 180)));
PointF p3 = new PointF(bodyPnt.X + 5 * (float)Math.Cos(heading - 0.167 * (cameraFOVangle * Math.PI / 180)), bodyPnt.Y + 5 * (float)Math.Sin(heading - 0.167 * (cameraFOVangle * Math.PI / 180)));
PointF p4 = new PointF(bodyPnt.X + 5 * (float)Math.Cos(heading + 0.167 * (cameraFOVangle * Math.PI / 180)), bodyPnt.Y + 5 * (float)Math.Sin(heading + 0.167 * (cameraFOVangle * Math.PI / 180)));
PointF p5 = new PointF(bodyPnt.X + 5 * (float)Math.Cos(heading + 0.5 * (cameraFOVangle * Math.PI / 180)), bodyPnt.Y + 5 * (float)Math.Sin(heading + 0.5 * (cameraFOVangle * Math.PI / 180)));
GLUtility.FillTriangle(color, 0.1f, p1, p2, p3);
GLUtility.FillTriangle(color, 0.1f, p1, p3, p4);
GLUtility.FillTriangle(color, 0.1f, p1, p4, p5);
//GLUtility.FillTriangle(Color.BlueViolet, 0.3f, p1, p2, p3);
//GLUtility.FillTriangle(Color.Blue, 0.3f, p1, p3, p4);
//GLUtility.FillTriangle(Color.Turquoise, 0.3f, p1, p4, p5);
}
}
public void Draw(Renderer cam)
{
//Console.WriteLine("trying to draw notepoint");
PointF npCenter = new PointF((float)x, (float)y);
GLUtility.DrawCircle(new GLPen(color, 0.25f), npCenter, .1f);
GLUtility.DrawCircle(new GLPen(color, 0.25f), npCenter, .25f);
GLUtility.DrawString(comments, Color.Black, npCenter);
if (name != null)
{
GLUtility.DrawString(name, Color.Black, npCenter);
}
}
public void DrawNodeRecrusive(ITreeNode n)
{
if (n == null)
{
return;
}
//draw a link from this node to each of its children
DrawSimulationResults(n, edgePen);
foreach (ITreeNode c in n.Children)
{
GLUtility.DrawCircle(circPen, n.Point, .10f);
//GLUtility.DrawLine(edgePen, n.Point, c.Point);
DrawNodeRecrusive(c);
}
}
public void Draw(Renderer cam)
{
if (points == null)
{
return;
}
List <Vector2> copy = new List <Vector2>(points);
lock (this.drawLock)
{
foreach (Vector2 v in copy)
{
GLUtility.DrawCross(new GLPen(color, 1.0f), v, size);
}
}
}
public void Draw(Renderer cam)
{
if (poses.Count == 0)
{
return;
}
lock (poses)
{
RobotPose lastPose = poses[0];
foreach (RobotPose p in poses)
{
GLUtility.DrawCross(pen, p.ToVector2(), .2f);
//GLUtility.DrawLine(pen, lastPose.ToVector2(), p.ToVector2());
lastPose = p;
}
if (poses[poses.Count - 1].covariance[0, 0] != 0)
{
//calculate the error ellipse
Matrix cov = new Matrix(2, 2);
cov[0, 0] = poses[poses.Count - 1].covariance[0, 0];
cov[0, 1] = poses[poses.Count - 1].covariance[0, 1];
cov[1, 0] = poses[poses.Count - 1].covariance[1, 0];
cov[1, 1] = poses[poses.Count - 1].covariance[1, 1];
double theta = .5 * Math.Atan2((-2 * cov[0, 1]), (cov[0, 0] - cov[1, 1]));
if (Double.IsNaN(theta))
{
theta = 0;
}
double sigu2 = (cov[0, 0] * Math.Sin(theta) * Math.Sin(theta)) +
(2 * cov[0, 1] * Math.Sin(theta) * Math.Cos(theta)) +
(cov[1, 1] * Math.Cos(theta) * Math.Cos(theta));
double sigv2 = (cov[0, 0] * Math.Cos(theta) * Math.Cos(theta)) +
(2 * cov[0, 1] * Math.Sin(theta) * Math.Cos(theta)) +
(cov[1, 1] * Math.Sin(theta) * Math.Sin(theta));
GLUtility.GoToTransformXYZ((float)poses[poses.Count - 1].x, (float)poses[poses.Count - 1].y, 0);
GLUtility.GoToTransformYPR((float)theta, 0, 0);
GLUtility.DrawEllipse(ellipsePen, new RectangleF((float)-sigu2 / 2, (float)-sigv2 / 2, (float)sigu2, (float)sigv2));
GLUtility.ComeBackFromTransform();
GLUtility.ComeBackFromTransform();
}
}
}
// Token: 0x06000B05 RID: 2821 RVA: 0x000579C0 File Offset: 0x00055DC0
protected void circle(Vector3 horizontalAxis, Vector3 verticalAxis, bool isDragging, bool isHovering, Color color)
{
if (isDragging && this.isSnapping)
{
GL.Color(new Color(0f, 0f, 0f, 0.5f));
float num = this.angleOrigin + this.displayAngle;
float num2 = 0.0174532924f * DevkitSelectionToolOptions.instance.snapRotation;
int num3 = Mathf.Max(1, Mathf.CeilToInt(1.57079637f / num2));
for (int i = -num3; i <= num3; i++)
{
float f = num + (float)i * num2;
float d = Mathf.Cos(f);
float d2 = Mathf.Sin(f);
GLUtility.line(horizontalAxis * d * 0.9f + verticalAxis * d2 * 0.9f, horizontalAxis * d * 1.1f + verticalAxis * d2 * 1.1f);
}
}
GL.Color((!isDragging) ? ((!isHovering) ? color : Color.yellow) : Color.white);
float num4 = 6.28318548f;
float num5 = 0f;
float num6 = num4 / 32f;
Vector3 v = GLUtility.matrix.MultiplyPoint3x4(horizontalAxis);
while (num5 < num4)
{
num5 += num6;
float f2 = Mathf.Min(num5, num4);
float d3 = Mathf.Cos(f2);
float d4 = Mathf.Sin(f2);
Vector3 vector = GLUtility.matrix.MultiplyPoint3x4(horizontalAxis * d3 + verticalAxis * d4);
GL.Vertex(v);
GL.Vertex(vector);
v = vector;
}
if (isDragging)
{
float f3 = this.angleOrigin;
float d5 = Mathf.Cos(f3) * 1.5f;
float d6 = Mathf.Sin(f3) * 1.5f;
Vector3 end = horizontalAxis * d5 + verticalAxis * d6;
GLUtility.line(Vector3.zero, end);
float f4 = this.angleOrigin + this.displayAngle;
float d7 = Mathf.Cos(f4) * 1.5f;
float d8 = Mathf.Sin(f4) * 1.5f;
Vector3 end2 = horizontalAxis * d7 + verticalAxis * d8;
GLUtility.line(Vector3.zero, end2);
}
}
