private void timer1_Tick(object sender, EventArgs e)
{
UpdateTooltip();
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.ClearColor(204 / 255.0F, 1.0f, 1.0f, 1.0f);
Matrix4 model = rotator;
viewModel = model * Matrix4.LookAt(FarOffset / 10.0f, FarOffset / 10.0f, FarOffset / 10.0f, 0, 0, 0, 0, 1, 0);
Matrix4 projection = Matrix4.CreatePerspectiveFieldOfView((float)(Math.PI / 2.0), glControl1.Width / (float)glControl1.Height, 0.01f, 1000.0f);
mult = viewModel * projection;
basic.Use();
//model *= Matrix4.CreateTranslation(FarOffset/10.0f, FarOffset/10.0f, FarOffset/10.0f);
GL.UniformMatrix4(basic.shaderMVLocation_, false, ref viewModel);
GL.UniformMatrix4(basic.shaderPLocation_, false, ref projection);
if (wire)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
GL.CullFace(CullFaceMode.FrontAndBack);
}
else
{
GL.PolygonMode(MaterialFace.Front, PolygonMode.Fill);
GL.CullFace(CullFaceMode.Back);
}
GL.Enable(EnableCap.DepthTest);
MainMesh_.Bind(basic);
MainMesh_.Render();
GL.Disable(EnableCap.DepthTest);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref mult);
GL.UseProgram(0);
GL.Begin(PrimitiveType.Lines);
GL.Color4(Color.Blue);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, FarOffset / 20.0f);
GL.Color4(Color.GreenYellow);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, FarOffset / 20.0f, 0);
GL.Color4(Color.Red);
GL.Vertex3(0, 0, 0);
GL.Vertex3(FarOffset / 20.0f, 0, 0);
GL.End();
GL.Flush();
glControl1.SwapBuffers();
if ((int)(OcclusionMap.AorResultTotal * 0.99f) < OcclusionMap.AorResult)
{
toolStripProgressBar1.Value = 0;
}
else
{
toolStripProgressBar1.Maximum = OcclusionMap.AorResultTotal;
toolStripProgressBar1.Value = OcclusionMap.AorResult;
}
if (Log.updated && textBox1.Visible)
{
Log.updated = false;
textBox1.Text = Log.Get();
}
}
// render all committed lines
public static void Render()
{
// half width of line, in pixels
const float half_width = 2.0f;
// store stuff
Vector3 a; // shortcut to line start
Vector3 b; // shortcut to line end
Vector3 diff; // vector from a to b
Vector3 v; // perpendicular vector
Vector3 Va; // perpendicular vector scaled by start distance
Vector3 Vb; // perpendicular vector scaled by end distance
Vector3 p0; // bottom left point
Vector3 p1; // bottom right point
Vector3 p2; // top left point
Vector3 p3; // top right point
// get camera
var cam = PlanetariumCamera.Camera;
Vector3 cam_pos = cam.transform.position;
Vector3 cam_up = cam.transform.up;
Vector3 cam_right = cam.transform.right;
// enable the material
mat.SetPass(0);
// start rendering lines
GL.Begin(GL.TRIANGLES);
// projection factor
// note: for some reasons, this result in a screen size 20% smaller than it should be
float k = half_width * 2.0f * Mathf.Tan(cam.fieldOfView * 0.5f * Mathf.Deg2Rad) / Screen.height;
// for each line we got
foreach (Line_data line in lines)
{
// shortcuts
a = line.a;
b = line.b;
// set the color
GL.Color(line.color);
// find vector perpendicular to look and line, in world space
diff = b - a;
v = (cam_right * -Vector3.Dot(diff, cam_up) + cam_up * Vector3.Dot(diff, cam_right)).normalized * k;
// scale perpendicular vector to have exact pixel length
Va = v * (a - cam_pos).magnitude;
Vb = v * (b - cam_pos).magnitude;
// calculate quand points
p0 = a - Va;
p1 = a + Va;
p2 = b - Vb;
p3 = b + Vb;
// bottom left
GL.TexCoord2(-1.0f, 0.0f);
GL.Vertex(p0);
// bottom right
GL.TexCoord2(1.0f, 0.0f);
GL.Vertex(p1);
// top right
GL.TexCoord2(1.0f, 0.0f);
GL.Vertex(p3);
// top right
GL.TexCoord2(1.0f, 0.0f);
GL.Vertex(p3);
// top left
GL.TexCoord2(-1.0f, 0.0f);
GL.Vertex(p2);
// bottom left
GL.TexCoord2(-1.0f, 0.0f);
GL.Vertex(p0);
}
// stop rendering triangles
GL.End();
// clear all committed lines
lines.Clear();
}
private void Render(object sender, PaintEventArgs e)
{
if (!loaded)
{
return;
}
MakeCurrent();
SetupViewport();
//double size = Scene.Size();
double size = Scene.Max.Y - Scene.Min.Y;
double SceneYOffset = -size / 2f;
double defaultzoom = (double)Math.Sqrt(Math.Pow(TableRadius, 2) + Math.Pow(TableHeight, 2));
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.LoadIdentity();
var aspect_ratio = Width / (double)Height;
var projection = Matrix4d.CreatePerspectiveFieldOfView(
MathHelper.PiOver4, double.Parse(aspect_ratio.ToString()), 1f, 1024);
// var modelview = Matrix4d.LookAt(0, size / 2 , - DragZoom * defaultzoom * 2f,
// 0,TableHeight/2, 0, 0, size, 0);
var viewHeight = (TableHeight / 2.50) + SceneYOffset;
var modelview = Matrix4d.LookAt(0, viewHeight, Math.Max(0.00000001f, -(-Drag.Zoom * defaultzoom * 1.5f)),
0, viewHeight, 0, 0, size, 0);
GL.MatrixMode(MatrixMode.Projection);
if (Projection)
{
GL.LoadMatrix(ref projection);
}
else
{
GL.LoadIdentity();
double x = Math.Max(TableRadius * 2, TableHeight) * Drag.Zoom / 2.0;
double y = x * ((double)Height / (double)Width);
GL.Ortho(-x, x, -y, y, 0.0, 10000.0);
}
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
#region LIGHT
//if (Lightning)
{
float[] lightPos = new float[] { (float)(-TableRadius * 2f), (float)TableRadius * 2f, (float)TableHeight * 2f, 1.0f };
GL.PointSize(5);
GL.Disable(EnableCap.Lighting);
GL.Begin(PrimitiveType.Points);
GL.Color3(Color.Yellow);
GL.Vertex3(lightPos);
GL.End();
GL.PointSize(1);
float[] light_ambient = { 0.2f, 0.2f, 0.2f, 1.0f };
float[] light_diffuse = { 1.0f, 1.0f, 1.0f, 1.0f };
float[] light_specular = { 1.0f, 1.0f, 1.0f, 1.0f };
float[] spotdirection = { 0.5f, -1.0f, -1.0f };
GL.Light(LightName.Light0, LightParameter.Ambient, light_ambient);
GL.Light(LightName.Light0, LightParameter.Diffuse, light_diffuse);
GL.Light(LightName.Light0, LightParameter.Specular, light_specular);
GL.Enable(EnableCap.Lighting);
GL.Light(LightName.Light0, LightParameter.Position, lightPos);
GL.Enable(EnableCap.Light0);
//GL.Light(LightName.Light0, LightParameter.SpotDirection, spotdirection);
//GL.Light(LightName.Light0, LightParameter.SpotCutoff, 20);
}
#endregion
GL.Translate(Drag.Pane.X, -Drag.Pane.Y, 0);
Matrix4d m = MatrixFromYawPitchRoll(-Math.PI * Drag.Angle.X / 360.0f, -Math.PI * Drag.Angle.Y / 360.0f, 0);
GL.MultMatrix(ref m);
// Model space
#region Box/Axis
GL.Disable(EnableCap.Lighting);
Vector3d scannerCenter = new Vector3d(0, -size / 2f, 0);
Axis(new Vector3d(scannerCenter.X - TableRadius, scannerCenter.Y, scannerCenter.Z + TableRadius), 10);
#endregion ;
GL.Translate(0, SceneYOffset, 0);
if (BoundingBox)
{
DrawBoundingBox(Color.Red, Scene.Min, Scene.Max);
}
if (Lightning)
{
GL.Enable(EnableCap.Lighting);
GL.ColorMaterial(MaterialFace.FrontAndBack, ColorMaterialParameter.AmbientAndDiffuse);
GL.Enable(EnableCap.ColorMaterial);
}
GL.PointSize(2);
GL.LineWidth(2);
RenderingContext context = RenderingContext.From(ViewerConfig);
context.ApplyFaceDefault();
GL.ShadeModel(Smooth ? ShadingModel.Smooth : ShadingModel.Flat);
GL.Enable(EnableCap.CullFace);
GL.CullFace(CullFaceMode.Back);
Scene.Render(ref context);
GL.Translate(0, -SceneYOffset, 0);
DrawScannerTable(scannerCenter);
SwapBuffers();
using (Graphics g = Graphics.FromHwnd(this.Handle))
{
using (SolidBrush bg = new SolidBrush(this.BackColor))
{
using (SolidBrush bf = new SolidBrush(this.ForeColor))
{
string text = String.Format("{0} points", Scene.GetNumVertices().ToString("N0"));
SizeF s = g.MeasureString(text, this.Font);
RectangleF rect = new RectangleF(0, 0, s.Width, s.Height);
rect.Y = this.Height - s.Height;
g.FillRectangle(bg, rect);
g.DrawString(text, this.Font, bf, rect.Location);
}
}
}
// this.Label.Text = String.Format("{0} points", Scene.GetNumVertices());
}
/// <summary>
/// <see cref="ISceneRenderer.Render"/>
/// </summary>
public void Render(ICameraController cam, Dictionary <Node, List <Mesh> > visibleMeshesByNode,
bool visibleSetChanged,
bool texturesChanged,
RenderFlags flags,
Renderer renderer)
{
GL.Disable(EnableCap.Texture2D);
GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);
GL.Enable(EnableCap.DepthTest);
if (flags.HasFlag(RenderFlags.Wireframe))
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
}
var tmp = InitposeMax.X - InitposeMin.X;
tmp = Math.Max(InitposeMax.Y - InitposeMin.Y, tmp);
tmp = Math.Max(InitposeMax.Z - InitposeMin.Z, tmp);
int logScale = (int)Math.Truncate(Math.Log10(tmp * 10 / 50)); // Up to 50units max size = 50m: keep scale (for smaller scenes).
float scale = 1;
for (int i = 0; i < logScale; i++)
{
scale = scale / 10;
}
Owner.Scale = scale;
if (cam != null)
{
// cam.SetPivot(Owner.Pivot * (float)scale); this does nothing (?) only makes controller dirty
}
var view = cam == null?Matrix4.LookAt(0, 10, 5, 0, 0, 0, 0, 1, 0) : cam.GetView();
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref view);
GL.Scale(scale, scale, scale);
Owner.MaterialMapper.BeginScene(renderer, flags.HasFlag(RenderFlags.UseSceneLights)); //here we switch on lights
if (flags.HasFlag(RenderFlags.ShowLightDirection)) //switch off for video??
{
var dir = new Vector3(1, 1, 0);
var mat = renderer.LightRotation;
Vector3.TransformNormal(ref dir, ref mat, out dir);
OverlayLightSource.DrawLightSource(dir);
}
// If textures changed, we may need to upload some of them to VRAM.
// it is important this happens here and not accidentially while
// compiling a displist.
if (texturesChanged)
{
UploadTextures();
}
UploadDynamicTextures();
GL.PushMatrix();
// Build and cache Gl displaylists and update only when the scene changes.
// when the scene is being animated, this changes each frame
var animated = Owner.SceneAnimator.IsAnimationActive;
if (visibleSetChanged || texturesChanged || flags != _lastFlags || (animated && (Owner.NewFrame) || wasAnimated))
{
int startList = 4; //we update only 4 animation displists
if (visibleSetChanged || texturesChanged || flags != _lastFlags)
{
startList = 0;
}
_lastFlags = flags;
// handle opaque geometry
for (int currDispList = startList; currDispList < _displayListCount; currDispList++)
{
if (_displayList[currDispList, 0] == 0)
{
_displayList[currDispList, 0] = GL.GenLists(1);
}
GL.NewList(_displayList[currDispList, 0], ListMode.Compile);
var needAlpha = RecursiveRender(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated, currDispList);
if (flags.HasFlag(RenderFlags.ShowSkeleton))
{
RecursiveRenderNoScale(Owner.Raw.RootNode, visibleMeshesByNode, flags, 1.0f / scale, animated, currDispList);
}
if (flags.HasFlag(RenderFlags.ShowNormals))
{
RecursiveRenderNormals(Owner.Raw.RootNode, visibleMeshesByNode, flags, 1.0f / scale, animated, Matrix4.Identity, currDispList);
}
GL.EndList();
if (needAlpha)
{
// handle semi-transparent geometry
if (_displayList[currDispList, 1] == 0)
{
_displayList[currDispList, 1] = GL.GenLists(1);
}
GL.NewList(_displayList[currDispList, 1], ListMode.Compile);
RecursiveRenderWithAlpha(Owner.Raw.RootNode, visibleMeshesByNode, flags, animated, currDispList);
GL.EndList();
}
else if (_displayList[currDispList, 1] != 0)
{
GL.DeleteLists(_displayList[currDispList, 1], 1);
_displayList[currDispList, 1] = 0;
}
}
}
Owner.NewFrame = false;
wasAnimated = animated;
/* display lists:
* 0: Background;
* 1: Else (always visible);
* 2: Foreground;
* 3: GreenScreen;
* 4: BackgroundAnimated;
* 5: ElseAnimated (always visible);
* 6: ForegroundAnimated;
* 7: GreenScreenAnimated;
* Animated - list is refreshed each frame
*/
switch (cam.GetScenePartMode())
{
case ScenePartMode.Background:
if (_displayList[0, 0] != 0)
{
GL.CallList(_displayList[0, 0]);
}
if (_displayList[4, 0] != 0)
{
GL.CallList(_displayList[4, 0]);
}
if (_displayList[0, 1] != 0)
{
GL.CallList(_displayList[0, 1]);
}
if (_displayList[4, 1] != 0)
{
GL.CallList(_displayList[4, 1]);
}
break;
case ScenePartMode.Foreground:
if (_displayList[2, 0] != 0)
{
GL.CallList(_displayList[2, 0]);
}
if (_displayList[6, 0] != 0)
{
GL.CallList(_displayList[6, 0]);
}
if (_displayList[2, 1] != 0)
{
GL.CallList(_displayList[2, 1]);
}
if (_displayList[6, 1] != 0)
{
GL.CallList(_displayList[6, 1]);
}
break;
case ScenePartMode.Others:
if (_displayList[1, 0] != 0)
{
GL.CallList(_displayList[1, 0]);
}
if (_displayList[5, 0] != 0)
{
GL.CallList(_displayList[5, 0]);
}
if (_displayList[1, 1] != 0)
{
GL.CallList(_displayList[1, 1]);
}
if (_displayList[5, 1] != 0)
{
GL.CallList(_displayList[5, 1]);
}
break;
case ScenePartMode.GreenScreen:
if (_displayList[3, 0] != 0)
{
GL.CallList(_displayList[3, 0]);
}
if (_displayList[7, 0] != 0)
{
GL.CallList(_displayList[7, 0]);
}
if (_displayList[3, 1] != 0)
{
GL.CallList(_displayList[3, 1]);
}
if (_displayList[7, 1] != 0)
{
GL.CallList(_displayList[7, 1]);
}
break;
case ScenePartMode.All:
for (int currDispList = 0; currDispList < _displayListCount; currDispList++)
{
if (_displayList[currDispList, 0] != 0)
{
GL.CallList(_displayList[currDispList, 0]);
}
if (_displayList[currDispList, 1] != 0)
{
GL.CallList(_displayList[currDispList, 1]);
}
}
break;
default: break; //at other modes we do not render anything
}
GL.PopMatrix();
// always switch back to FILL
Owner.MaterialMapper.EndScene(renderer);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Disable(EnableCap.DepthTest);
#if TEST
GL.Enable(EnableCap.ColorMaterial);
// TEST CODE to visualize mid point (pivot) and origin
GL.LoadMatrix(ref view);
GL.Begin(BeginMode.Lines);
GL.Vertex3((InitposeMin + InitposeMax) * 0.5f * (float)scale);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3(0, 0, 0);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3((InitposeMin + InitposeMax) * 0.5f * (float)scale);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.Vertex3(10, 10, 10);
GL.Color3(0.0f, 1.0f, 0.0f);
GL.End();
#endif
GL.Disable(EnableCap.Texture2D);
}
////draw the guidance line
public void DrawCurve()
{
int ptCount = refList.Count;
if (refList.Count == 0)
{
return;
}
GL.LineWidth(2);
GL.Color3(0.30f, 0.692f, 0.60f);
GL.Begin(PrimitiveType.LineStrip);
for (int h = 0; h < ptCount; h++)
{
GL.Vertex3(refList[h].easting, refList[h].northing, 0);
}
GL.Color3(0.930f, 0.0692f, 0.260f);
if (!mf.curve.isCurveSet)
{
ptCount--;
GL.Vertex3(refList[ptCount].easting, refList[ptCount].northing, 0);
#pragma warning disable CS1690 // Accessing a member on a field of a marshal-by-reference class may cause a runtime exception
GL.Vertex3(mf.pivotAxlePos.easting, mf.pivotAxlePos.northing, 0);
#pragma warning restore CS1690 // Accessing a member on a field of a marshal-by-reference class may cause a runtime exception
}
GL.End();
//just draw ref and smoothed line if smoothing window is open
if (isSmoothWindowOpen)
{
ptCount = smooList.Count;
if (smooList.Count == 0)
{
return;
}
GL.LineWidth(2);
GL.Color3(0.930f, 0.92f, 0.260f);
GL.Begin(PrimitiveType.Lines);
for (int h = 0; h < ptCount; h++)
{
GL.Vertex3(smooList[h].easting, smooList[h].northing, 0);
}
GL.End();
//GL.Color3(0.64f, 0.64f, 0.750f);
//GL.Begin(PrimitiveType.Lines);
//GL.Vertex3(boxA.easting, boxA.northing, 0);
//GL.Vertex3(boxB.easting, boxB.northing, 0);
//GL.Vertex3(boxC.easting, boxC.northing, 0);
//GL.Vertex3(boxD.easting, boxD.northing, 0);
//GL.End();
}
//normal. Smoothing window is not open.
else
{
ptCount = curList.Count;
if (ptCount > 0 || !isCurveSet)
{
GL.PointSize(2);
GL.Color3(0.95f, 0.2f, 0.0f);
GL.Begin(PrimitiveType.LineStrip);
for (int h = 0; h < ptCount; h++)
{
GL.Vertex3(curList[h].easting, curList[h].northing, 0);
}
GL.End();
if (mf.isPureDisplayOn)
{
if (ppRadiusCu < 100 && ppRadiusCu > -100)
{
const int numSegments = 100;
double theta = glm.twoPI / numSegments;
double c = Math.Cos(theta); //precalculate the sine and cosine
double s = Math.Sin(theta);
double x = ppRadiusCu; //we start at angle = 0
double y = 0;
GL.LineWidth(1);
GL.Color3(0.95f, 0.30f, 0.950f);
GL.Begin(PrimitiveType.LineLoop);
for (int ii = 0; ii < numSegments; ii++)
{
//glVertex2f(x + cx, y + cy);//output vertex
GL.Vertex3(x + radiusPointCu.easting, y + radiusPointCu.northing, 0); //output vertex
double t = x; //apply the rotation matrix
x = (c * x) - (s * y);
y = (s * t) + (c * y);
}
GL.End();
}
//Draw lookahead Point
GL.PointSize(4.0f);
GL.Begin(PrimitiveType.Points);
GL.Color3(1.0f, 0.5f, 0.95f);
GL.Vertex3(goalPointCu.easting, goalPointCu.northing, 0.0);
GL.End();
}
mf.yt.DrawYouTurn();
if (mf.yt.isYouTurnTriggered)
{
GL.Color3(0.95f, 0.95f, 0.25f);
GL.LineWidth(4);
ptCount = mf.yt.ytList.Count;
if (ptCount > 0)
{
GL.Begin(PrimitiveType.Points);
for (int i = 0; i < ptCount; i++)
{
GL.Vertex3(mf.yt.ytList[i].easting, mf.yt.ytList[i].northing, 0);
}
GL.End();
}
GL.Color3(0.95f, 0.05f, 0.05f);
}
}
}
GL.PointSize(1.0f);
}
public void DrawBoundingBoxes(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
if (!objectBase.Camera.Enabled)
{
return;
}
if (!objectBase.Camera.Active)
{
return;
}
if (!enableDrawBoundingBoxes)
{
return;
}
float time = args.Time;
PhysicsObject visiblePhysicsObject;
Vector3 min, max;
objectBase.Camera.View.GetViewMatrix(ref view);
objectBase.Camera.Projection.GetProjectionMatrix(ref projection);
world = matrixIdentity;
GL.Color3(1.0f, 1.0f, 1.0f);
render.SetWorld(ref world);
render.SetView(ref view);
render.SetProjection(ref projection);
render.Apply();
for (int i = 0; i < objectBase.Camera.VisiblePhysicsObjectCount; i++)
{
visiblePhysicsObject = objectBase.Camera.GetVisiblePhysicsObject(i);
visiblePhysicsObject.GetBoundingBox(ref boundingBox);
min = boundingBox.Min;
max = boundingBox.Max;
cameraVertices[0].Position.X = min.X;
cameraVertices[0].Position.Y = min.Y;
cameraVertices[0].Position.Z = min.Z;
cameraVertices[1].Position.X = max.X;
cameraVertices[1].Position.Y = min.Y;
cameraVertices[1].Position.Z = min.Z;
cameraVertices[2].Position.X = min.X;
cameraVertices[2].Position.Y = min.Y;
cameraVertices[2].Position.Z = min.Z;
cameraVertices[3].Position.X = min.X;
cameraVertices[3].Position.Y = max.Y;
cameraVertices[3].Position.Z = min.Z;
cameraVertices[4].Position.X = min.X;
cameraVertices[4].Position.Y = min.Y;
cameraVertices[4].Position.Z = min.Z;
cameraVertices[5].Position.X = min.X;
cameraVertices[5].Position.Y = min.Y;
cameraVertices[5].Position.Z = max.Z;
cameraVertices[6].Position.X = max.X;
cameraVertices[6].Position.Y = max.Y;
cameraVertices[6].Position.Z = max.Z;
cameraVertices[7].Position.X = min.X;
cameraVertices[7].Position.Y = max.Y;
cameraVertices[7].Position.Z = max.Z;
cameraVertices[8].Position.X = max.X;
cameraVertices[8].Position.Y = max.Y;
cameraVertices[8].Position.Z = max.Z;
cameraVertices[9].Position.X = max.X;
cameraVertices[9].Position.Y = min.Y;
cameraVertices[9].Position.Z = max.Z;
cameraVertices[10].Position.X = max.X;
cameraVertices[10].Position.Y = max.Y;
cameraVertices[10].Position.Z = max.Z;
cameraVertices[11].Position.X = max.X;
cameraVertices[11].Position.Y = max.Y;
cameraVertices[11].Position.Z = min.Z;
cameraVertices[12].Position.X = min.X;
cameraVertices[12].Position.Y = max.Y;
cameraVertices[12].Position.Z = min.Z;
cameraVertices[13].Position.X = min.X;
cameraVertices[13].Position.Y = max.Y;
cameraVertices[13].Position.Z = max.Z;
cameraVertices[14].Position.X = min.X;
cameraVertices[14].Position.Y = max.Y;
cameraVertices[14].Position.Z = min.Z;
cameraVertices[15].Position.X = max.X;
cameraVertices[15].Position.Y = max.Y;
cameraVertices[15].Position.Z = min.Z;
cameraVertices[16].Position.X = max.X;
cameraVertices[16].Position.Y = min.Y;
cameraVertices[16].Position.Z = max.Z;
cameraVertices[17].Position.X = max.X;
cameraVertices[17].Position.Y = min.Y;
cameraVertices[17].Position.Z = min.Z;
cameraVertices[18].Position.X = max.X;
cameraVertices[18].Position.Y = min.Y;
cameraVertices[18].Position.Z = max.Z;
cameraVertices[19].Position.X = min.X;
cameraVertices[19].Position.Y = min.Y;
cameraVertices[19].Position.Z = max.Z;
cameraVertices[20].Position.X = min.X;
cameraVertices[20].Position.Y = max.Y;
cameraVertices[20].Position.Z = max.Z;
cameraVertices[21].Position.X = min.X;
cameraVertices[21].Position.Y = min.Y;
cameraVertices[21].Position.Z = max.Z;
cameraVertices[22].Position.X = max.X;
cameraVertices[22].Position.Y = max.Y;
cameraVertices[22].Position.Z = min.Z;
cameraVertices[23].Position.X = max.X;
cameraVertices[23].Position.Y = min.Y;
cameraVertices[23].Position.Z = min.Z;
GL.Begin(PrimitiveType.Lines);
for (int j = 0; j < 24; j += 2)
{
GL.Vertex3(cameraVertices[j].Position);
GL.Vertex3(cameraVertices[j + 1].Position);
}
GL.End();
}
}
/// <summary>Renders a string to the screen.</summary>
/// <param name="font">The font to use.</param>
/// <param name="text">The string to render.</param>
/// <param name="location">The location.</param>
/// <param name="alignment">The alignment.</param>
/// <param name="color">The color.</param>
/// <remarks>This function sets the OpenGL blend function to glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA).</remarks>
private static void DrawString(Fonts.OpenGlFont font, string text, Point location, TextAlignment alignment, Color128 color)
{
if (text == null || font == null)
{
return;
}
/*
* Prepare the top-left coordinates for rendering, incorporating the
* orientation of the string in relation to the specified location.
* */
int left;
if ((alignment & TextAlignment.Left) == 0)
{
int width = 0;
for (int i = 0; i < text.Length; i++)
{
Textures.Texture texture;
Fonts.OpenGlFontChar data;
i += font.GetCharacterData(text, i, out texture, out data) - 1;
width += data.TypographicSize.Width;
}
if ((alignment & TextAlignment.Right) != 0)
{
left = location.X - width;
}
else
{
left = location.X - width / 2;
}
}
else
{
left = location.X;
}
int top;
if ((alignment & TextAlignment.Top) == 0)
{
int height = 0;
for (int i = 0; i < text.Length; i++)
{
Textures.Texture texture;
Fonts.OpenGlFontChar data;
i += font.GetCharacterData(text, i, out texture, out data) - 1;
if (data.TypographicSize.Height > height)
{
height = data.TypographicSize.Height;
}
}
if ((alignment & TextAlignment.Bottom) != 0)
{
top = location.Y - height;
}
else
{
top = location.Y - height / 2;
}
}
else
{
top = location.Y;
}
/*
* Render the string.
* */
GL.Enable(EnableCap.Texture2D);
for (int i = 0; i < text.Length; i++)
{
Textures.Texture texture;
Fonts.OpenGlFontChar data;
i += font.GetCharacterData(text, i, out texture, out data) - 1;
if (Textures.LoadTexture(texture, Textures.OpenGlTextureWrapMode.ClampClamp))
{
GL.BindTexture(TextureTarget.Texture2D, texture.OpenGlTextures[(int)Textures.OpenGlTextureWrapMode.ClampClamp].Name);
int x = left - (data.PhysicalSize.Width - data.TypographicSize.Width) / 2;
int y = top - (data.PhysicalSize.Height - data.TypographicSize.Height) / 2;
/*
* In the first pass, mask off the background with pure black.
* */
GL.BlendFunc(BlendingFactor.Zero, BlendingFactor.OneMinusSrcColor);
GL.Begin(PrimitiveType.Polygon);
GL.Color4(color.A, color.A, color.A, 1.0f);
GL.TexCoord2(data.TextureCoordinates.Left, data.TextureCoordinates.Top);
GL.Vertex2(x, y);
GL.Color4(color.A, color.A, color.A, 1.0f);
GL.TexCoord2(data.TextureCoordinates.Right, data.TextureCoordinates.Top);
GL.Vertex2(x + data.PhysicalSize.Width, y);
GL.Color4(color.A, color.A, color.A, 1.0f);
GL.TexCoord2(data.TextureCoordinates.Right, data.TextureCoordinates.Bottom);
GL.Vertex2(x + data.PhysicalSize.Width, y + data.PhysicalSize.Height);
GL.Color4(color.A, color.A, color.A, 1.0f);
GL.TexCoord2(data.TextureCoordinates.Left, data.TextureCoordinates.Bottom);
GL.Vertex2(x, y + data.PhysicalSize.Height);
GL.End();
/*
* In the second pass, add the character onto the background.
* */
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.One);
GL.Begin(PrimitiveType.Polygon);
GL.Color4(color.R, color.G, color.B, color.A);
GL.TexCoord2(data.TextureCoordinates.Left, data.TextureCoordinates.Top);
GL.Vertex2(x, y);
GL.Color4(color.R, color.G, color.B, color.A);
GL.TexCoord2(data.TextureCoordinates.Right, data.TextureCoordinates.Top);
GL.Vertex2(x + data.PhysicalSize.Width, y);
GL.Color4(color.R, color.G, color.B, color.A);
GL.TexCoord2(data.TextureCoordinates.Right, data.TextureCoordinates.Bottom);
GL.Vertex2(x + data.PhysicalSize.Width, y + data.PhysicalSize.Height);
GL.Color4(color.R, color.G, color.B, color.A);
GL.TexCoord2(data.TextureCoordinates.Left, data.TextureCoordinates.Bottom);
GL.Vertex2(x, y + data.PhysicalSize.Height);
GL.End();
}
left += data.TypographicSize.Width;
}
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha); // HACK //
GL.Disable(EnableCap.Texture2D);
}
void LateUpdate()
{
//tex1 = RenderTexture.GetTemporary(300, 300, 16);
string partModelName = "stretchyTank";
string sidesName = "sides";
string endsName = "ends";
string collisionName = "collisionMesh";
List <Mesh> meshList = new List <Mesh>();
List <RenderItem> items = new List <RenderItem>();
Bounds box = new Bounds(new Vector3(0, 0, 0), new Vector3(0, 0, 0));
foreach (Part part in FlightGlobals.ActiveVessel.parts)
{
if (part == null)
{
continue;
}
if (part.GetComponent <Buoyancy>() != null)
{
//Log.post("found buoyancy");
Transform partModel = part.FindModelTransform(partModelName);
Transform sides = part.FindModelTransform(sidesName);
Transform ends = part.FindModelTransform(endsName);
Transform colliderTr = part.FindModelTransform(collisionName);
Material SidesMaterial = sides.renderer.material;
Material EndsMaterial = ends.renderer.material;
// Instantiate meshes. The mesh method unshares any shared meshes.
Mesh SidesMesh = sides.GetComponent <MeshFilter>().sharedMesh;
Mesh EndsMesh = ends.GetComponent <MeshFilter>().sharedMesh;
Mesh colliderMesh = colliderTr.GetComponent <MeshCollider>().sharedMesh;
RenderItem newItem = new RenderItem();
newItem.mesh = colliderMesh;
newItem.translation = sides;
newItem.material = SidesMaterial;
newItem.material.shader = Shader.Find("Unlit");
items.Add(newItem);
box.Encapsulate(SidesMesh.bounds);
//box.Encapsulate(EndsMesh.bounds);
//foreach (Vector3 v in SidesMesh.vertices)
//{
// box.Encapsulate(v);
//}
//foreach (Vector3 v in EndsMesh.vertices)
//{
// box.bounds.Encapsulate(v);
//}
//Matrix4x4 projMatrix = Matrix4x4.Ortho(-3, 3, -3, 3, -10, 10);
//for (int i = 0; i < SidesMaterial.passCount; ++i)
//{
// SidesMaterial.SetPass(0);
// Graphics.DrawMeshNow(SidesMesh, projMatrix);
//}
}
}
Matrix4x4 projMatrix = Matrix4x4.Ortho(-10, 10, -10, 10, -10, 10);
//Matrix4x4.Ortho(box.min.x, box.max.x, box.min.y, box.max.y, box.min.z, box.max.z);
//FlightCamera.fetch.camera
if (!tex1.IsCreated())
{
tex1.Create();
}
RenderTexture.active = tex1;
GL.Clear(true, true, Color.blue);
GL.LoadProjectionMatrix(projMatrix);
GL.LoadIdentity();
GL.PushMatrix();
GL.Begin(GL.TRIANGLES);
foreach (RenderItem ri in items)
{
ri.material.SetPass(0);
GL.Color(Color.grey);
Graphics.DrawMeshNow(ri.mesh, projMatrix);
foreach (int i in ri.mesh.triangles)
{
GL.Vertex(ri.mesh.vertices[i]);
GL.TexCoord(ri.mesh.uv[i]);
}
}
GL.End();
GL.PopMatrix();
//Graphics.DrawTexture(new Rect(100, 100, 300, 300), tex1);
//foreach (Mesh m in meshList)
//{
// Graphics.DrawMeshNow(m, FlightGlobals.ActiveVessel.rootPart.rigidbody.worldCenterOfMass, Quaternion.identity);
//}
}
void glControl1_Paint(object sender, PaintEventArgs e)
{
if (!loaded)
{
return;
}
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
if (this.system != null)
{
// Setup camera.
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
OpenTK.Vector3 bounds = this.maxPoint - this.minPoint;
float controlWidth = this.glControl1.Width;
float controlHeight = this.glControl1.Height;
float controlAspect = controlWidth / controlHeight;
float maxSize = bounds.Length * 0.5f;
float orthoWidth = 0, orthoHeight = 0;
if (controlWidth > controlHeight)
{
orthoHeight = maxSize;
orthoWidth = maxSize * controlAspect;
}
else
{
orthoWidth = maxSize;
orthoHeight = maxSize / controlAspect;
}
if (isOrtho)
{
GL.Ortho(-orthoWidth, orthoWidth, -orthoHeight, orthoHeight, -100000, 100000);
}
else
{
OpenTK.Matrix4 m = OpenTK.Matrix4.CreatePerspectiveFieldOfView((float)(Math.PI * 0.3f), controlAspect, 1, 2 + orthoHeight * 10);
GL.MultMatrix(ref m);
}
// Render L-System.
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
if (!isOrtho)
{
OpenTK.Matrix4 lookAt = OpenTK.Matrix4.LookAt(0, 0, orthoHeight * 2, 0, 0, 0, 0, 1, 0);
GL.MultMatrix(ref lookAt);
}
GL.Rotate(cameraAngle.X, 1, 0, 0);
GL.Rotate(cameraAngle.Y, 0, 1, 0);
GL.Scale(cameraScale, cameraScale, cameraScale);
GL.Translate((this.maxPoint + this.minPoint) * (-0.5f));
// Draw axis.
float axisLength = Math.Max(orthoWidth, orthoHeight);
GL.Disable(EnableCap.Lighting);
GL.Begin(BeginMode.Lines);
GL.Color3(Color.Red);
GL.Vertex3(0, 0, 0);
GL.Vertex3(axisLength, 0, 0);
GL.Color3(Color.Green);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, axisLength, 0);
GL.Color3(Color.Blue);
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, axisLength);
GL.End();
GL.Begin(BeginMode.Lines);
GL.Color3(Color.Orange);
for (int i = 0; i < helperLines.Count; i += 2)
{
GL.Vertex3(helperLines[i]);
GL.Vertex3(helperLines[i + 1]);
}
GL.End();
GL.Enable(EnableCap.Lighting);
Render(
BeginMode.Quads,
this.numQuadVertexes,
this.vertexesPtr,
this.colorsPtr,
this.normalsPtr,
null,
null);
Render(
BeginMode.Triangles,
this.numTriVertexes,
this.triVertexesPtr,
this.triColorsPtr,
this.triNormalsPtr,
null,
null);
}
glControl1.SwapBuffers();
}
public GLDisplayList GetScaleControl()
{
//Create the axes.
GLDisplayList axis = new GLDisplayList();
axis.Begin();
//Disable culling so square bases for the arrows aren't necessary to draw
GL.Disable(EnableCap.CullFace);
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Begin(BeginMode.Lines);
//X
if ((_snapY && _snapZ) || (_hiY && _hiZ))
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Red);
}
GL.Vertex3(0.0f, _scaleHalf1LDist, 0.0f);
GL.Vertex3(0.0f, 0.0f, _scaleHalf1LDist);
GL.Vertex3(0.0f, _scaleHalf2LDist, 0.0f);
GL.Vertex3(0.0f, 0.0f, _scaleHalf2LDist);
if (_snapX || _hiX)
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Red);
}
GL.Vertex3(0.0f, 0.0f, 0.0f);
GL.Vertex3(_dst, 0.0f, 0.0f);
GL.End();
GL.Begin(BeginMode.Triangles);
GL.Vertex3(_axisLDist, 0.0f, 0.0f);
GL.Vertex3(_dst, _apthm, -_apthm);
GL.Vertex3(_dst, _apthm, _apthm);
GL.Vertex3(_axisLDist, 0.0f, 0.0f);
GL.Vertex3(_dst, -_apthm, _apthm);
GL.Vertex3(_dst, -_apthm, -_apthm);
GL.Vertex3(_axisLDist, 0.0f, 0.0f);
GL.Vertex3(_dst, _apthm, _apthm);
GL.Vertex3(_dst, -_apthm, _apthm);
GL.Vertex3(_axisLDist, 0.0f, 0.0f);
GL.Vertex3(_dst, -_apthm, -_apthm);
GL.Vertex3(_dst, _apthm, -_apthm);
GL.End();
GL.Begin(BeginMode.Lines);
//Y
if ((_snapZ && _snapX) || (_hiZ && _hiX))
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Green);
}
GL.Vertex3(0.0f, 0.0f, _scaleHalf1LDist);
GL.Vertex3(_scaleHalf1LDist, 0.0f, 0.0f);
GL.Vertex3(0.0f, 0.0f, _scaleHalf2LDist);
GL.Vertex3(_scaleHalf2LDist, 0.0f, 0.0f);
if (_snapY || _hiY)
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Green);
}
GL.Vertex3(0.0f, 0.0f, 0.0f);
GL.Vertex3(0.0f, _dst, 0.0f);
GL.End();
GL.Begin(BeginMode.Triangles);
GL.Vertex3(0.0f, _axisLDist, 0.0f);
GL.Vertex3(_apthm, _dst, -_apthm);
GL.Vertex3(_apthm, _dst, _apthm);
GL.Vertex3(0.0f, _axisLDist, 0.0f);
GL.Vertex3(-_apthm, _dst, _apthm);
GL.Vertex3(-_apthm, _dst, -_apthm);
GL.Vertex3(0.0f, _axisLDist, 0.0f);
GL.Vertex3(_apthm, _dst, _apthm);
GL.Vertex3(-_apthm, _dst, _apthm);
GL.Vertex3(0.0f, _axisLDist, 0.0f);
GL.Vertex3(-_apthm, _dst, -_apthm);
GL.Vertex3(_apthm, _dst, -_apthm);
GL.End();
GL.Begin(BeginMode.Lines);
//Z
if ((_snapX && _snapY) || (_hiX && _hiY))
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Blue);
}
GL.Vertex3(0.0f, _scaleHalf1LDist, 0.0f);
GL.Vertex3(_scaleHalf1LDist, 0.0f, 0.0f);
GL.Vertex3(0.0f, _scaleHalf2LDist, 0.0f);
GL.Vertex3(_scaleHalf2LDist, 0.0f, 0.0f);
if (_snapZ || _hiZ)
{
GL.Color4(Color.Yellow);
}
else
{
GL.Color4(Color.Blue);
}
GL.Vertex3(0.0f, 0.0f, 0.0f);
GL.Vertex3(0.0f, 0.0f, _dst);
GL.End();
GL.Begin(BeginMode.Triangles);
GL.Vertex3(0.0f, 0.0f, _axisLDist);
GL.Vertex3(_apthm, -_apthm, _dst);
GL.Vertex3(_apthm, _apthm, _dst);
GL.Vertex3(0.0f, 0.0f, _axisLDist);
GL.Vertex3(-_apthm, _apthm, _dst);
GL.Vertex3(-_apthm, -_apthm, _dst);
GL.Vertex3(0.0f, 0.0f, _axisLDist);
GL.Vertex3(_apthm, _apthm, _dst);
GL.Vertex3(-_apthm, _apthm, _dst);
GL.Vertex3(0.0f, 0.0f, _axisLDist);
GL.Vertex3(-_apthm, -_apthm, _dst);
GL.Vertex3(_apthm, -_apthm, _dst);
GL.End();
axis.End();
return(axis);
}
private unsafe void modelPanel1_PostRender(object sender, TKContext context)
{
//GL.LineWidth(2.0f);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.DepthTest);
//Attributes.PostRender();
//Render hurtboxes
if (chkHurtboxes.Checked)
{
for (int i = 0; i < listPanel.lstHurtboxes.Items.Count; i++)
{
if (listPanel.lstHurtboxes.GetItemChecked(i))
{
((MiscHurtBox)listPanel.lstHurtboxes.Items[i]).Render(SelectedHurtbox != null && SelectedHurtbox.Index == i, Scriptor._hurtBoxType);
}
}
}
//Render hitboxes
if (chkHitboxes.Checked && Manager.Moveset != null)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GLDisplayList c = context.GetRingList();
GLDisplayList s = context.GetSphereList();
foreach (HitBox e in RunTime._hitBoxes)
{
e.Render(context, modelPanel._camera.GetPoint());
}
}
GL.Enable(EnableCap.DepthTest);
//Show the user where the light source is
if (_renderLightDisplay)
{
GL.PushAttrib(AttribMask.AllAttribBits);
GL.Color4(Color.Blue);
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.DepthTest);
GL.Scale(modelPanel.LightPosition._x, modelPanel.LightPosition._x, modelPanel.LightPosition._x);
GL.Rotate(90.0f, 1, 0, 0);
float azimuth = modelPanel.LightPosition._y.Clamp180Deg();
float elevation = modelPanel.LightPosition._z.Clamp180Deg();
if (Math.Abs(azimuth) == Math.Abs(elevation) && azimuth % 180.0f == 0 && elevation % 180.0f == 0)
{
azimuth = 0;
elevation = 0;
}
int i; float x;
float e = azimuth;
bool flip = false;
if (e < 0)
{
e = -e;
flip = true;
GL.Rotate(180.0f, 1, 0, 0);
}
float f = (float)((int)e);
float diff = (float)Math.Round(e - f, 1);
GL.Begin(OpenTK.Graphics.OpenGL.BeginMode.Lines);
for (i = 0; i < f; i++)
{
GL.Vertex2(Math.Cos(i * Maths._deg2radf), Math.Sin(i * Maths._deg2radf));
GL.Vertex2(Math.Cos((i + 1) * Maths._deg2radf), Math.Sin((i + 1) * Maths._deg2radf));
}
for (x = 0; x < diff; x += 0.1f)
{
GL.Vertex2(Math.Cos((x + (float)i) * Maths._deg2radf), Math.Sin((x + (float)i) * Maths._deg2radf));
GL.Vertex2(Math.Cos((x + 0.1f + (float)i) * Maths._deg2radf), Math.Sin((x + 0.1f + (float)i) * Maths._deg2radf));
}
GL.End();
if (flip)
{
GL.Rotate(-180.0f, 1, 0, 0);
}
GL.Rotate(90.0f, 0, 1, 0);
GL.Rotate(90.0f, 0, 0, 1);
GL.Rotate(180.0f, 1, 0, 0);
GL.Rotate(90.0f - azimuth, 0, 1, 0);
e = elevation;
if (e < 0)
{
e = -e;
GL.Rotate(180.0f, 1, 0, 0);
}
f = (float)((int)e);
diff = (float)Math.Round(e - f, 1);
GL.Begin(OpenTK.Graphics.OpenGL.BeginMode.Lines);
for (i = 0; i < f; i++)
{
GL.Vertex2(Math.Cos(i * Maths._deg2radf), Math.Sin(i * Maths._deg2radf));
GL.Vertex2(Math.Cos((i + 1) * Maths._deg2radf), Math.Sin((i + 1) * Maths._deg2radf));
}
for (x = 0; x < diff; x += 0.1f)
{
GL.Vertex2(Math.Cos((x + (float)i) * Maths._deg2radf), Math.Sin((x + (float)i) * Maths._deg2radf));
GL.Vertex2(Math.Cos((x + 0.1f + (float)i) * Maths._deg2radf), Math.Sin((x + 0.1f + (float)i) * Maths._deg2radf));
}
GL.Vertex2(Math.Cos((x + (float)i) * Maths._deg2radf), Math.Sin((x + (float)i) * Maths._deg2radf));
GL.Color4(Color.Orange);
GL.Vertex3(0, 0, 0);
GL.End();
GL.PopAttrib();
}
GL.Clear(ClearBufferMask.DepthBufferBit);
RenderTransformControl(context);
if (!modelPanel._grabbing && !modelPanel._scrolling && !_playing)
{
GL.Color4(Color.Black);
GL.ColorMask(false, false, false, false);
if (RenderBones)
{
//Render invisible depth orbs
GLDisplayList list = context.GetSphereList();
if (_editingAll)
{
foreach (MDL0Node m in _targetModels)
{
foreach (MDL0BoneNode bone in m._linker.BoneCache)
{
if (bone != SelectedBone)
{
RenderOrb(bone, list);
}
}
}
}
else if (TargetModel != null && TargetModel._linker != null && TargetModel._linker.BoneCache != null)
{
foreach (MDL0BoneNode bone in _targetModel._linker.BoneCache)
{
if (bone != SelectedBone)
{
RenderOrb(bone, list);
}
}
}
}
//Render invisible depth planes for translation and scale controls
if (_editType != 0 && SelectedBone != null && RenderBones)
{
#region Axis Selection Display List
GLDisplayList selList = new GLDisplayList();
selList.Begin();
GL.Begin(BeginMode.Quads);
//X Axis
//XY quad
GL.Vertex3(0.0f, -_axisSelectRange, 0.0f);
GL.Vertex3(0.0f, _axisSelectRange, 0.0f);
GL.Vertex3(_axisLDist, _axisSelectRange, 0.0f);
GL.Vertex3(_axisLDist, -_axisSelectRange, 0.0f);
//XZ quad
GL.Vertex3(0.0f, 0.0f, -_axisSelectRange);
GL.Vertex3(0.0f, 0.0f, _axisSelectRange);
GL.Vertex3(_axisLDist, 0.0f, _axisSelectRange);
GL.Vertex3(_axisLDist, 0.0f, -_axisSelectRange);
//Y Axis
//YX quad
GL.Vertex3(-_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, _axisLDist, 0.0f);
GL.Vertex3(-_axisSelectRange, _axisLDist, 0.0f);
//YZ quad
GL.Vertex3(0.0f, 0.0f, -_axisSelectRange);
GL.Vertex3(0.0f, 0.0f, _axisSelectRange);
GL.Vertex3(0.0f, _axisLDist, _axisSelectRange);
GL.Vertex3(0.0f, _axisLDist, -_axisSelectRange);
//Z Axis
//ZX quad
GL.Vertex3(-_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, 0.0f, _axisLDist);
GL.Vertex3(-_axisSelectRange, 0.0f, _axisLDist);
//ZY quad
GL.Vertex3(0.0f, -_axisSelectRange, 0.0f);
GL.Vertex3(0.0f, _axisSelectRange, 0.0f);
GL.Vertex3(0.0f, _axisSelectRange, _axisLDist);
GL.Vertex3(0.0f, -_axisSelectRange, _axisLDist);
GL.End();
selList.End();
#endregion
if (_editType != 0 && SelectedBone != null)
{
Matrix m = Matrix.TransformMatrix(new Vector3(OrbRadius), new Vector3(), BoneLoc);
GL.PushMatrix();
GL.MultMatrix((float *)&m);
selList.Call();
if (_editType == TransformType.Translation)
{
GL.Begin(BeginMode.Quads);
//XY
GL.Vertex3(0.0f, _axisSelectRange, 0.0f);
GL.Vertex3(_axisHalfLDist, _axisSelectRange, 0.0f);
GL.Vertex3(_axisHalfLDist, _axisHalfLDist, 0.0f);
GL.Vertex3(0.0f, _axisHalfLDist, 0.0f);
//YZ
GL.Vertex3(0.0f, 0.0f, _axisSelectRange);
GL.Vertex3(0.0f, _axisHalfLDist, _axisSelectRange);
GL.Vertex3(0.0f, _axisHalfLDist, _axisHalfLDist);
GL.Vertex3(0.0f, 0.0f, _axisHalfLDist);
//XZ
GL.Vertex3(_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, 0.0f, _axisHalfLDist);
GL.Vertex3(_axisHalfLDist, 0.0f, _axisHalfLDist);
GL.Vertex3(_axisHalfLDist, 0.0f, 0.0f);
GL.End();
}
else
{
GL.Begin(BeginMode.Triangles);
//XY
GL.Vertex3(0.0f, _axisSelectRange, 0.0f);
GL.Vertex3(_scaleHalf2LDist, _axisSelectRange, 0.0f);
GL.Vertex3(0.0f, _scaleHalf2LDist, 0.0f);
//YZ
GL.Vertex3(0.0f, 0.0f, _axisSelectRange);
GL.Vertex3(0.0f, _scaleHalf2LDist, _axisSelectRange);
GL.Vertex3(0.0f, 0.0f, _scaleHalf2LDist);
//XZ
GL.Vertex3(_axisSelectRange, 0.0f, 0.0f);
GL.Vertex3(_axisSelectRange, 0.0f, _scaleHalf2LDist);
GL.Vertex3(_scaleHalf2LDist, 0.0f, 0.0f);
GL.End();
}
GL.PopMatrix();
}
}
GL.ColorMask(true, true, true, true);
}
}
public override void OnPreviewGUI(Rect r, GUIStyle background)
{
if (Event.current.type == EventType.Repaint)
{
background.Draw(r, false, false, false, false);
}
// show texture
Texture t = target as Texture;
if (t == null) // texture might be gone by now, in case this code is used for floating texture preview
{
return;
}
// Render target must be created before we can display it (case 491797)
RenderTexture rt = t as RenderTexture;
if (rt != null)
{
if (!SystemInfo.IsFormatSupported(rt.graphicsFormat, FormatUsage.Render))
{
return; // can't do this RT format
}
rt.Create();
}
if (IsCubemap())
{
m_CubemapPreview.OnPreviewGUI(t, r, background);
return;
}
// target can report zero sizes in some cases just after a parameter change;
// guard against that.
int texWidth = Mathf.Max(t.width, 1);
int texHeight = Mathf.Max(t.height, 1);
float mipLevel = GetMipLevelForRendering();
float zoomLevel = Mathf.Min(Mathf.Min(r.width / texWidth, r.height / texHeight), 1);
Rect wantedRect = new Rect(r.x, r.y, texWidth * zoomLevel, texHeight * zoomLevel);
PreviewGUI.BeginScrollView(r, m_Pos, wantedRect, "PreHorizontalScrollbar", "PreHorizontalScrollbarThumb");
FilterMode oldFilter = t.filterMode;
TextureUtil.SetFilterModeNoDirty(t, FilterMode.Point);
Texture2D t2d = t as Texture2D;
ColorWriteMask colorWriteMask = ColorWriteMask.All;
switch (m_PreviewMode)
{
case PreviewMode.R:
colorWriteMask = ColorWriteMask.Red | ColorWriteMask.Alpha;
break;
case PreviewMode.G:
colorWriteMask = ColorWriteMask.Green | ColorWriteMask.Alpha;
break;
case PreviewMode.B:
colorWriteMask = ColorWriteMask.Blue | ColorWriteMask.Alpha;
break;
}
if (m_PreviewMode == PreviewMode.A)
{
EditorGUI.DrawTextureAlpha(wantedRect, t, ScaleMode.StretchToFill, 0, mipLevel);
}
else
{
if (t2d != null && t2d.alphaIsTransparency)
{
EditorGUI.DrawTextureTransparent(wantedRect, t, ScaleMode.StretchToFill, 0, mipLevel, colorWriteMask);
}
else
{
EditorGUI.DrawPreviewTexture(wantedRect, t, null, ScaleMode.StretchToFill, 0, mipLevel, colorWriteMask);
}
}
// TODO: Less hacky way to prevent sprite rects to not appear in smaller previews like icons.
if ((wantedRect.width > 32 && wantedRect.height > 32) && Event.current.type == EventType.Repaint)
{
string path = AssetDatabase.GetAssetPath(t);
TextureImporter textureImporter = AssetImporter.GetAtPath(path) as TextureImporter;
SpriteMetaData[] spritesheet = textureImporter != null ? textureImporter.spritesheet : null;
if (spritesheet != null && textureImporter.spriteImportMode == SpriteImportMode.Multiple)
{
Rect screenRect = new Rect();
Rect sourceRect = new Rect();
GUI.CalculateScaledTextureRects(wantedRect, ScaleMode.StretchToFill, (float)t.width / (float)t.height, ref screenRect, ref sourceRect);
int origWidth = t.width;
int origHeight = t.height;
textureImporter.GetWidthAndHeight(ref origWidth, ref origHeight);
float definitionScale = (float)t.width / (float)origWidth;
HandleUtility.ApplyWireMaterial();
GL.PushMatrix();
GL.MultMatrix(Handles.matrix);
GL.Begin(GL.LINES);
GL.Color(new Color(1f, 1f, 1f, 0.5f));
foreach (SpriteMetaData sprite in spritesheet)
{
Rect spriteRect = sprite.rect;
Rect spriteScreenRect = new Rect();
spriteScreenRect.xMin = screenRect.xMin + screenRect.width * (spriteRect.xMin / t.width * definitionScale);
spriteScreenRect.xMax = screenRect.xMin + screenRect.width * (spriteRect.xMax / t.width * definitionScale);
spriteScreenRect.yMin = screenRect.yMin + screenRect.height * (1f - spriteRect.yMin / t.height * definitionScale);
spriteScreenRect.yMax = screenRect.yMin + screenRect.height * (1f - spriteRect.yMax / t.height * definitionScale);
DrawRect(spriteScreenRect);
}
GL.End();
GL.PopMatrix();
}
}
TextureUtil.SetFilterModeNoDirty(t, oldFilter);
m_Pos = PreviewGUI.EndScrollView();
if (mipLevel != 0)
{
EditorGUI.DropShadowLabel(new Rect(r.x, r.y, r.width, 20), "Mip " + mipLevel);
}
}
public static void DrawGraphs(Rect rect, EditorWindow window)
{
if (VarTracer.Instance)
{
bool isEditorPaused = EditorApplication.isPaused;
CreateLineMaterial();
mLineMaterial.SetPass(0);
int graph_index = 0;
//use this to get the starting y position for the GL rendering
Rect find_y = EditorGUILayout.BeginVertical(GUIStyle.none);
EditorGUILayout.EndVertical();
int currentFrameIndex = VarTracerNet.Instance.GetCurrentFrameFromTimestamp(VarTracerUtils.GetTimeStamp());
if (isEditorPaused)
currentFrameIndex = VarTracerNet.Instance.GetCurrentFrameFromTimestamp(VarTracerUtils.StopTimeStamp);
float scrolled_y_pos = y_offset - mGraphViewScrollPos.y;
if (Event.current.type == EventType.Repaint)
{
GL.PushMatrix();
float start_y = find_y.y;
GL.Viewport(new Rect(0, 0, rect.width, rect.height - start_y));
GL.LoadPixelMatrix(0, rect.width, rect.height - start_y, 0);
//Draw grey BG
GL.Begin(GL.QUADS);
GL.Color(new Color(0.2f, 0.2f, 0.2f));
foreach (KeyValuePair<string, VarTracerGraphItData> kv in VarTracer.Instance.Graphs)
{
float height = kv.Value.GetHeight();
GL.Vertex3(x_offset, scrolled_y_pos, 0);
GL.Vertex3(x_offset + mWidth, scrolled_y_pos, 0);
GL.Vertex3(x_offset + mWidth, scrolled_y_pos + height, 0);
GL.Vertex3(x_offset, scrolled_y_pos + height, 0);
scrolled_y_pos += (height + y_gap);
}
GL.End();
scrolled_y_pos = y_offset - mGraphViewScrollPos.y;
//Draw Lines
GL.Begin(GL.LINES);
foreach (KeyValuePair<string, VarTracerGraphItData> kv in VarTracer.Instance.Graphs)
{
graph_index++;
float height = kv.Value.GetHeight();
DrawGraphGridLines(scrolled_y_pos, mWidth, height, graph_index == mMouseOverGraphIndex);
foreach (KeyValuePair<string, VarTracerDataInternal> entry in kv.Value.mData)
{
VarTracerDataInternal g = entry.Value;
float y_min = kv.Value.GetMin(entry.Key);
float y_max = kv.Value.GetMax(entry.Key);
float y_range = Mathf.Max(y_max - y_min, 0.00001f);
//draw the 0 line
if (y_min != 0.0f)
{
GL.Color(Color.white);
float y = scrolled_y_pos + height * (1 - (0.0f - y_min) / y_range);
Plot(x_offset, y, x_offset + mWidth, y);
}
GL.Color(g.mColor);
float previous_value = 0, value = 0;
int dataInfoIndex = 0, frameIndex = 0;
for (int i = 0; i <= currentFrameIndex; i++)
{
int dataCount = g.mDataInfos.Count;
if (dataCount != 0)
{
int lastFrame = g.mDataInfos[dataCount - 1].FrameIndex;
float lastValue = g.mDataInfos[dataCount - 1].Value;
frameIndex = g.mDataInfos[dataInfoIndex].FrameIndex;
if (dataInfoIndex >= 1)
value = g.mDataInfos[dataInfoIndex - 1].Value;
if (dataInfoIndex == 0 && i < frameIndex)
value = 0;
if (i >= frameIndex)
{
while (g.mDataInfos[dataInfoIndex].FrameIndex == frameIndex && dataInfoIndex < dataCount - 1)
{
dataInfoIndex++;
}
}
if (i > lastFrame)
value = lastValue;
}
else
{
value = 0;
}
if (i >= 1)
{
float x0 = x_offset + (i - 1) * kv.Value.XStep - kv.Value.ScrollPos.x;
if (x0 <= x_offset - kv.Value.XStep) continue;
if (x0 >= mWidth + x_offset) break;
float y0 = scrolled_y_pos + height * (1 - (previous_value - y_min) / y_range);
if (i == 1)
{
x0 = x_offset;
y0 = scrolled_y_pos + height;
}
float x1 = x_offset + i * kv.Value.XStep - kv.Value.ScrollPos.x;
float y1 = scrolled_y_pos + height * (1 - (value - y_min) / y_range);
if (m_isDrawLine)
Plot(x0, y0, x1, y1);
else
Plot(x0, y0, x0+1, y0+1);
}
previous_value = value;
}
}
scrolled_y_pos += (height + y_gap);
}
GL.End();
scrolled_y_pos = y_offset - mGraphViewScrollPos.y;
scrolled_y_pos = ShowEventLabel(scrolled_y_pos);
GL.PopMatrix();
GL.Viewport(new Rect(0, 0, rect.width, rect.height));
GL.LoadPixelMatrix(0, rect.width, rect.height, 0);
}
mGraphViewScrollPos = EditorGUILayout.BeginScrollView(mGraphViewScrollPos, GUIStyle.none);
graph_index = 0;
mWidth = window.position.width - x_offset;
foreach (KeyValuePair<string, VarTracerGraphItData> kv in VarTracer.Instance.Graphs)
{
graph_index++;
float height = kv.Value.GetHeight();
float width = currentFrameIndex * kv.Value.XStep;
if (width < mWidth)
{
width = mWidth - x_offset;
}
else
{
if (!EditorApplication.isPaused)
kv.Value.ScrollPos = new Vector2(width - mWidth, kv.Value.ScrollPos.y);
}
GUIStyle s = new GUIStyle();
s.fixedHeight = height + y_gap;
s.stretchWidth = true;
Rect r = EditorGUILayout.BeginVertical(s);
//skip subgraph title if only one, and it's the same.
NameLabel.normal.textColor = Color.white;
r.height = height + 50;
r.width = width;
r.x = x_offset - 35;
r.y = (height + y_gap) * (graph_index - 1) - 10;
if (kv.Value.mData.Count > 0)
{
GUILayout.BeginArea(r);
GUILayout.BeginVertical();
float GraphGap = kv.Value.m_maxValue - kv.Value.m_minValue;
float unitHeight = GraphGap / VarTracerConst.Graph_Grid_Row_Num;
for (int i = 0; i < VarTracerConst.Graph_Grid_Row_Num + 1; i++)
{
GUILayout.Space(6);
if (unitHeight == 0)
EditorGUILayout.LabelField("",NameLabel);
else
EditorGUILayout.LabelField((kv.Value.m_maxValue - i * unitHeight).ToString(VarTracerConst.NUM_FORMAT_1),NameLabel);
}
GUILayout.BeginHorizontal();
kv.Value.ScrollPos = GUILayout.BeginScrollView(kv.Value.ScrollPos, GUILayout.Width(mWidth), GUILayout.Height(0));
GUILayout.Label("", GUILayout.Width(width), GUILayout.Height(0));
GUILayout.EndScrollView();
GUILayout.EndHorizontal();
GUILayout.EndVertical();
GUILayout.EndArea();
}
DrawGraphAttribute(kv);
////Respond to mouse input!
if (Event.current.type == EventType.MouseDrag && r.Contains(Event.current.mousePosition - Event.current.delta))
{
if (Event.current.button == 0)
{
kv.Value.ScrollPos = new Vector2(kv.Value.ScrollPos.x + Event.current.delta.x, kv.Value.ScrollPos.y);
}
window.Repaint();
}
EditorGUILayout.EndVertical();
}
EditorGUILayout.EndScrollView();
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
System.Random random = new System.Random(25565);
EditorGUI.PrefixLabel(position, label);
position.y += EditorGUIUtility.singleLineHeight;
cachedWidth = position.x + position.width * (1 - PREVIEW_WIDTH) / 2;
if (Event.current.type != EventType.Repaint)
{
return;
}
position.height = position.width / PREVIEW_RATIO;
Rect rect = new Rect()
{
size = new Vector2(position.width *= PREVIEW_WIDTH, position.width / PREVIEW_RATIO),
position = new Vector2(position.x += position.width * (1 - PREVIEW_WIDTH) / 2, position.position.y + Y_OFFSET)
};
EditorGUI.DrawRect(rect, PREVIEW_BACKGROUND);
SerializedProperty enemiesArray = property.serializedObject.FindProperty("enemies");
for (int i = 0; i < enemiesArray.arraySize; i++)
{
Vector2 enemyPos = enemiesArray.GetArrayElementAtIndex(i).FindPropertyRelative("startOffset").vector2Value;
enemyPos.y *= -1;
Rect enemyRect = new Rect()
{
size = Vector2.one * DOT_SIZE,
center = rect.center + (rect.size / 2F) * enemyPos
};
EditorGUI.DrawRect(enemyRect, PREVIEW_DOT_COLOR);
SerializedProperty movementsArray = enemiesArray.GetArrayElementAtIndex(i).FindPropertyRelative("movements");
if (movementsArray.arraySize == 0)
{
continue;
}
Vector2 last = enemyRect.center;
GL.Begin(GL.LINE_STRIP);
GL.Color(new Color(random.Next(50, 255) / 255F, random.Next(50, 255) / 255F, random.Next(50, 255) / 255F));
GL.Vertex(enemyRect.center);
for (int j = 0; j < movementsArray.arraySize; j++)
{
Vector2 move = movementsArray.GetArrayElementAtIndex(j).FindPropertyRelative("move").vector2Value;
move *= rect.width * .025F;
move.y *= -1;
Vector2 newPos = last + move;
GL.Vertex(newPos);
last = newPos;
}
GL.End();
}
}
public void TimeRuler(Rect position, float frameRate, bool labels, bool useEntireHeight, float alpha,
TimeFormat timeFormat)
{
Color backupCol = GUI.color;
GUI.BeginGroup(position);
InitStyles();
HandleUtility.ApplyWireMaterial();
Color tempBackgroundColor = GUI.backgroundColor;
SetTickMarkerRanges();
hTicks.SetTickStrengths(kTickRulerDistMin, kTickRulerDistFull, true);
Color baseColor = timeAreaStyles.timelineTick.normal.textColor;
baseColor.a = 0.75f * alpha;
if (Event.current.type == EventType.Repaint)
{
if (Application.platform == RuntimePlatform.WindowsEditor)
{
GL.Begin(GL.QUADS);
}
else
{
GL.Begin(GL.LINES);
}
// Draw tick markers of various sizes
Rect cachedShowArea = shownArea;
for (int l = 0; l < hTicks.tickLevels; l++)
{
float strength = hTicks.GetStrengthOfLevel(l) * .9f;
float[] ticks = hTicks.GetTicksAtLevel(l, true);
for (int i = 0; i < ticks.Length; i++)
{
if (ticks[i] < hRangeMin || ticks[i] > hRangeMax)
{
continue;
}
int frame = Mathf.RoundToInt(ticks[i] * frameRate);
float height = useEntireHeight
? position.height
: position.height * Mathf.Min(1, strength) * kTickRulerHeightMax;
float x = FrameToPixel(frame, frameRate, position, cachedShowArea);
// Draw line
DrawVerticalLineFast(x, position.height - height + 0.5f, position.height - 0.5f,
new Color(1, 1, 1, strength / kTickRulerFatThreshold) * baseColor);
}
}
GL.End();
}
if (labels)
{
// Draw tick labels
int labelLevel = hTicks.GetLevelWithMinSeparation(kTickRulerDistLabel);
float[] labelTicks = hTicks.GetTicksAtLevel(labelLevel, false);
for (int i = 0; i < labelTicks.Length; i++)
{
if (labelTicks[i] < hRangeMin || labelTicks[i] > hRangeMax)
{
continue;
}
int frame = Mathf.RoundToInt(labelTicks[i] * frameRate);
// Important to take floor of positions of GUI stuff to get pixel correct alignment of
// stuff drawn with both GUI and Handles/GL. Otherwise things are off by one pixel half the time.
float labelpos = Mathf.Floor(FrameToPixel(frame, frameRate, position));
string label = FormatTime(labelTicks[i], frameRate, timeFormat);
GUI.Label(new Rect(labelpos + 3, -3, 40, 20), label, timeAreaStyles.timelineTick);
}
}
GUI.EndGroup();
GUI.backgroundColor = tempBackgroundColor;
GUI.color = backupCol;
}
public virtual void GL_DrawAliasFrameLerp(qfiles.dmdl_t paliashdr, Single backlerp)
{
Single l;
qfiles.daliasframe_t frame, oldframe;
Int32[] v, ov;
Int32[] order;
var orderIndex = 0;
Int32 count;
Single frontlerp;
Single alpha;
Single[] move = new Single[] { 0, 0, 0 };
Single[][] vectors = new Single[][] { new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 }, new Single[] { 0, 0, 0 } };
Single[] frontv = new Single[] { 0, 0, 0 };
Single[] backv = new Single[] { 0, 0, 0 };
Int32 i;
Int32 index_xyz;
frame = paliashdr.aliasFrames[currententity.frame];
v = frame.verts;
oldframe = paliashdr.aliasFrames[currententity.oldframe];
ov = oldframe.verts;
order = paliashdr.glCmds;
if ((currententity.flags & Defines.RF_TRANSLUCENT) != 0)
{
alpha = currententity.alpha;
}
else
{
alpha = 1F;
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.Disable(EnableCap.Texture2D);
}
frontlerp = 1F - backlerp;
Math3D.VectorSubtract(currententity.oldorigin, currententity.origin, frontv);
Math3D.AngleVectors(currententity.angles, vectors[0], vectors[1], vectors[2]);
move[0] = Math3D.DotProduct(frontv, vectors[0]);
move[1] = -Math3D.DotProduct(frontv, vectors[1]);
move[2] = Math3D.DotProduct(frontv, vectors[2]);
Math3D.VectorAdd(move, oldframe.translate, move);
for (i = 0; i < 3; i++)
{
move[i] = backlerp * move[i] + frontlerp * frame.translate[i];
frontv[i] = frontlerp * frame.scale[i];
backv[i] = backlerp * oldframe.scale[i];
}
if (gl_vertex_arrays.value != 0F)
{
GL_LerpVerts(paliashdr.num_xyz, ov, v, move, frontv, backv);
GL.EnableClientState(ArrayCap.VertexArray);
new Pinnable(vertexArrayBuf.Array, (ptr) =>
{
GL.VertexPointer(3, VertexPointerType.Float, 0, ptr);
});
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.DisableClientState(ArrayCap.ColorArray);
GL.Color4(shadelight[0], shadelight[1], shadelight[2], alpha);
}
else
{
GL.EnableClientState(ArrayCap.ColorArray);
new Pinnable(colorArrayBuf.Array, (ptr) =>
{
GL.ColorPointer(4, ColorPointerType.Float, 0, ptr);
});
SingleBuffer color = colorArrayBuf;
var j = 0;
for (i = 0; i < paliashdr.num_xyz; i++)
{
l = shadedots[(v[i] >> 24) & 0xFF];
color.Put(j++, l * shadelight[0]);
color.Put(j++, l * shadelight[1]);
color.Put(j++, l * shadelight[2]);
color.Put(j++, alpha);
}
}
//if (qglLockArraysEXT)
// gl.GlLockArraysEXT(0, paliashdr.num_xyz);
while (true)
{
count = order[orderIndex++];
if (count == 0)
{
break;
}
if (count < 0)
{
count = -count;
GL.Begin(PrimitiveType.TriangleFan);
}
else
{
GL.Begin(PrimitiveType.TriangleStrip);
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
do
{
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.ArrayElement(index_xyz);
}while (--count != 0);
}
else
{
do
{
GL.TexCoord2(BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 0])), BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 1])));
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.ArrayElement(index_xyz);
}while (--count != 0);
}
GL.End();
}
// if (qglLockArraysEXT)
// gl.GlUnlockArraysEXT();
}
else
{
GL_LerpVerts(paliashdr.num_xyz, ov, v, s_lerped, move, frontv, backv);
Single[] tmp;
while (true)
{
count = order[orderIndex++];
if (count == 0)
{
break;
}
if (count < 0)
{
count = -count;
GL.Begin(PrimitiveType.TriangleFan);
}
else
{
GL.Begin(PrimitiveType.TriangleStrip);
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE)) != 0)
{
do
{
index_xyz = order[orderIndex + 2];
orderIndex += 3;
GL.Color4(shadelight[0], shadelight[1], shadelight[2], alpha);
tmp = s_lerped[index_xyz];
GL.Vertex3(tmp[0], tmp[1], tmp[2]);
}while (--count != 0);
}
else
{
do
{
GL.TexCoord2(BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 0])), BitConverter.ToSingle(BitConverter.GetBytes(order[orderIndex + 1])));
index_xyz = order[orderIndex + 2];
orderIndex += 3;
l = shadedots[(v[index_xyz] >> 24) & 0xFF];
GL.Color4(l * shadelight[0], l * shadelight[1], l * shadelight[2], alpha);
tmp = s_lerped[index_xyz];
GL.Vertex3(tmp[0], tmp[1], tmp[2]);
}while (--count != 0);
}
GL.End();
}
}
if ((currententity.flags & (Defines.RF_SHELL_RED | Defines.RF_SHELL_GREEN | Defines.RF_SHELL_BLUE | Defines.RF_SHELL_DOUBLE | Defines.RF_SHELL_HALF_DAM)) != 0)
{
GL.Enable(EnableCap.Texture2D);
}
}
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (material == null)
{
Graphics.Blit(source, destination);
return;
}
//Setup
material.SetMatrix("_CameraFrustumPlanes", GetCameraFrustumPlanes());
material.SetMatrix("_CameraToWorldMatrix", myCamera.cameraToWorldMatrix);
material.SetFloat("_MaxDistance", m_maxDistance);
material.SetInt("_MaxIterations", m_maxIterations);
material.SetFloat("_Accuracy", m_accuracy);
//Color
material.SetColor("_MainColor", m_mainColor);
//Light
material.SetVector("_LightDir", m_lightTransform.forward);
material.SetColor("_LightCol", m_lightColor);
material.SetFloat("_LightIntensity", m_lightIntensity);
//Shadow
material.SetVector("_ShadowDistance", m_shadowDistance);
material.SetFloat("_ShadowIntensity", m_shadowIntensity);
material.SetFloat("_ShadowPenumbra", _shadowPenumbra);
//Ambient Occlusion
material.SetFloat("_AOStepSize", m_ambientOcclusionStepSize);
material.SetInt("_AOIterations", m_ambientOcclusionIterations);
material.SetFloat("_AOIntensity", m_ambientOcclusionIntensity);
//Reflection
material.SetInt("_ReflectionCount", m_reflectionCount);
material.SetFloat("_ReflectionIntensity", m_reflectionIntensity);
material.SetFloat("_EnvironmentReflectionIntensity", m_environmentReflectionIntensity);
material.SetTexture("_ReflectionCube", m_reflectionCube);
//SDF
material.SetFloat("_Smooth", m_smooth);
material.SetVector("_GroundPosition", m_groundPosition);
material.SetVector("_GroundColor", m_groundColor);
for (int i = 0; i < m_colors.Length; i++)
{
m_colors[i] = m_sphereGradient.Evaluate(i * 1f / (m_colors.Length - 1));
}
material.SetColorArray("_SphereColors", m_colors);
RenderTexture.active = destination;
material.SetTexture("_MainTex", source);
GL.PushMatrix();
GL.LoadOrtho();
material.SetPass(0);
GL.Begin(GL.QUADS);
//BL
GL.MultiTexCoord2(0, 0, 0);
GL.Vertex3(0, 0, 3);
//BR
GL.MultiTexCoord2(0, 1, 0);
GL.Vertex3(1, 0, 2);
//TR
GL.MultiTexCoord2(0, 1, 1);
GL.Vertex3(1, 1, 1);
//TL
GL.MultiTexCoord2(0, 0, 1);
GL.Vertex3(0, 1, 0);
GL.End();
GL.PopMatrix();
}
protected void DrawBorder(RenderTexture dest, Material material)
{
float x1;
float x2;
float y1;
float y2;
RenderTexture.active = dest;
bool invertY = true; // source.texelSize.y < 0.0ff;
// Set up the simple Matrix
GL.PushMatrix();
GL.LoadOrtho();
for (int i = 0; i < material.passCount; ++i)
{
material.SetPass(i);
float y1_; float y2_;
if (invertY)
{
y1_ = 1.0f; y2_ = 0.0f;
}
else
{
y1_ = 0.0f; y2_ = 1.0f;
}
// left
x1 = 0.0f;
x2 = 0.0f + 1.0f / (dest.width * 1.0f);
y1 = 0.0f;
y2 = 1.0f;
GL.Begin(GL.QUADS);
GL.TexCoord2(0.0f, y1_); GL.Vertex3(x1, y1, 0.1f);
GL.TexCoord2(1.0f, y1_); GL.Vertex3(x2, y1, 0.1f);
GL.TexCoord2(1.0f, y2_); GL.Vertex3(x2, y2, 0.1f);
GL.TexCoord2(0.0f, y2_); GL.Vertex3(x1, y2, 0.1f);
// right
x1 = 1.0f - 1.0f / (dest.width * 1.0f);
x2 = 1.0f;
y1 = 0.0f;
y2 = 1.0f;
GL.TexCoord2(0.0f, y1_); GL.Vertex3(x1, y1, 0.1f);
GL.TexCoord2(1.0f, y1_); GL.Vertex3(x2, y1, 0.1f);
GL.TexCoord2(1.0f, y2_); GL.Vertex3(x2, y2, 0.1f);
GL.TexCoord2(0.0f, y2_); GL.Vertex3(x1, y2, 0.1f);
// top
x1 = 0.0f;
x2 = 1.0f;
y1 = 0.0f;
y2 = 0.0f + 1.0f / (dest.height * 1.0f);
GL.TexCoord2(0.0f, y1_); GL.Vertex3(x1, y1, 0.1f);
GL.TexCoord2(1.0f, y1_); GL.Vertex3(x2, y1, 0.1f);
GL.TexCoord2(1.0f, y2_); GL.Vertex3(x2, y2, 0.1f);
GL.TexCoord2(0.0f, y2_); GL.Vertex3(x1, y2, 0.1f);
// bottom
x1 = 0.0f;
x2 = 1.0f;
y1 = 1.0f - 1.0f / (dest.height * 1.0f);
y2 = 1.0f;
GL.TexCoord2(0.0f, y1_); GL.Vertex3(x1, y1, 0.1f);
GL.TexCoord2(1.0f, y1_); GL.Vertex3(x2, y1, 0.1f);
GL.TexCoord2(1.0f, y2_); GL.Vertex3(x2, y2, 0.1f);
GL.TexCoord2(0.0f, y2_); GL.Vertex3(x1, y2, 0.1f);
GL.End();
}
GL.PopMatrix();
}
public void DrawImpactFactors(DrawMethodArgs args)
{
PhysicsScene scene = demo.Engine.Factory.PhysicsSceneManager.Get(args.OwnerSceneIndex);
PhysicsObject objectBase = scene.Factory.PhysicsObjectManager.Get(args.OwnerIndex);
if (!objectBase.Camera.Enabled)
{
return;
}
if (!objectBase.Camera.Active)
{
return;
}
if (!enableDrawImpactFactors)
{
return;
}
GL.Disable(EnableCap.DepthTest);
GL.DepthMask(false);
float time = args.Time;
PhysicsObject visiblePhysicsObject;
int contactPointCount;
Vector3 start1, end1, start2, end2;
float impactFactor, velocityMagnitude;
objectBase.Camera.View.GetViewMatrix(ref view);
objectBase.Camera.Projection.GetProjectionMatrix(ref projection);
world = matrixIdentity;
render.SetWorld(ref world);
render.SetView(ref view);
render.SetProjection(ref projection);
render.Apply();
for (int i = 0; i < objectBase.Camera.VisiblePhysicsObjectCount; i++)
{
visiblePhysicsObject = objectBase.Camera.GetVisiblePhysicsObject(i);
for (int j = 0; j < visiblePhysicsObject.CollisionPairCount; j++)
{
contactPointCount = visiblePhysicsObject.GetCollisionPairContactPointCount(j);
for (int k = 0; k < contactPointCount; k++)
{
visiblePhysicsObject.GetCollisionPairContactPointAnchor2(j, k, ref position);
visiblePhysicsObject.GetCollisionPairContactPointNormal(j, k, ref direction);
impactFactor = visiblePhysicsObject.GetCollisionPairContactPointImpactFactor(j, k);
velocityMagnitude = Math.Min(Math.Max(visiblePhysicsObject.MainWorldTransform.GetLinearVelocityMagnitude() - visiblePhysicsObject.MaxSleepLinearVelocity, 0.0f) + Math.Max(visiblePhysicsObject.MainWorldTransform.GetAngularVelocityMagnitude() - visiblePhysicsObject.MaxSleepAngularVelocity, 0.0f), 1.0f);
impactFactor *= velocityMagnitude;
if (impactFactor < 0.001f)
{
continue;
}
Vector3.Multiply(ref direction, (float)impactFactor, out direction);
Vector3.Multiply(ref direction, 0.5f, out direction);
start1 = position;
end1 = direction;
Vector3.Add(ref start1, ref end1, out end1);
start2 = end1;
end2 = direction;
Vector3.Add(ref start2, ref end2, out end2);
GL.Begin(PrimitiveType.Lines);
GL.Color3(1.0f, 1.0f, 1.0f);
GL.Vertex3(start1);
GL.Vertex3(end1);
GL.Color3(0.6f, 0.8f, 0.2f);
GL.Vertex3(start2);
GL.Vertex3(end2);
GL.End();
}
}
}
GL.DepthMask(true);
GL.Enable(EnableCap.DepthTest);
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
if (this.DesignMode)
{
e.Graphics.Clear(Color.Black);
return;
}
GL.Viewport(0, 0, this.Width, this.Height);
// radians += 5 * deg2rad;
if (rotatewithdata)
{
yaw += 5 * deg2rad;
}
MakeCurrent();
GL.MatrixMode(MatrixMode.Projection);
double max = Math.Max(Math.Max((maxx - minx) / 2, (maxy - miny) / 2), (maxz - minz) / 2);
if (max < 300)
{
max = 400;
}
max *= 1.3;
if (points.Count > 0)
{
Vector3 current = new Vector3(points[points.Count - 1].X, points[points.Count - 1].Y, points[points.Count - 1].Z);
//yaw = Math.Atan2(points[points.Count - 1].X, points[points.Count - 1].Y);
}
OpenTK.Matrix4 projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView((float)(45 * deg2rad), 1f, 0.00001f, 5000.0f);
GL.LoadMatrix(ref projection);
float eyedist = (float)max * 3;
// Z X Y
eye = Vector3.TransformPosition(eye, Matrix4.CreateRotationZ((float)yaw));
yaw = 0;
pitch = 0;
if (float.IsNaN(eye.X))
{
eye = new Vector3(1, 1, 1);
}
eye.Normalize();
eye *= eyedist;
//Console.WriteLine("eye "+ eye.ToString());
//(maxx + minx) / 2, (maxy + miny) / 2, (maxz + minz) / 2
Matrix4 modelview = Matrix4.LookAt(eye.X, eye.Y, eye.Z, 0, 0, 0, 0, 0, 1); // CenterPoint.X, CenterPoint.Y, CenterPoint.Z
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadMatrix(ref modelview);
GL.ClearColor(Color.Black);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
// 3
GL.PointSize(8);
GL.Begin(PrimitiveType.Lines);
// +tivs
GL.Color3(Color.FromArgb(0, 0, 255));
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, max);
GL.Color3(Color.FromArgb(0, 255, 0));
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, max, 0);
GL.Color3(Color.FromArgb(255, 0, 0));
GL.Vertex3(0, 0, 0);
GL.Vertex3(max, 0, 0);
// -atives
GL.Color3(Color.FromArgb(255, 255, 0));
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, 0, -max);
GL.Color3(Color.FromArgb(255, 0, 255));
GL.Vertex3(0, 0, 0);
GL.Vertex3(0, -max, 0);
GL.Color3(Color.FromArgb(0, 255, 255));
GL.Vertex3(0, 0, 0);
GL.Vertex3(-max, 0, 0);
GL.End();
//GL.Rotate(Pitch, 0, 0, 0);
//GL.Rotate(Roll, 0, 0, 0);
// GL.Rotate(Yaw, 0, 0, 0);
GL.Begin(PrimitiveType.Points);
lock (points)
{
foreach (var item in points)
{
float rangex = maxx - minx;
float rangey = maxy - miny;
float rangez = maxz - minz;
int valuex = (int)Math.Abs((((item.X) / rangex) * 254)) & 0xff;
int valuey = (int)Math.Abs((((item.Y) / rangey) * 254)) & 0xff;
int valuez = (int)Math.Abs((((item.Z) / rangez) * 254)) & 0xff;
Color col = Color.FromArgb(valuex, valuey, valuez);
GL.Color3(col);
Vector3 vec = new Vector3(item.X, item.Y, item.Z) + CenterPoint;
GL.Vertex3(vec);
}
lock (aimpoints)
{
foreach (var aim in aimpoints)
{
GL.PointSize(8);
GL.Color3(Color.White);
GL.Vertex3(new Vector3(aim.X, aim.Y, aim.Z) + CenterPoint);
}
}
GL.End();
// 8
GL.PointSize(12);
GL.Begin(PrimitiveType.Points);
GL.Color3(Color.Red);
if (points.Count > 0)
{
GL.Vertex3(new Vector3(points[points.Count - 1].X, points[points.Count - 1].Y, points[points.Count - 1].Z) + CenterPoint);
}
}
GL.End();
Console.WriteLine(Math.Atan2(eye.Y, eye.X));
//float newyaw = 0 * deg2rad;
//DrawCircle(CenterPoint.X, CenterPoint.Y, CenterPoint.Z, newyaw, (float)(max), 60);
this.SwapBuffers();
}
public override void Render(ref SSRenderConfig renderConfig)
{
UpdateTexture();
base.Render(ref renderConfig);
SSShaderProgram.DeactivateAll(); // disable GLSL
// mode setup
// GL.PixelStore(PixelStoreParameter.UnpackAlignment, 1);
// Step 2: setup our material mode and paramaters...
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.Lighting);
if (hasAlpha)
{
GL.Enable(EnableCap.AlphaTest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
}
else
{
GL.Disable(EnableCap.AlphaTest);
GL.Disable(EnableCap.Blend);
}
// setup our texture source
if (textureSurface != null)
{
GL.ActiveTexture(TextureUnit.Texture0);
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, textureSurface.TextureID);
}
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (float)TextureMagFilter.Nearest);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (float)TextureMinFilter.Nearest);
// draw text rectangle...
GL.Begin(PrimitiveType.Triangles);
GL.Color3(Color.White); // clear the vertex color to white..
float w = gdiSize.Width;
float h = gdiSize.Height;
if (gdiSize != textureSize)
{
// adjust texture coordinates
throw new Exception("not implemented");
}
// upper-left
GL.TexCoord2(0.0, 0.0); GL.Vertex3(0.0, 0.0, 0.0);
GL.TexCoord2(1.0, 0.0); GL.Vertex3(w, 0.0, 0.0);
GL.TexCoord2(0.0, 1.0); GL.Vertex3(0.0, h, 0.0);
// lower-right
GL.TexCoord2(0.0, 1.0); GL.Vertex3(0.0, h, 0.0);
GL.TexCoord2(1.0, 0.0); GL.Vertex3(w, 0.0, 0.0);
GL.TexCoord2(1.0, 1.0); GL.Vertex3(w, h, 0.0);
GL.End();
}
public override bool ImageEffect_RenderImage(RenderTexture source, RenderTexture destination, RenderBuffer depthBuffer)
{
if (!ImageEffects.ImageEffectManager.AdvanceImangeEffectEnabled)
{
return(false);
}
if (CheckResources() == false || !IsOnValidLOD())
{
return(false);
}
//根据人物距离控制强度，如果足够远就关闭
float fallOff = 0;
if (hasArea)
{
ImageEffectManager result = null;
ImageEffectManager.ImageEffectManagerTable.TryGetValue(m_Camera, out result);
if (result != null)
{
if (result.hero != null)
{
float distance = GetDistanceToOBB(result.hero.transform.position);
fallOff = distance / maxDistance;
fallOff = Mathf.Clamp01(fallOff);
//Debug.Log("sun distance: " + distance);
}
}
//Debug.Log("sun fallOff: " + fallOff);
}
int divider = 4;
if (resolution == SunShaftsResolution.Normal)
{
divider = 2;
}
else if (resolution == SunShaftsResolution.High)
{
divider = 1;
}
Vector3 v = Vector3.one * 0.5f;
if (sunTransform)
{
v = m_Camera.WorldToViewportPoint(sunTransform.position);
}
else
{
v = new Vector3(0.5f, 0.5f, 0.0f);
}
if (v.x < -0.15 || v.x > 1.15 || v.y < -0.15 || v.y > 1.15 || fallOff >= 1)
{
return(false);
}
int rtW = source.width / divider;
int rtH = source.height / divider;
RenderTexture lrColorB;
RenderTexture lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0);
// mask out everything except the skybox
// we have 2 methods, one of which requires depth buffer support, the other one is just comparing images
sunShaftsMaterial.SetVector("_BlurRadius4", new Vector4(1.0f, 1.0f, 0.0f, 0.0f) * sunShaftBlurRadius);
sunShaftsMaterial.SetVector("_SunPosition", new Vector4(v.x, v.y, v.z, maxRadius));
sunShaftsMaterial.SetVector("_SunThreshold", sunThreshold);
var skybox = RenderSettings.skybox;
if (skybox != null && skyMask != null && canUseMask)
{
sunShaftsMaterial.SetTexture("_SkyCubemap", skyMask);
sunShaftsMaterial.SetColor("_SkyTint", skybox.GetColor("_Tint"));
sunShaftsMaterial.SetFloat("_SkyExposure", skybox.GetFloat("_Exposure"));
sunShaftsMaterial.SetFloat("_SkyRotation", skybox.GetFloat("_Rotation"));
sunShaftsMaterial.EnableKeyword("ENABLE_SKY_MASK");
}
else
{
sunShaftsMaterial.DisableKeyword("ENABLE_SKY_MASK");
}
//Graphics.Blit(source, lrDepthBuffer, sunShaftsMaterial, 2);
var cam = m_Camera;
var camtr = cam.transform;
var camNear = cam.nearClipPlane;
var camFar = cam.farClipPlane;
var tanHalfFov = Mathf.Tan(cam.fieldOfView * Mathf.Deg2Rad / 2);
var toRight = camtr.right * camNear * tanHalfFov * cam.aspect;
var toTop = camtr.up * camNear * tanHalfFov;
var v_tl = camtr.forward * camNear - toRight + toTop;
var v_tr = camtr.forward * camNear + toRight + toTop;
var v_br = camtr.forward * camNear + toRight - toTop;
var v_bl = camtr.forward * camNear - toRight - toTop;
var v_s = v_tl.magnitude * camFar / camNear;
// Draw screen quad.
RenderTexture.active = lrDepthBuffer;
sunShaftsMaterial.SetTexture("_MainTex", source);
sunShaftsMaterial.SetPass(2);
GL.PushMatrix();
GL.LoadOrtho();
GL.Begin(GL.QUADS);
GL.MultiTexCoord2(0, 0, 0);
GL.MultiTexCoord(1, v_bl.normalized * v_s);
GL.Vertex3(0, 0, 0.1f);
GL.MultiTexCoord2(0, 1, 0);
GL.MultiTexCoord(1, v_br.normalized * v_s);
GL.Vertex3(1, 0, 0.1f);
GL.MultiTexCoord2(0, 1, 1);
GL.MultiTexCoord(1, v_tr.normalized * v_s);
GL.Vertex3(1, 1, 0.1f);
GL.MultiTexCoord2(0, 0, 1);
GL.MultiTexCoord(1, v_tl.normalized * v_s);
GL.Vertex3(0, 1, 0.1f);
GL.End();
GL.PopMatrix();
// radial blur:
radialBlurIterations = Mathf.Clamp(radialBlurIterations, 1, 4);
float ofs = sunShaftBlurRadius * (1.0f / 768.0f);
sunShaftsMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
sunShaftsMaterial.SetVector("_SunPosition", new Vector4(v.x, v.y, v.z, maxRadius));
for (int it2 = 0; it2 < radialBlurIterations; it2++)
{
// each iteration takes 2 * 6 samples
// we update _BlurRadius each time to cheaply get a very smooth look
lrColorB = RenderTexture.GetTemporary(rtW, rtH, 0);
Graphics.Blit(lrDepthBuffer, lrColorB, sunShaftsMaterial, 1);
RenderTexture.ReleaseTemporary(lrDepthBuffer);
ofs = sunShaftBlurRadius * (((it2 * 2.0f + 1.0f) * 6.0f)) / 768.0f;
sunShaftsMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0);
Graphics.Blit(lrColorB, lrDepthBuffer, sunShaftsMaterial, 1);
RenderTexture.ReleaseTemporary(lrColorB);
ofs = sunShaftBlurRadius * (((it2 * 2.0f + 2.0f) * 6.0f)) / 768.0f;
sunShaftsMaterial.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
}
// put together:
//if (v.z >= 0.0f)
sunShaftsMaterial.SetVector("_SunColor", new Vector4(sunColor.r, sunColor.g, sunColor.b, sunColor.a) * sunShaftIntensity * (1 - fallOff));
//else
// sunShaftsMaterial.SetVector ("_SunColor", Vector4.zero); // no backprojection !
sunShaftsMaterial.SetTexture("_ColorBuffer", lrDepthBuffer);
Graphics.Blit(source, destination, sunShaftsMaterial, 0);
RenderTexture.ReleaseTemporary(lrDepthBuffer);
return(true);
}
/// <summary>
/// Draw a mesh using either its given material or a transparent "ghost" material.
/// </summary>
/// <param name="node">Current node</param>
/// <param name="animated">Specifies whether animations should be played</param>
/// <param name="showGhost">Indicates whether to substitute the mesh' material with a
/// "ghost" surrogate material that allows looking through the geometry.</param>
/// <param name="index">Mesh index in the scene</param>
/// <param name="mesh">Mesh instance</param>
/// <param name="flags"> </param>
/// <returns></returns>
protected override bool InternDrawMesh(Node node, bool animated, bool showGhost, int index, Mesh mesh, RenderFlags flags)
{
if (showGhost)
{
Owner.MaterialMapper.ApplyGhostMaterial(mesh, Owner.Raw.Materials[mesh.MaterialIndex],
flags.HasFlag(RenderFlags.Shaded), flags.HasFlag(RenderFlags.ForceTwoSidedLighting));
}
else
{
Owner.MaterialMapper.ApplyMaterial(mesh, Owner.Raw.Materials[mesh.MaterialIndex],
flags.HasFlag(RenderFlags.Textured),
flags.HasFlag(RenderFlags.Shaded), flags.HasFlag(RenderFlags.ForceTwoSidedLighting));
}
if (GraphicsSettings.Default.BackFaceCulling)
{
GL.FrontFace(FrontFaceDirection.Ccw);
GL.CullFace(CullFaceMode.Back);
GL.Enable(EnableCap.CullFace);
}
else
{
GL.Disable(EnableCap.CullFace);
}
var hasColors = mesh.HasVertexColors(0);
var hasTexCoords = mesh.HasTextureCoords(0);
var skinning = mesh.HasBones && animated;
foreach (var face in mesh.Faces)
{
BeginMode faceMode;
switch (face.IndexCount)
{
case 1:
faceMode = BeginMode.Points;
break;
case 2:
faceMode = BeginMode.Lines;
break;
case 3:
faceMode = BeginMode.Triangles;
break;
default:
faceMode = BeginMode.Polygon;
break;
}
GL.Begin(faceMode);
for (var i = 0; i < face.IndexCount; i++)
{
var indice = face.Indices[i];
if (hasColors)
{
var vertColor = AssimpToOpenTk.FromColor(mesh.VertexColorChannels[0][indice]);
GL.Color4(vertColor);
}
if (mesh.HasNormals)
{
Vector3 normal;
if (skinning)
{
Skinner.GetTransformedVertexNormal(node, mesh, (uint)indice, out normal);
}
else
{
normal = AssimpToOpenTk.FromVector(mesh.Normals[indice]);
}
GL.Normal3(normal);
}
if (hasTexCoords)
{
var uvw = AssimpToOpenTk.FromVector(mesh.TextureCoordinateChannels[0][indice]);
GL.TexCoord2(uvw.X, 1 - uvw.Y);
}
Vector3 pos;
if (skinning)
{
Skinner.GetTransformedVertexPosition(node, mesh, (uint)indice, out pos);
}
else
{
pos = AssimpToOpenTk.FromVector(mesh.Vertices[indice]);
}
GL.Vertex3(pos);
}
GL.End();
}
GL.Disable(EnableCap.CullFace);
return(skinning);
}
private void drawTexturedQuads()
{
GL.Enable(EnableCap.Texture2D);
GL.Enable(EnableCap.Blend);
GL.Enable(EnableCap.DepthTest);
GL.BindTexture(TextureTarget.Texture2D, textureIdCastle);
GL.Begin(BeginMode.Quads);
/*GL.Color3(1.0f, 1.0f, 1.0f);*/ GL.TexCoord2(0, 1); GL.Vertex3(-1.0f, -2.0f, 2.0f);
/*GL.Color3(1.0f, 1.0f, 1.0f);*/ GL.TexCoord2(1, 1); GL.Vertex3(1.0f, -2.0f, 2.0f);
/*GL.Color3(1.0f, 1.0f, 1.0f);*/ GL.TexCoord2(1, 0); GL.Vertex3(1.0f, 2.0f, 2.0f);
/*GL.Color3(1.0f, 1.0f, 1.0f);*/ GL.TexCoord2(0, 0); GL.Vertex3(-1.0f, 2.0f, 2.0f);
GL.End();
GL.BindTexture(TextureTarget.Texture2D, textureIdGrid);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//GL.Begin(BeginMode.Quads);
//for (int i = 10; i > -5; i -= 2)
//{
// GL.TexCoord2(0, 1); GL.Vertex3((-i), -1.0f, 3.9f);
// GL.TexCoord2(1, 1); GL.Vertex3((-i) + 2, -1.0f, 3.9f);
// GL.TexCoord2(1, 0); GL.Vertex3((-i) + 2, 1.0f, 3.9f);
// GL.TexCoord2(0, 0); GL.Vertex3((-i), 1.0f, 3.9f);
//}
//for (int i = 10; i > -5; i -= 2)
//{
// GL.TexCoord2(0, 1); GL.Vertex3((-i) + 1, -2.5f, 4.9f);
// GL.TexCoord2(1, 1); GL.Vertex3((-i) + 2 + 1, -2.5f, 4.9f);
// GL.TexCoord2(1, 0); GL.Vertex3((-i) + 2 + 1, -0.5f, 4.9f);
// GL.TexCoord2(0, 0); GL.Vertex3((-i) + 1, -0.5f, 4.9f);
//}
//for (int i = 10; i > -5; i -= 2)
//{
// GL.TexCoord2(0, 1); GL.Vertex3((-i), -4.0f, 5.9f);
// GL.TexCoord2(1, 1); GL.Vertex3((-i) + 2, -4.0f, 5.9f);
// GL.TexCoord2(1, 0); GL.Vertex3((-i) + 2, -2.0f, 5.9f);
// GL.TexCoord2(0, 0); GL.Vertex3((-i), -2.0f, 5.9f);
//}
//for (int i = 10; i > -5; i -= 2)
//{
// GL.TexCoord2(0, 1); GL.Vertex3((-i) + 1, -5.5f, 6.9f);
// GL.TexCoord2(1, 1); GL.Vertex3((-i) + 2 + 1, -5.5f, 6.9f);
// GL.TexCoord2(1, 0); GL.Vertex3((-i) + 2 + 1, -3.5f, 6.9f);
// GL.TexCoord2(0, 0); GL.Vertex3((-i) + 1, -3.5f, 6.9f);
//}
//GL.End();
GL.BindTexture(TextureTarget.Texture2D, textureIdHouse);
GL.Begin(BeginMode.Quads);
for (int i = 10; i > -5; i -= 2)
{
GL.TexCoord2(0, 1); GL.Vertex3((-i), -4.0f, 6.9f);
GL.TexCoord2(1, 1); GL.Vertex3((-i) + 2, -4.0f, 6.9f);
GL.TexCoord2(1, 0); GL.Vertex3((-i) + 2, -2.0f, 6.9f);
GL.TexCoord2(0, 0); GL.Vertex3((-i), -2.0f, 6.9f);
}
GL.End();
float h = 4;
float r = 0.866025f;
float s = 8;
for (int row = 0; row < 12; row++)
{
int v = row & 1;
GL.BindTexture(TextureTarget.Texture2D, textureIdGrass);
GL.Begin(PrimitiveType.Quads);
for (int i = 0; i < 20; i += 1)
{
GL.TexCoord2(0, 1); GL.Vertex3((i * 34 * r + (row & 1) * r * 16), row * (h + s) * 2, 6.9f + row * 0.1);
GL.TexCoord2(1, 1); GL.Vertex3((i * 34 * r + (row & 1) * r * 16 + 32), row * (h + s) * 2, 6.9f + row * 0.1);
GL.TexCoord2(1, 0); GL.Vertex3((i * 34 * r + (row & 1) * r * 16 + 32), row * (h + s) * 2 + 32, 6.9f + row * 0.1);
GL.TexCoord2(0, 0); GL.Vertex3((i * 34 * r + (row & 1) * r * 16), row * (h + s) * 2 + 32, 6.9f + row * 0.1);
}
GL.End();
}
GL.BindTexture(TextureTarget.Texture2D, textureIdHouse);
GL.Begin(BeginMode.Quads);
//for (int i = 0; i < 10; i += 1)
//{
// GL.TexCoord2(0, 1); GL.Vertex3((i * 64), 64.0f, 17.9f);
// GL.TexCoord2(1, 1); GL.Vertex3((i * 64) + 64, 64.0f, 17.9f);
// GL.TexCoord2(1, 0); GL.Vertex3((i * 64) + 64, 0.0f, 17.9f);
// GL.TexCoord2(0, 0); GL.Vertex3((i * 64), 0.0f, 17.9f);
//}
GL.End();
}
protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
{
if (this.DesignMode)
{
return;
}
if (area.LocationMiddle.Lat == 0 && area.LocationMiddle.Lng == 0)
{
return;
}
try
{
base.OnPaint(e);
}
catch { return; }
double heightscale = (step / 90.0) * 1;
float yawradians = (float)(Math.PI * (rpy.Z * 1) / 180.0f);
//radians = 0;
float mouseY = (float)step / 10f;
cameraX = center.Lng; // -Math.Sin(yawradians) * mouseY; // multiplying by mouseY makes the
cameraY = center.Lat; // -Math.Cos(yawradians) * mouseY; // camera get closer/farther away with mouseY
cameraZ = (center.Alt < srtm.getAltitude(center.Lat, center.Lng).alt) ? (srtm.getAltitude(center.Lat, center.Lng).alt + 1) * heightscale : center.Alt * heightscale; // (srtm.getAltitude(lookZ, lookX, 20) + 100) * heighscale;
lookX = center.Lng + Math.Sin(yawradians) * mouseY;
lookY = center.Lat + Math.Cos(yawradians) * mouseY;
lookZ = cameraZ;
// cameraZ += 0.04;
GMapProvider type = GMap.NET.MapProviders.GoogleSatelliteMapProvider.Instance;
PureProjection prj = type.Projection;
int size = (int)(cameraZ * 150000);
// in front
PointLatLngAlt leftf = center.newpos(rpy.Z, size);
// behind
PointLatLngAlt rightf = center.newpos(rpy.Z, 50);
// left : 90 allows for 180 degree viewing angle
PointLatLngAlt left = center.newpos(rpy.Z - 90, size);
// right
PointLatLngAlt right = center.newpos(rpy.Z + 90, size);
double maxlat = Math.Max(left.Lat, Math.Max(right.Lat, Math.Max(leftf.Lat, rightf.Lat)));
double minlat = Math.Min(left.Lat, Math.Min(right.Lat, Math.Min(leftf.Lat, rightf.Lat)));
double maxlng = Math.Max(left.Lng, Math.Max(right.Lng, Math.Max(leftf.Lng, rightf.Lng)));
double minlng = Math.Min(left.Lng, Math.Min(right.Lng, Math.Min(leftf.Lng, rightf.Lng)));
// if (Math.Abs(area.Lat - maxlat) < 0.001)
{
}
// else
{
area = RectLatLng.FromLTRB(minlng, maxlat, maxlng, minlat);
}
GPoint topLeftPx = prj.FromLatLngToPixel(area.LocationTopLeft, zoom);
GPoint rightButtomPx = prj.FromLatLngToPixel(area.Bottom, area.Right, zoom);
GPoint pxDelta = new GPoint(rightButtomPx.X - topLeftPx.X, rightButtomPx.Y - topLeftPx.Y);
zoom = 21;
pxDelta.X = 9999;
int otherzoomlevel = 12;
// zoom based on pixel density
while (pxDelta.X > this.Width)
{
zoom--;
// current area
topLeftPx = prj.FromLatLngToPixel(area.LocationTopLeft, zoom);
rightButtomPx = prj.FromLatLngToPixel(area.Bottom, area.Right, zoom);
pxDelta = new GPoint(rightButtomPx.X - topLeftPx.X, rightButtomPx.Y - topLeftPx.Y);
}
otherzoomlevel = zoom - 4;
Console.WriteLine("zoom {0}", zoom);
// update once per seconds - we only read from disk, so need to let cahce settle
if (lastrefresh.AddSeconds(0.5) < DateTime.Now)
{
// get tiles - bg
core.Provider = type;
core.Position = LocationCenter;
// get zoom 10
core.Zoom = otherzoomlevel;
core.OnMapSizeChanged(this.Width, this.Height);
// get actual current zoom
core.Zoom = zoom;
core.OnMapSizeChanged(this.Width, this.Height);
lastrefresh = DateTime.Now;
}
else
{
//return;
}
float screenscale = this.Width / (float)this.Height;
MakeCurrent();
GL.MatrixMode(MatrixMode.Projection);
OpenTK.Matrix4 projection = OpenTK.Matrix4.CreatePerspectiveFieldOfView(120 * deg2rad, screenscale, 0.00001f, (float)step * 20000);
GL.LoadMatrix(ref projection);
Matrix4 modelview = Matrix4.LookAt((float)cameraX, (float)cameraY, (float)cameraZ, (float)lookX, (float)lookY, (float)lookZ, 0, 0, 1);
GL.MatrixMode(MatrixMode.Modelview);
// roll
modelview = Matrix4.Mult(modelview, Matrix4.CreateRotationZ(rpy.X * deg2rad));
// pitch
modelview = Matrix4.Mult(modelview, Matrix4.CreateRotationX((rpy.Y - 15) * -deg2rad));
GL.LoadMatrix(ref modelview);
GL.ClearColor(Color.CornflowerBlue);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.AccumBufferBit);
GL.LightModel(LightModelParameter.LightModelAmbient, new float[] { 1f, 1f, 1f, 1f });
// GL.Disable(EnableCap.Fog);
GL.Enable(EnableCap.Fog);
//GL.Enable(EnableCap.Lighting);
//GL.Enable(EnableCap.Light0);
GL.Fog(FogParameter.FogColor, new float[] { 100 / 255.0f, 149 / 255.0f, 237 / 255.0f, 1f });
//GL.Fog(FogParameter.FogDensity,0.1f);
GL.Fog(FogParameter.FogMode, (int)FogMode.Linear);
GL.Fog(FogParameter.FogStart, (float)step * 40);
GL.Fog(FogParameter.FogEnd, (float)(step * 50));
// GL.Enable(EnableCap.DepthTest);
GL.DepthFunc(DepthFunction.Always);
/*
* GL.Begin(BeginMode.LineStrip);
*
* GL.Color3(Color.White);
* GL.Vertex3(0, 0, 0);
*
* //GL.Color3(Color.Red);
* GL.Vertex3(area.Bottom, 0, area.Left);
*
* //GL.Color3(Color.Yellow);
* GL.Vertex3(lookX, lookY, lookZ);
*
* //GL.Color3(Color.Green);
* GL.Vertex3(cameraX, cameraY, cameraZ);
*
* GL.End();
*/
/*
* GL.PointSize(10);
* GL.Color4(Color.Yellow);
* GL.LineWidth(5);
*
*
* GL.Begin(PrimitiveType.LineStrip);
*
* //GL.Vertex3(new Vector3((float)center.Lng,(float)center.Lat,(float)(center.Alt * heightscale)));
* //GL.Vertex3(new Vector3(0, 0, 0));
* //GL.Vertex3(new Vector3((float)cameraX, (float)cameraY, (float)cameraZ));
* //GL.Color3(Color.Green);
* //GL.Vertex3(new Vector3((float)lookX, (float)lookY, (float)lookZ));
*
* GL.Vertex3(area.LocationTopLeft.Lng, area.LocationTopLeft.Lat, (float)cameraZ);
* GL.Vertex3(area.LocationTopLeft.Lng, area.LocationRightBottom.Lat, (float)cameraZ);
* GL.Vertex3(area.LocationRightBottom.Lng, area.LocationRightBottom.Lat, (float)cameraZ);
* GL.Vertex3(area.LocationRightBottom.Lng, area.LocationTopLeft.Lat, (float)cameraZ);
* GL.Vertex3(area.LocationTopLeft.Lng, area.LocationTopLeft.Lat, (float)cameraZ);
*
* GL.End();
*/
GL.Finish();
GL.PointSize((float)(step * 1));
GL.Color3(Color.Blue);
GL.Begin(PrimitiveType.Points);
GL.Vertex3(new Vector3((float)center.Lng, (float)center.Lat, (float)cameraZ));
GL.End();
//GL.ClampColor(ClampColorTarget.ClampReadColor, ClampColorMode.True);
/*
* GL.Enable(EnableCap.Blend);
* GL.DepthMask(false);
* GL.BlendFunc(BlendingFactorSrc.Zero, BlendingFactorDest.Src1Color);
* GL.DepthMask(true);
* GL.Disable(EnableCap.Blend);
*/
// textureid.Clear();
// get level 10 tiles
List <GPoint> tileArea1 = prj.GetAreaTileList(area, otherzoomlevel, 1);
// get type list at new zoom level
List <GPoint> tileArea2 = prj.GetAreaTileList(area, zoom, 2);
List <GPoint> tileArea = new List <GPoint>();
tileArea.AddRange(tileArea1);
tileArea.AddRange(tileArea2);
// get tiles & combine into one
foreach (var p in tileArea)
{
int localzoom = zoom;
core.tileDrawingListLock.AcquireReaderLock();
core.Matrix.EnterReadLock();
try
{
if (tileArea1.Contains(p))
{
localzoom = otherzoomlevel;
}
topLeftPx = prj.FromLatLngToPixel(area.LocationTopLeft, localzoom);
GMap.NET.Internals.Tile t = core.Matrix.GetTileWithNoLock(localzoom, p);
if (t.NotEmpty)
{
foreach (GMapImage img in t.Overlays)
{
if (!textureid.ContainsKey(p))
{
generateTexture(p, (Bitmap)img.Img);
}
}
}
else
{
}
}
finally
{
core.Matrix.LeaveReadLock();
core.tileDrawingListLock.ReleaseReaderLock();
}
//GMapImage tile = ((PureImageCache)Maps.MyImageCache.Instance).GetImageFromCache(type.DbId, p, zoom) as GMapImage;
//if (tile != null && !textureid.ContainsKey(p))
{
// generateTexture(p, (Bitmap)tile.Img);
}
if (textureid.ContainsKey(p))
{
int texture = textureid[p];
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, texture);
}
else
{
//Console.WriteLine("Missing tile");
continue;
}
long x = p.X * prj.TileSize.Width - topLeftPx.X;
long y = p.Y * prj.TileSize.Width - topLeftPx.Y;
long xr = p.X * prj.TileSize.Width;
long yr = p.Y * prj.TileSize.Width;
long x2 = (p.X + 1) * prj.TileSize.Width;
long y2 = (p.Y + 1) * prj.TileSize.Width;
GL.LineWidth(0);
GL.Color3(Color.White);
// generate terrain
GL.Begin(PrimitiveType.TriangleStrip);
var latlng = prj.FromPixelToLatLng(xr, yr, localzoom);
double heightl = srtm.getAltitude(latlng.Lat, latlng.Lng).alt;
if (localzoom == 10)
{
heightl = 0;
}
//xr - topLeftPx.X, yr - topLeftPx.Y
GL.TexCoord2(0, 0);
GL.Vertex3(latlng.Lng, latlng.Lat, heightl * heightscale);
// next down
latlng = prj.FromPixelToLatLng(xr, y2, localzoom);
heightl = srtm.getAltitude(latlng.Lat, latlng.Lng).alt;
if (localzoom == 10)
{
heightl = 0;
}
GL.TexCoord2(0, 1);
GL.Vertex3(latlng.Lng, latlng.Lat, heightl * heightscale);
// next right
latlng = prj.FromPixelToLatLng(x2, yr, localzoom);
heightl = srtm.getAltitude(latlng.Lat, latlng.Lng).alt;
if (localzoom == 10)
{
heightl = 0;
}
GL.TexCoord2(1, 0);
GL.Vertex3(latlng.Lng, latlng.Lat, heightl * heightscale);
// next right down
latlng = prj.FromPixelToLatLng(x2, y2, localzoom);
heightl = srtm.getAltitude(latlng.Lat, latlng.Lng).alt;
if (localzoom == 10)
{
heightl = 0;
}
GL.TexCoord2(1, 1);
GL.Vertex3(latlng.Lng, latlng.Lat, heightl * heightscale);
GL.End();
}
GL.Flush();
try
{
this.SwapBuffers();
Context.MakeCurrent(null);
}
catch { }
//this.Invalidate();
return;
}
public override void Show(Main D)
{
GL.Begin(PrimitiveType.TriangleFan);
GL.Vertex2(MainCirclePosition);
for (int i = 0; i <= CircleSteps; i++)
{
float T = i / (float)CircleSteps;
double Angle = T * Math.PI * 2;
GL.Color4(GetColorFromPosition(T));
Vector2 V = new Vector2((float)Math.Sin(Angle), -(float)Math.Cos(Angle)) * MainCircleOuterRadius;
GL.Vertex2(V + MainCirclePosition);
}
GL.End();
GL.Begin(PrimitiveType.Triangles);
for (int i = 0; i < CurrentPaletteSize; i++)
{
double Angle = PalettePositions[i] * Math.PI * 2;
Vector2 V1 = new Vector2((float)Math.Sin(Angle - NodeWidth), -(float)Math.Cos(Angle - NodeWidth)) * MainCircleOuterRadius;
Vector2 V2 = new Vector2((float)Math.Sin(Angle + NodeWidth), -(float)Math.Cos(Angle + NodeWidth)) * MainCircleOuterRadius;
if (SelectedIndex == i)
{
V1 *= 1.1f;
V2 *= 1.1f;
}
GL.Color4(ColorPalette[i]);
GL.Vertex2(MainCirclePosition);
GL.Vertex2(MainCirclePosition + V1);
GL.Vertex2(MainCirclePosition + V2);
}
GL.End();
GL.LineWidth(2);
GL.Begin(PrimitiveType.Lines);
for (int i = 0; i < CurrentPaletteSize; i++)
{
double Angle = PalettePositions[i] * Math.PI * 2;
Vector2 V1 = new Vector2((float)Math.Sin(Angle - NodeWidth), -(float)Math.Cos(Angle - NodeWidth)) * MainCircleOuterRadius;
Vector2 V2 = new Vector2((float)Math.Sin(Angle + NodeWidth), -(float)Math.Cos(Angle + NodeWidth)) * MainCircleOuterRadius;
if (SelectedIndex == i)
{
V1 *= 1.1f;
V2 *= 1.1f;
}
GL.Color3(Color.LightGray);
GL.Vertex2(MainCirclePosition);
GL.Vertex2(MainCirclePosition + V1);
GL.Vertex2(MainCirclePosition);
GL.Vertex2(MainCirclePosition + V2);
}
GL.End();
/*if (IsHoldingCircle)
* {
* GL.Color3(Color.OrangeRed);
* }
* else
* {
* GL.Color4(InteriorColor);
* }*/
float Rad = InnerCircleRadius;
if (SelectedIndex == -1)
{
Rad *= 1.3f;
}
FillCircle(BackgroundColor, MainCircleInnerRadius);
FillCircle(InteriorColor, Rad);
DrawCircle(Color.LightGray, Rad);
IsDraggingCircle = false;
}
public override Image Render(RendererOptions options)
{
if (window == null)
{
int size = 1;
window = new GameWindow(size, size, new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 0, 0, ColorFormat.Empty, 1), "", GameWindowFlags.Default, DisplayDevice.Default, 3, 0, GraphicsContextFlags.Offscreen)
{
WindowState = WindowState.Fullscreen, Visible = false
};
window.TargetRenderPeriod = 1;
window.TargetUpdateFrequency = 1;
}
GL.ClearColor(Color.Transparent);
using (Bitmap sourceBitmap = CreateTextureBitmap(options))
{
BitmapData data;
int size = (int)options.OutputImageSize;
if (window.ClientSize.Width != size || window.ClientSize.Height != size)
{
window.ClientSize = new Size(size, size);
System.Windows.Application.Current.Dispatcher.Invoke(() => System.Windows.Application.Current.MainWindow?.Activate());
}
Rectangle rect = new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height);
data = sourceBitmap.LockBits(rect, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
double crds = 1;
GL.Viewport(0, 0, size, size);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(-crds, crds, -crds, crds, -crds, crds);
GL.Rotate(90, new Vector3d(0, 0, 1));
GL.Rotate(90 - options.LatitudeShift, new Vector3d(0, 1, 0));
GL.Rotate(-options.LongutudeShift, new Vector3d(0, 0, 1));
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Viewport(0, 0, size, size);
GL.Color3(Color.White);
GL.Disable(EnableCap.Lighting);
GL.DepthMask(true);
GL.Enable(EnableCap.DepthTest);
//GL.ClearDepth(1.0f);
GL.DepthFunc(DepthFunction.Lequal);
int nx, ny;
nx = 64;
ny = 64;
int texture;
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Fill);
GL.Enable(EnableCap.Texture2D);
GL.GenTextures(1, out texture);
GL.BindTexture(TextureTarget.Texture2D, texture);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
int ix, iy;
double x, y, z, sy, cy, sy1, cy1, sx, cx, piy, pix, ay, ay1, ax, tx, ty, ty1, dnx, dny, diy;
dnx = 1.0 / nx;
dny = 1.0 / ny;
GL.Begin(PrimitiveType.QuadStrip);
piy = Math.PI * dny;
pix = Math.PI * dnx;
for (iy = 0; iy < ny; iy++)
{
diy = iy;
ay = diy * piy;
sy = Math.Sin(ay);
cy = Math.Cos(ay);
ty = diy * dny;
ay1 = ay + piy;
sy1 = Math.Sin(ay1);
cy1 = Math.Cos(ay1);
ty1 = ty + dny;
for (ix = 0; ix <= nx; ix++)
{
ax = 2.0 * ix * pix;
sx = Math.Sin(ax);
cx = Math.Cos(ax);
x = sy * cx;
y = sy * sx;
z = cy;
tx = ix * dnx;
GL.TexCoord2(tx, ty);
GL.Vertex3(x, y, z);
x = sy1 * cx;
y = sy1 * sx;
z = cy1;
GL.TexCoord2(tx, ty1);
GL.Vertex3(x, y, z);
}
}
GL.End();
GL.Disable(EnableCap.Texture2D);
GL.DeleteTexture(texture);
sourceBitmap.UnlockBits(data);
return(GraphicsContextToBitmap(size));
}
}
public static void update()
{
deferred_action_run(); //Run deferred actions
TimeSpan span = DateTime.Now.Subtract(Graphics.last_frame_time);
if (span < frame_time)
{
Thread.Sleep(frame_time.Subtract(span));
}
Graphics.last_frame_time = DateTime.Now;
if (!Window.IsExiting)
{
Window.ProcessEvents();
}
frame_count++;
if (frozen)
{
return;
}
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
GL.ClearColor(0f, 0f, 0f, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit);
sort();
//Console.WriteLine("new frame ");
default_viewport.draw();
foreach (Viewport vp in viewports)
{
//Console.WriteLine("drawing viewport: " + vp.z);
//Console.WriteLine("Viewport z: " + vp.z + (vp.is_default ? " (default)" : ""));
vp.draw();
}
//brightness quad
if (brightness < 255)
{
GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
GL.Viewport(0, 0, Graphics.width, Graphics.height);
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(0, Graphics.width, Graphics.height, 0, -1, 1);
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, 0);
GL.Color4(0.0f, 0.0f, 0.0f, 1f - ((1f / 255f) * (float)brightness));
GL.Begin(BeginMode.Quads);
GL.Vertex3(0, 0, 0.1f);
GL.Vertex3(width, 0, 0.1f);
GL.Vertex3(width, height, 0.1f);
GL.Vertex3(0, height, 0.1f);
GL.End();
}
if (!Window.IsExiting)
{
Window.SwapBuffers();
}
}
protected void DrawScannerTable(Vector3d center)
{
List <Vector3d> circT = new List <Vector3d>(360);
List <Vector3d> circB = new List <Vector3d>(360);
List <Vector2d> text = new List <Vector2d>(360);
double h = 5;
for (int i = 0; i < 361; i++)
{
double ang = Utils.DEGREES_TO_RADIANS(i);
double x = -Math.Cos(ang);
double y = Math.Sin(ang);
text.Add(new Vector2d(x * TableRadius / 20.0, y * TableRadius / 20.0));
Vector3d t = new Vector3d(x * TableRadius, 0, y * TableRadius);
Vector3d b = new Vector3d(x * TableRadius, -h, y * TableRadius);
circT.Add(t + center);
circB.Add(b + center);
}
using (new GLEnable(EnableCap.Lighting))
{
GL.ColorMaterial(MaterialFace.FrontAndBack, ColorMaterialParameter.AmbientAndDiffuse);
using (new GLEnable(EnableCap.ColorMaterial))
{
GL.ShadeModel(Smooth ? ShadingModel.Smooth : ShadingModel.Flat);
GL.Color3(ForeColor.GetStepColor(BackColor, 0.5));
using (new GLEnable(EnableCap.CullFace))
{
GL.CullFace(CullFaceMode.Back);
GL.BindTexture(TextureTarget.Texture2D, this.ScannerTextureID);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear);
GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear);
using (new GLEnable(EnableCap.Blend))
{
GL.BlendFunc(BlendingFactorSrc.SrcColor, BlendingFactorDest.SrcColor);
using (new GLEnable(EnableCap.Texture2D))
{
GL.Begin(PrimitiveType.Polygon);
GL.Normal3(new Vector3d(0, 1, 0));
for (int i = 0; i < circT.Count; i++)
{
GL.TexCoord2(text[i]);
//GL.Normal3(new Vector3d(0, 1, 0));
GL.Vertex3(circT[i]);
}
GL.End();
double div = (TableRadius * 16 * Math.PI) / 360;
GL.Begin(PrimitiveType.TriangleStrip);
for (int i = 0; i < circT.Count; i++)
{
GL.Normal3(circT[i].Normalized());
GL.TexCoord2(new Vector2d(i / div, 0));
GL.Vertex3(circT[i]);
GL.TexCoord2(new Vector2d(i / div, 0.5));
GL.Vertex3(circB[i]);
}
GL.End();
GL.Begin(PrimitiveType.Polygon);
GL.Normal3(new Vector3d(0, -1, 0));
for (int i = circT.Count - 1; i >= 0; i--)
{
//GL.Normal3(new Vector3d(0, -1, 0));
GL.TexCoord2(text[i]);
GL.Vertex3(circB[i]);
}
GL.End();
GL.Color3(BackColor.ModifyLuminosity(0.1));
GL.Disable(EnableCap.Lighting);
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Blend);
GL.Begin(PrimitiveType.TriangleStrip);
for (int i = 0; i < circT.Count; i++)
{
Vector3d v = new Vector3d(circT[i]);
v.Y += TableHeight;
circB[i] = v;
GL.Vertex3(circT[i]);
GL.Vertex3(circB[i]);
}
GL.End();
GL.Begin(PrimitiveType.Polygon);
GL.Normal3(new Vector3d(0, -1, 0));
for (int i = circT.Count - 1; i >= 0; i--)
{
GL.Vertex3(circB[i]);
}
GL.End();
}
}
}
}
}
}
void RaycastCornerBlit(RenderTexture source, RenderTexture dest, Material mat)
{
// Compute Frustum Corners
float camFar = _camera.farClipPlane;
float camFov = _camera.fieldOfView;
float camAspect = _camera.aspect;
float fovWHalf = camFov * 0.5f;
Vector3 toRight = _camera.transform.right * Mathf.Tan(fovWHalf * Mathf.Deg2Rad) * camAspect;
Vector3 toTop = _camera.transform.up * Mathf.Tan(fovWHalf * Mathf.Deg2Rad);
Vector3 topLeft = (_camera.transform.forward - toRight + toTop);
float camScale = topLeft.magnitude * camFar;
topLeft.Normalize();
topLeft *= camScale;
Vector3 topRight = (_camera.transform.forward + toRight + toTop);
topRight.Normalize();
topRight *= camScale;
Vector3 bottomRight = (_camera.transform.forward + toRight - toTop);
bottomRight.Normalize();
bottomRight *= camScale;
Vector3 bottomLeft = (_camera.transform.forward - toRight - toTop);
bottomLeft.Normalize();
bottomLeft *= camScale;
// Custom Blit, encoding Frustum Corners as additional Texture Coordinates
RenderTexture.active = dest;
mat.SetTexture("_MainTex", source);
GL.PushMatrix();
GL.LoadOrtho();
mat.SetPass(0);
GL.Begin(GL.QUADS);
GL.MultiTexCoord2(0, 0.0f, 0.0f);
GL.MultiTexCoord(1, bottomLeft);
GL.Vertex3(0.0f, 0.0f, 0.0f);
GL.MultiTexCoord2(0, 1.0f, 0.0f);
GL.MultiTexCoord(1, bottomRight);
GL.Vertex3(1.0f, 0.0f, 0.0f);
GL.MultiTexCoord2(0, 1.0f, 1.0f);
GL.MultiTexCoord(1, topRight);
GL.Vertex3(1.0f, 1.0f, 0.0f);
GL.MultiTexCoord2(0, 0.0f, 1.0f);
GL.MultiTexCoord(1, topLeft);
GL.Vertex3(0.0f, 1.0f, 0.0f);
GL.End();
GL.PopMatrix();
}
