static void Main(string[] args) { Console.WriteLine("Sanity Check!"); Sender _sender = new Sender(); KeyboardInput _key = new KeyboardInput(); EventListener _listener = new EventListener(_key); vec3 start = vec3.Zero; vec3 end = new vec3(110.0f, 100.0f, 10.0f); float vel = 1f; bool complete = false; while (!complete) { MoveVector3(out complete, ref start, end, vel, AXIS.X); } Console.WriteLine("########################################################################"); Console.WriteLine("########### STOPPED SIM ###########"); Console.WriteLine("########################################################################"); _key.Send(); }
public ClockRenderer(vec3 worldPosition) { this.WorldPosition = worldPosition; const float factor = 0.5f; this.Scale = new vec3(factor, factor, factor); this.ModelSize = new vec3(2, 2, 2); }
public LinesBase(OpenGL gl, List<Tuple<vec3, vec3>> lines, Material material = null, OGLModelUsage usage = OGLModelUsage.StaticRead) { var verts = new vec3[lines.Count * 2]; var normals = new vec3[lines.Count * 2]; var indices = new uint[lines.Count * 2]; for (int i = 0; i < lines.Count; i++) { var i2 = i * 2; verts[i2] = lines[i].Item1; verts[i2 + 1] = lines[i].Item2; normals[i2] = new vec3(1, 1, 1); normals[i2 + 1] = new vec3(1, 1, 1); indices[i2] = (uint)i2; indices[i2 + 1] = (uint)(i2 + 1); } if (material != null) Material = material; Vertices = verts; Normals = normals; Indices = indices; GlDrawMode = OpenGL.GL_LINES; if (gl != null) GenerateGeometry(gl, usage); }
/// <summary> /// 判定三点是否共线。 /// </summary> /// <param name="walker"></param> /// <param name="start"></param> /// <param name="end"></param> /// <param name="percent">如果三点共线,<paramref name="percent"/>代表(<paramref name="walker"/> - <paramref name="start"/>)/(<paramref name="end"/> - <paramref name="start"/>)</param> /// <returns></returns> public static bool InTheSameLine(this vec3 walker, vec3 start, vec3 end, out float percent, float allowableError = 0.01f) { vec3 v1 = walker - start; vec3 v2 = end - start; var values = new List<float>(); for (int i = 0; i < 3; i++) { if (v2[i] == 0.0f) { if (v1[i] != 0.0f) { percent = 0; return false; } } else { values.Add(v1[i] / v2[i]); } } float average, variance; values.ToArray().AverageVariance(out average, out variance); if (variance <= allowableError) { percent = average; return true; } else { percent = 0; return false; } }
/// <summary> /// 链条。若干个点用直线连接起来。 /// </summary> /// <param name="pointCount">有多少个点</param> /// <param name="length">点的范围(长度)</param> /// <param name="width">点的范围(宽度)</param> /// <param name="height">点的范围(高度)</param> public ChainModel(int pointCount = 10, int length = 5, int width = 5, int height = 5) { var random = new Random(); var positions = new vec3[pointCount]; for (int i = 0; i < pointCount; i++) { var point = new vec3(); point.x = (float)random.NextDouble() * length; point.y = (float)random.NextDouble() * width; point.z = (float)random.NextDouble() * height; positions[i] = point; } BoundingBox box = positions.Move2Center(); this.Lengths = box.MaxPosition - box.MinPosition; this.Positions = positions; this.Colors = new vec3[pointCount]; { for (int i = 0; i < pointCount; i++) { uint p = (uint)((256 * 256 * 256) / pointCount * (i + 1)); var color = new vec3(); color.x = ((p >> 0) & 0xFF) / 255.0f; color.y = ((p >> 8) & 0xFF) / 255.0f; color.z = ((p >> 16) & 0xFF) / 255.0f; this.Colors[i] = color; } } }
public BrickFragmentShader(vec2 size, vec2 pct, vec3 brickColor, vec3 mortColor) { BrickSize = size; BrickPct = pct; BrickColor = brickColor; MortarColor = mortColor; }
public Entity(TexturedModel model, vec3 position, vec3 rot, float scale) { this.model = model; this.position = position; this.rot = rot; this.scale = scale; }
/// <summary> /// Build a look at view matrix. /// transform object's coordinate from world's space to camera's space. /// </summary> /// <param name="eye">The eye.</param> /// <param name="center">The center.</param> /// <param name="up">Up.</param> /// <returns></returns> public static mat4 lookAt(vec3 eye, vec3 center, vec3 up) { // camera's back in world space coordinate system vec3 back = (eye - center).normalize(); // camera's right in world space coordinate system vec3 right = up.cross(back).normalize(); // camera's up in world space coordinate system vec3 standardUp = back.cross(right); mat4 viewMatrix = new mat4(1); viewMatrix.col0.x = right.x; viewMatrix.col1.x = right.y; viewMatrix.col2.x = right.z; viewMatrix.col0.y = standardUp.x; viewMatrix.col1.y = standardUp.y; viewMatrix.col2.y = standardUp.z; viewMatrix.col0.z = back.x; viewMatrix.col1.z = back.y; viewMatrix.col2.z = back.z; // Translation in world space coordinate system viewMatrix.col3.x = -eye.dot(right); viewMatrix.col3.y = -eye.dot(standardUp); viewMatrix.col3.z = -eye.dot(back); return viewMatrix; }
public static vec3 cross(vec3 lhs, vec3 rhs) { return new vec3( lhs.y * rhs.z - rhs.y * lhs.z, lhs.z * rhs.x - rhs.z * lhs.x, lhs.x * rhs.y - rhs.x * lhs.y); }
public TrefoilKnotModel(double interval = 0.02) { this.interval = interval; bool initialized = false; vec3 max = new vec3(); vec3 min = new vec3(); int uCount = GetUCount(interval); for (int uIndex = 0; uIndex < uCount; uIndex++) { double t = Math.PI * 2 * uIndex / uCount; var position = GetPosition(t); if (!initialized) { max = position; min = position; initialized = true; } else { position.UpdateMax(ref max); position.UpdateMin(ref min); } } this.Lengths = max - min; }
public Rectangle3D(vec3 min, vec3 max) { vec3 realMin, realMax; MakesureMinMax(min, max, out realMin, out realMax); this.min = realMin; this.max = realMax; }
private static vec3 GetLengths(BuildInSceneObject buildIn) { var lengths = new vec3(1, 1, 1) * 2; switch (buildIn) { case BuildInSceneObject.Cube: break; case BuildInSceneObject.Sphere: break; case BuildInSceneObject.Ground: lengths = new vec3(groundXLength, 1, groundZLength); break; case BuildInSceneObject.Axis: break; default: throw new NotImplementedException(); } return lengths; }
public override MeshBase CreateMesh(GridderSource source) { PointGridderSource src = (PointGridderSource)source; vec3 minvec3 = new vec3(); vec3 maxvec3 = new vec3(); bool isSet = false; PointPositionBuffer positions = new PointPositionBuffer(); PointRadiusBuffer radiusBuffer = null; int dimSize = src.DimenSize; Random random = new Random(); // setup positions unsafe { positions.AllocMem(dimSize); var cells = (vec3*)positions.Data; for (int gridIndex = 0; gridIndex < dimSize; gridIndex++) { vec3 p = src.TranslateMatrix * src.Positions[gridIndex]; cells[gridIndex] = p; } } radiusBuffer = this.CreateRadiusBufferData(src, src.Radius); PointMeshGeometry3D mesh = new PointMeshGeometry3D(positions, radiusBuffer, dimSize); mesh.Max = src.TransformedActiveBounds.Max; mesh.Min = src.TransformedActiveBounds.Min; return mesh; }
static BigDipperModel() { positions = new vec3[11]; positions[0] = new vec3(0, 2, 0); positions[1] = new vec3(1, 2, 0); positions[2] = new vec3(2, 1.5f, 0); positions[3] = new vec3(3, 1.25f, 0); positions[4] = new vec3(3.5f, 0, 0); positions[5] = new vec3(4.5f, 0, 0); positions[6] = new vec3(5, 1, 0); positions[7] = new vec3(5.9f, 4.1f, 0); positions[8] = new vec3(6.1f, 4.2f, 0); positions[9] = new vec3(6.2f, 3.9f, 0); positions[10] = new vec3(6.4f, 3.9f, 0); positions.Move2Center(); colors = new vec3[11]; colors[0] = new vec3(1, 0, 0); colors[1] = new vec3(1, 0.5f, 0); colors[2] = new vec3(1, 1, 0); colors[3] = new vec3(0, 1, 0); colors[4] = new vec3(0, 1, 1); colors[5] = new vec3(0, 0, 1); colors[6] = new vec3(0.5f, 0, 1); colors[7] = new vec3(1.0f, 215.0f / 255.0f, 0.0f); colors[8] = new vec3(1.0f * 0.9f, 215.0f / 255.0f * 0.9f, 0.0f); colors[9] = new vec3(1.0f * 0.8f, 215.0f / 255.0f * 0.8f, 0.0f); colors[10] = new vec3(1.0f * 0.7f, 215.0f / 255.0f * 0.7f, 0.0f); }
public KleinBottleModel(double interval = 0.02) { this.interval = interval; bool initialized = false; vec3 max = new vec3(); vec3 min = new vec3(); int uCount = GetUCount(interval); int vCount = GetVCount(interval); for (int uIndex = 0; uIndex < uCount; uIndex++) { for (int vIndex = 0; vIndex < vCount; vIndex++) { double u = Math.PI * uIndex / uCount; double v = Math.PI * 2 * vIndex / vCount; var position = GetPosition(u, v); if (!initialized) { max = position; min = position; initialized = true; } else { position.UpdateMax(ref max); position.UpdateMin(ref min); } } } this.Lengths = max - min; }
public OrderIndependentTransparencyRenderer(IBufferable model, vec3 lengths, string positionName, string normalName) { { var map = new AttributeMap(); map.Add("position", positionName); map.Add("normal", normalName); var build_lists = new ShaderCode[2]; build_lists[0] = new ShaderCode(File.ReadAllText(@"shaders\OIT\build_lists.vert"), ShaderType.VertexShader); build_lists[1] = new ShaderCode(File.ReadAllText(@"shaders\OIT\build_lists.frag"), ShaderType.FragmentShader); this.buildListsRenderer = new PickableRenderer(model, build_lists, map, positionName); } { var map = new AttributeMap(); map.Add("position", positionName); var resolve_lists = new ShaderCode[2]; resolve_lists[0] = new ShaderCode(File.ReadAllText(@"shaders\OIT\resolve_lists.vert"), ShaderType.VertexShader); resolve_lists[1] = new ShaderCode(File.ReadAllText(@"shaders\OIT\resolve_lists.frag"), ShaderType.FragmentShader); this.resolve_lists = new PickableRenderer(model, resolve_lists, map, positionName); } { this.depthTestState = new DepthTestState(false); this.cullFaceState = new CullFaceState(false); } this.ModelSize = lengths; }
/// <summary> /// Evaluates the trefoil, providing the vertex at a given coordinate. /// </summary> /// <param name="s">The s.</param> /// <param name="t">The t.</param> /// <returns>The vertex at (s,t).</returns> private static vec3 EvaluateTrefoil(float s, float t) { const float TwoPi = (float)Math.PI * 2; float a = 0.5f; float b = 0.3f; float c = 0.5f; float d = 0.1f; float u = (1 - s) * 2 * TwoPi; float v = t * TwoPi; float r = (float)(a + b * Math.Cos(1.5f * u)); float x = (float)(r * Math.Cos(u)); float y = (float)(r * Math.Sin(u)); float z = (float)(c * Math.Sin(1.5f * u)); vec3 dv = new vec3(); dv.x = (float) (-1.5f*b*Math.Sin(1.5f*u)*Math.Cos(u) - (a + b*Math.Cos(1.5f*u))*Math.Sin(u)); dv.y = (float) (-1.5f*b*Math.Sin(1.5f*u)*Math.Sin(u) + (a + b*Math.Cos(1.5f*u))*Math.Cos(u)); dv.z = (float) (1.5f*c*Math.Cos(1.5f*u)); vec3 q = glm.normalize(dv); vec3 qvn = glm.normalize(new vec3(q.y, -q.x, 0.0f)); vec3 ww = glm.cross(q, qvn); vec3 range = new vec3(); range.x = (float) (x + d*(qvn.x*Math.Cos(v) + ww.x*Math.Sin(v))); range.y = (float)(y + d * (qvn.y * Math.Cos(v) + ww.y * Math.Sin(v))); range.z = (float)(z + d * ww.z * Math.Sin(v)); return range; }
public BoundedRenderer(Renderer scientificRenderer, vec3 lengths) { if (scientificRenderer == null) { throw new ArgumentNullException(); } this.BoundingBoxRenderer = BoudingBoxRendererFactory.GetBoundingBoxRenderer(lengths); this.ScientificRenderer = scientificRenderer; }
public void CanCreateLookAtProjection() { var eye = new vec3(4f, 4f, 4f); var centre = new vec3(0f, 0f, 0f); var up = new vec3(0f, 1f, 0f); var result = glm.lookAt(eye, centre, up); }
public static mat4 Translate(ref vec3 t) { return new mat4( 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, t.x, t.y, t.z, 1 ); }
internal void SetDirection(vec3 direction) { direction.y = 0; direction = direction.normalize(); float cosRadian = direction.dot(new vec3(1, 0, 0)); float radian = (float)Math.Acos(cosRadian); if (direction.z > 0) { radian = -radian; } this.radian = radian; }
/// <summary> /// Rotates by angleRadians in the direction(s) v and forces a recalculation of the result matrix. /// </summary> /// <param name="angleRadians">The angle of the rotation in radians.</param> /// <param name="v">The vector that represents the axis around which should be rotated.</param> public virtual TransformableBase RotateAbsolute(float angleRadians, vec3 v) { if (angleRadians == 0) return this; _rotationMatrix = GlmNet.glm.rotate(_rotationMatrix, angleRadians, v); return RecalculateResultMatrix(); }
/// <summary> /// /// </summary> /// <param name="item"></param> /// <returns></returns> public static vec3 Abs(this vec3 item) { vec3 result = new vec3(item.x, item.y, item.z); if (result.x < 0) { result.x = -result.x; } if (result.y < 0) { result.y = -result.y; } if (result.z < 0) { result.z = -result.z; } return result; }
//public PickedGeometry() { } /// <summary> /// The color-coded picking result. /// <para>Representing a primitive(point, line, triangle, quad, polygon).</para> /// </summary> /// <param name="fromViewPort"></param> /// <param name="geometryType"></param> /// <param name="positions"></param> /// <param name="vertexIds"></param> /// <param name="stageVertexId"></param> /// <param name="fromRenderer"></param> public PickedGeometry(ViewPort fromViewPort, PickingGeometryType geometryType, vec3[] positions, uint[] vertexIds, uint stageVertexId, IPickable fromRenderer) { this.FromViewPort = fromViewPort; this.GeometryType = geometryType; this.Positions = positions; this.VertexIds = vertexIds; this.StageVertexId = stageVertexId; this.FromRenderer = fromRenderer; }
public static void ApplySingleLightParameters(SharpGL.OpenGL gl, ExtShaderProgram esp, vec3 lp) { var prms = esp.Parameters as ISingleLightParameters; var p = esp.Program; // Set the light position. if (prms.LightPositionId != null) p.SetUniform3(gl, prms.LightPositionId, lp.x, lp.y, lp.z); }
public static mat4 ScaleMatrix(ref vec3 s) { mat4 r = new mat4(s.x, 0, 0, 0, 0, s.y, 0, 0, 0, 0, s.z, 0, 0, 0, 0, 1); return r; }
public static mat4 createTransformationMatrix(GlmNet.vec3 translation, vec3 rot, float scale) { mat4 matrix = new mat4(4); matrix = glm.translate(matrix, translation); mat4 rotMatrix = glm.rotate(rot.x, new vec3(0, 0, 1)) * glm.rotate(rot.y, new vec3(0, 1, 0)) * glm.rotate(rot.z, new vec3(1, 0, 0)); mat4 scaleMatrix = new mat4(4); scaleMatrix = glm.scale(scaleMatrix, new vec3(scale, scale, scale)); return matrix * rotMatrix * scaleMatrix; }
internal void SetDirection(IRenderable renderer, vec3 direction) { direction.y = 0; direction = direction.normalize(); float cosRadian = direction.dot(new vec3(1, 0, 0));// (1, 0, 0) is teapot's default direction. float radian = (float)Math.Acos(cosRadian); if (direction.z > 0) { radian = -radian; } renderer.RotationAngleDegree = (float)(radian * 180.0 / Math.PI); }
public static mat4 createViewMatrix(Camera camera) { mat4 viewMatrix = new mat4(); viewMatrix = glm.rotate((float)ToRadiansExtension.ToRadians(camera.getRotation().y), new vec3(1, 0, 0)); viewMatrix = glm.rotate(viewMatrix,(float)ToRadiansExtension.ToRadians(camera.getRotation().z), new vec3(0, 1, 0)); viewMatrix = glm.rotate(viewMatrix,(float)ToRadiansExtension.ToRadians(camera.getRotation().x), new vec3(0, 0, 1)); vec3 negativeCameraPos = new vec3(-camera.getPosition().x, -camera.getPosition().y, -camera.getPosition().z); viewMatrix = glm.translate(viewMatrix, negativeCameraPos); return viewMatrix; }
/// <summary> /// Specify a cuboid that marks a model's edges. /// </summary> /// <param name="min"></param> /// <param name="max"></param> public LegacyBoundingBoxRenderer(vec3 min, vec3 max) { this.MinPosition = min; this.MaxPosition = max; this.Scale = new vec3(1, 1, 1); this.RotationAxis = new vec3(0, 1, 0); this.ModelSize = max - min; }
/// <summary> /// /// </summary> /// <param name="lengths"></param> public Cube(vec3 lengths) { this.Lengths = lengths; }
public static float Distance(vec3 p1, vec3 p2) { return(Length(p2 - p1)); }
public static vec3 ProjectOntoPlane(vec3 v, vec3 n) { // See https://www.maplesoft.com/support/help/Maple/view.aspx?path=MathApps%2FProjectionOfVectorOntoPlane. return(v - Project(v, n)); }
public float projection(vec3 point) { return(direction ^ (point - origin)); }
public static vec3 Rotate(vec3 v, float angle, vec3 axis) { Debug.Assert(axis != vec3.Zero, "Can't rotate around a vec3.Zero axis."); return(angle == 0 ? v : quat.FromAxisAngle(angle, axis) * v); }
public extern mat3(vec3 col0, vec3 col1, vec3 col2);
public ray(vec3 origin, vec3 direction) { this.origin = origin; this.direction = direction; }
public static float DistanceToLine(vec3 p, vec3 e0, vec3 e1, out float t) { return(Line3D.Distance(p, e0, e1, out t)); }
public void SetSeekTarget(vec3 targetPoint) { }
public static bool Intersects(vec3 p1, vec3 p2, vec3[] triangle, out float t) { return(Intersects(p1, p2, triangle[0], triangle[1], triangle[2], out t)); }
public static bool IsWithinTriangle(vec3 p, vec3 p0, vec3 p1, vec3 p2) { var b = Barycentric(p, p0, p1, p2); return(b.x >= 0 && b.x <= 1 && b.y >= 0 && b.y <= 1 && b.z >= 0 && b.z <= 1); }
public static vec3 Project(vec3 v, vec3 onto) { // See https://math.oregonstate.edu/home/programs/undergrad/CalculusQuestStudyGuides/vcalc/dotprod/dotprod.html. return(vec3.Dot(onto, v) / vec3.Dot(onto, onto) * onto); }
public CubeModel() { this.ModelSize = new vec3(xLength * 2, yLength * 2, zLength * 2); }
public LayeredRectangleModel() { this.ModelSize = new vec3(xLength * 2, yLength * 2, (xLength + yLength) * 0.02f); }
public ray() { origin = vec3.zero; direction = vec3.forward; }
public static void AreVectorsEqual(vec3 expected, vec3 actual, float delta) { Assert.AreEqual(expected.x, actual.x, delta, "Vector X component is incorrect."); Assert.AreEqual(expected.y, actual.y, delta, "Vector Y component is incorrect."); Assert.AreEqual(expected.z, actual.z, delta, "Vector Z component is incorrect."); }
public float distance(vec3 point) { return((direction % (point - origin)).magnitude); }
public static float Dot(vec3 v1, vec3 v2) { return(vec3.Dot(v1, v2)); }
public vec3 project(vec3 point) { return(origin + direction * projection(point)); }
public static float Length(vec3 v) { return((float)Math.Sqrt(LengthSquared(v))); }
public static float LengthSquared(vec3 v) { return(v.x * v.x + v.y * v.y + v.z * v.z); }
public static vec3 Cross(vec3 v1, vec3 v2) { return(vec3.Cross(v1, v2)); }
public static float Dot(vec3 v) { return(v.x * v.x + v.y * v.y + v.z * v.z); }
public bullet(vec3 cp, vec3 ld) { pos = cp; dir = ld; }
public static vec3 Barycentric(vec3 p, vec3[] triangle) { return(Barycentric(p, triangle[0], triangle[1], triangle[2])); }
public void update() { pos += dir; }
public static PointsNode Create(IBufferSource model, string position, string color, vec3 size) { RenderMethodBuilder randomBuilder, gl_VertexIDBuilder; { var vs = new VertexShader(randomVert); var fs = new FragmentShader(randomFrag); var array = new ShaderArray(vs, fs); var map = new AttributeMap(); map.Add("inPosition", position); map.Add("inColor", color); randomBuilder = new RenderMethodBuilder(array, map); } { var vs = new VertexShader(gl_VertexIDVert); var fs = new FragmentShader(gl_VertexIDFrag); var array = new ShaderArray(vs, fs); var map = new AttributeMap(); map.Add("inPosition", position); gl_VertexIDBuilder = new RenderMethodBuilder(array, map); } var node = new PointsNode(model, position, randomBuilder, gl_VertexIDBuilder); node.Initialize(); node.ModelSize = size; return(node); }
public static vec3 ProjectOntoPlane(vec3 p, vec3 planePoint, vec3 n) { return(ProjectOntoPlane(p - planePoint, n)); }
public static float DistanceSquared(vec3 p1, vec3 p2) { return(LengthSquared(p2 - p1)); }
public static bool IsWithinTriangle(vec3 p, vec3[] triangle) { return(IsWithinTriangle(p, triangle[0], triangle[1], triangle[2])); }