public void DrawVectors(Matrix4d transformacja) { if (VectorsVisibility) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 0); foreach (var item in ControlArrayC1) { for (int i = 1; i < 6; i++) { Matrix4d projection = MatrixProvider.ProjectionMatrix(); var a = projection.Multiply(transformacja.Multiply(item[0][i])); var b = projection.Multiply(transformacja.Multiply(item[1][i])); var c = projection.Multiply(transformacja.Multiply(2 * item[0][i] - item[1][i])); //GL.Vertex2(new Vector2d(a.X / 720, a.Y / 375)); //GL.Vertex2(new Vector2d(b.X / 720, b.Y / 375)); //GL.Vertex2(new Vector2d((2*(item[0][i].X_Window / (1440.0 / 2.0) )- item[1][i].X_Window /(1440.0 / 2.0)), (2* (item[0][i].Y_Window / (1440.0 / 2.0) )- item[1][i].Y_Window / (1440.0 / 2.0)))); //GL.Vertex2(new Vector2d(item[1][i].X_Window/ (1440.0 / 2.0) , item[1][i].Y_Window/(750.0 / 2.0))); GL.Vertex2(new Vector2d(c.X, c.Y)); GL.Vertex2(new Vector2d(b.X, b.Y)); } } GL.End(); } }
public void DrawPolyline(Matrix4d transformacja) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < 4; i++) { for (int j = 0; j < 4 - 1; j++) { var _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j + 1].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } for (int i = 0; i < 4 - 1; i++) { for (int j = 0; j < 4; j++) { var _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i + 1, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } GL.End(); }
public void Draw(Matrix4d transformacja, int size = 4, double red = 1, double green = 1, double blue = 1) { //Matrix4d projekcja = MatrixProvider.ProjectionMatrix(100); GL.Enable(EnableCap.VertexProgramPointSize); GL.PointSize(size); GL.Begin(BeginMode.Points); if (_selected) { GL.Color3(0.0, 1.0, 0.0); } else { GL.Color3(red, green, blue); } Matrix4d projection = MatrixProvider.ProjectionMatrix(); _windowCoordinates = projection.Multiply(transformacja.Multiply(_coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates.X = _windowCoordinates.X * 1440 / 2; _windowCoordinates.Y = _windowCoordinates.Y * 750 / 2; GL.End(); }
public void Draw(Program program, ref Matrix4d world, SetWorldMatrixCallback setWorldMatrix, IModelMaterialBinder materialBinder) { ModelMaterial material = null; foreach (ModelMesh mesh in meshes) { if (setWorldMatrix != null) { Matrix4d meshWorld; if (mesh.bone != null) { mesh.bone.GetWorldTransform(out meshWorld); world.Multiply(ref meshWorld, out meshWorld); setWorldMatrix.Invoke(ref meshWorld); } } foreach (ModelPart part in mesh.parts) { if (part.Material != null && part.Material != material && materialBinder != null) { material = part.Material; materialBinder.BindMaterial(part.Material); } program.Draw(part.Primitive, part.Count, elementBuffer, elementType, part.Offset); } } }
protected void DrawBezierCurve(Matrix4d transformacja, IEnumerable <Point> points) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); ObservableCollection <Point> transformedProjectedPoints = new ObservableCollection <Point>(); ObservableCollection <Point> temp = new ObservableCollection <Point>(); foreach (var p in points) { var a = projekcjaRight.Multiply(transformacja.Multiply(p)); transformedProjectedPoints.Add(new Point(a.X, a.Y, a.Z)); } foreach (var p in transformedProjectedPoints) { temp.Add(p); if (temp.Count % 4 == 0 || p == transformedProjectedPoints.Last()) { var divisions = GetDivisions(transformacja, temp); var point = Casteljeu(temp, 0); for (double t = divisions / 2; t <= 1; t += divisions / 2) { GL.Vertex2(point.X, point.Y); point = Casteljeu(temp, t); GL.Vertex2(point.X, point.Y); } temp.Clear(); temp.Add(p); } } GL.End(); }
public override void DrawPolyline(Matrix4d transformacja) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); if (PolylineEnabled) { for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcja.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcja.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } } GL.End(); }
public double GetDivisions(Matrix4d transformacja, ObservableCollection <Point> temp) { int j = temp.Count; double length = 0; for (int i = 0; i < j - 1; i++) { Vector4d a = projekcja.Multiply(transformacja.Multiply(temp[i + 1])) - projekcja.Multiply(transformacja.Multiply(temp[i])); a.X *= 1440; a.Y *= 750; length += a.Length; } return(0.1 / length); }
public void GetWorldTransform(out Matrix4d result) { result = Transform; for (ModelBone parent = Parent; parent != null; parent = parent.parent) { result.Multiply(ref parent.transform, out result); } }
public void Draw(Matrix4d transformacja) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 0.0, 0.0); var vertex = transformacja.Multiply(vertices[0]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[1]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); GL.Color3(0.0, 1.0, 0.0); vertex = transformacja.Multiply(vertices[2]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[3]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); GL.Color3(0.0, 0.0, 1.0); vertex = transformacja.Multiply(vertices[4]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[5]); GL.Vertex2(_projection.Multiply(vertex).X, _projection.Multiply(vertex).Y); GL.End(); var temp = _projection.Multiply(transformacja.Multiply(_coordinates)); WindowCoordinate = new Vector4d(temp.X * 720, temp.Y * 375, 0, 0); }
public void DrawPolyline(Matrix4d transformacja) { if (PolylineEnabled) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < PatchPoints.GetLength(0); i++) { for (int j = 0; j < PatchPoints.GetLength(1) - 1; j++) { var _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j + 1].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } for (int i = 0; i < PatchPoints.GetLength(0) - 1; i++) { for (int j = 0; j < PatchPoints.GetLength(1); j++) { var _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i + 1, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } if (PatchesAreCylinder) { for (int i = 0; i < PatchPoints.GetLength(0); i++) { var _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, 0].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(PatchPoints[i, PatchPoints.GetLength(1) - 1].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } GL.End(); } }
public void Draw(Matrix4d transformacja) { Matrix4d projekcja = MatrixProvider.ProjectionMatrix(); GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); foreach (var relations in _relationsList) { var vertex = transformacja.Multiply(_verticesList[relations.Item1]); var vertex2 = transformacja.Multiply(_verticesList[relations.Item2]); GL.Vertex2(projekcja.Multiply(vertex).X, projekcja.Multiply(vertex).Y); GL.Vertex2(projekcja.Multiply(vertex2).X, projekcja.Multiply(vertex2).Y); //} //GL.Vertex3(_verticesList[relations.Item1]); //GL.Vertex3(_verticesList[relations.Item2]); } GL.End(); }
public void DrawPatch(Matrix4d transformacja) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < _curvesPatchPoints1.GetLength(0) - 1; i++) { for (int j = 0; j < _curvesPatchPoints1.GetLength(1); j++) { // if (_curvesPatchPoints[i + 1, j] == null || _curvesPatchPoints[i, j] == null) break; var _windowCoordinates = projection.Multiply(transformacja.Multiply(_curvesPatchPoints1[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(_curvesPatchPoints1[i + 1, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } for (int i = 0; i < _curvesPatchPoints.GetLength(0); i++) { for (int j = 0; j < _curvesPatchPoints.GetLength(1) - 1; j++) { //if (_curvesPatchPoints[i , j+1] == null || _curvesPatchPoints[i, j] == null) break; var _windowCoordinates = projection.Multiply(transformacja.Multiply(_curvesPatchPoints[i, j].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); _windowCoordinates = projection.Multiply(transformacja.Multiply(_curvesPatchPoints[i, j + 1].Coordinates)); GL.Vertex2(_windowCoordinates.X, _windowCoordinates.Y); } } GL.End(); }
public void DrawStereoscopy(Matrix4d transformacja) { double StereoscopyMin = 1; GL.Enable(EnableCap.VertexProgramPointSize); GL.PointSize(3); GL.Begin(BeginMode.Points); //zmiana odleglosciu oczu Matrix4d projekcja = MatrixProvider.RightProjectionMatrix(); var a = projekcja.Multiply(transformacja.Multiply(_coordinates)); projekcja = MatrixProvider.LeftProjectionMatrix(); var b = projekcja.Multiply(transformacja.Multiply(_coordinates)); var c = a - b; c.X = c.X * 1440 / 2; c.Y = c.Y * 750 / 2; if (c.Length < StereoscopyMin) { GL.Color3(1.0, 0.0, 1.0); GL.Vertex2((a.X + b.X) / 2, (a.Y + b.Y) / 2); } else { GL.Color3(1.0, 0, 0); GL.Vertex2(a.X, a.Y); GL.Color3(0, 0, 1.0); GL.Vertex2(b.X, b.Y); } _windowCoordinates.X = (a.X / 2 + b.X / 2) * 1440 / 2; _windowCoordinates.Y = (a.Y / 2 + b.Y / 2) * 750 / 2; GL.End(); }
public override void DrawPolylineStereoscopy(Matrix4d transformacja) { if (PolylineEnabled) { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.Color3(0.0, 0.0, 0.6); for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } }
public override void DrawCurveStereoscopy(Matrix4d transformacja) { if (_interpolation) { CalculateInterpolationDeBoore(); transformedProjectedPoints.Clear(); foreach (var p in _pointsCollectionInterpolation) { var a = projekcjaRight.Multiply(transformacja.Multiply(p)); transformedProjectedPoints.Add(new Point(a.X, a.Y, a.Z)); } SetSplineKnots(); CalculateAdditionalPoints(_pointsCollectionInterpolation); double divisions = GetDivisions(transformacja, _additionalPointsCollection2); if (IsBernsteinBasis) { foreach (var p in _additionalPointsCollection) { p.Draw(transformacja, 4); } foreach (var p in _additionalPointsCollection2) { p.Draw(transformacja, 4); } DrawBezierCurveStereoscopy(transformacja, _additionalPointsCollection2); } else { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (double t = 0; t < 1; t += divisions) { if (t >= _knots[3] && t <= _knots[_knots.Length - PolynomialDegree - 4]) { var u = BSplinePoint(t); var v = BSplinePoint(t + divisions); // var windowCoordinates = projekcja.Multiply(transformacja.Multiply(u.Coordinates)); GL.Vertex2(u.X, u.Y); /// windowCoordinates = projekcja.Multiply(transformacja.Multiply(v.Coordinates)); GL.Vertex2(v.X, v.Y); } } GL.Color3(0.0, 0.0, 0.6); for (double t = 0; t < 1; t += divisions) { if (t >= _knots[3] && t <= _knots[_knots.Length - PolynomialDegree - 4]) { var u = BSplinePoint(t); var v = BSplinePoint(t + divisions); // var windowCoordinates = projekcja.Multiply(transformacja.Multiply(u.Coordinates)); GL.Vertex2(u.X, u.Y); /// windowCoordinates = projekcja.Multiply(transformacja.Multiply(v.Coordinates)); GL.Vertex2(v.X, v.Y); } } GL.End(); } } else { transformedProjectedPoints.Clear(); foreach (var p in PointsCollection) { var a = projekcjaRight.Multiply(transformacja.Multiply(p)); transformedProjectedPoints.Add(new Point(a.X, a.Y, a.Z)); } SetSplineKnots(); CalculateAdditionalPoints(PointsCollection); double divisions = GetDivisions(transformacja, _additionalPointsCollection2); if (IsBernsteinBasis) { foreach (var p in _additionalPointsCollection) { p.Draw(transformacja, 4); } foreach (var p in _additionalPointsCollection2) { p.Draw(transformacja, 4); } DrawBezierCurveStereoscopy(transformacja, _additionalPointsCollection2); } else { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (double t = 0; t < 1; t += divisions) { if (t >= _knots[3] && t <= _knots[_knots.Length - PolynomialDegree - 4]) { var u = BSplinePoint(t); var v = BSplinePoint(t + divisions); // var windowCoordinates = projekcja.Multiply(transformacja.Multiply(u.Coordinates)); GL.Vertex2(u.X, u.Y); /// windowCoordinates = projekcja.Multiply(transformacja.Multiply(v.Coordinates)); GL.Vertex2(v.X, v.Y); } } GL.Color3(0.0, 0.0, 0.6); for (double t = 0; t < 1; t += divisions) { if (t >= _knots[3] && t <= _knots[_knots.Length - PolynomialDegree - 4]) { var u = BSplinePoint(t); var v = BSplinePoint(t + divisions); // var windowCoordinates = projekcja.Multiply(transformacja.Multiply(u.Coordinates)); GL.Vertex2(u.X, u.Y); /// windowCoordinates = projekcja.Multiply(transformacja.Multiply(v.Coordinates)); GL.Vertex2(v.X, v.Y); } } GL.End(); } } }
public override void DrawPolylineStereoscopy(Matrix4d transformacja) { if (_interpolation) { if (IsBernsteinBasis) { if (PolylineEnabled) { CalculateAdditionalPoints(_pointsCollectionInterpolation); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.Color3(0.0, 0.0, 0.6); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } else { if (PolylineEnabled) { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (int i = 0; i < _pointsCollectionInterpolation.Count - 1; i++) { var windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.Color3(0.0, 0.0, 0.6); for (int i = 0; i < _pointsCollectionInterpolation.Count - 1; i++) { var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } } else { if (IsBernsteinBasis) { if (PolylineEnabled) { CalculateAdditionalPoints(PointsCollection); GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.Color3(0.0, 0.0, 0.6); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } else { if (PolylineEnabled) { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaRight.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.Color3(0.0, 0.0, 0.6); for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } } }
public void DrawStereoscopy(Matrix4d transformacja) { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); var vertex = transformacja.Multiply(vertices[0]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[1]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[2]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[3]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[4]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[5]); GL.Vertex2(_projectionRight.Multiply(vertex).X, _projectionRight.Multiply(vertex).Y); GL.Color3(0.0, 0.0, 0.6); vertex = transformacja.Multiply(vertices[0]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[1]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[2]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[3]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[4]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); vertex = transformacja.Multiply(vertices[5]); GL.Vertex2(_projectionLeft.Multiply(vertex).X, _projectionLeft.Multiply(vertex).Y); GL.End(); var temp = _projectionLeft.Multiply(transformacja.Multiply(_coordinates)); WindowCoordinate = new Vector4d(temp.X * 720, temp.Y * 375, 0, 0); }
public void DrawBezierCurveStereoscopy(Matrix4d transformacja, ObservableCollection <Point> Points) { GL.Enable(EnableCap.Blend); GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One); GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0.0, 0.0); int j = 0; ObservableCollection <Point> temp = new ObservableCollection <Point>(); ObservableCollection <Point> transformedProjectedPoints = new ObservableCollection <Point>(); foreach (var p in Points) { var a = projekcjaRight.Multiply(transformacja.Multiply(p)); transformedProjectedPoints.Add(new Point(a.X, a.Y, a.Z)); } foreach (var p in transformedProjectedPoints) { j++; temp.Add(p); if (j % 4 == 0 || p == transformedProjectedPoints.Last()) { double divisions = GetDivisions(temp); var point = Casteljeu(temp, 0); for (double t = divisions / 2; t <= 1; t += divisions / 2) { GL.Vertex2(point.X, point.Y); point = Casteljeu(temp, t); GL.Vertex2(point.X, point.Y); } temp.Clear(); temp.Add(p); j = 1; } } GL.Color3(0.0, 0.0, 0.6); j = 0; ObservableCollection <Point> temp2 = new ObservableCollection <Point>(); foreach (var p in Points) { j++; temp2.Add(p); if (j % 4 == 0 || p == PointsCollection.Last()) { double divisions = GetDivisions(transformacja, temp2); var point = Casteljeu(temp2, 0); var windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(point)); for (double t = divisions / 2; t <= 1; t += divisions / 2) { GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); point = Casteljeu(temp2, t); windowCoordinates = projekcjaLeft.Multiply(transformacja.Multiply(point)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } temp2.Clear(); temp2.Add(p); j = 1; } } GL.End(); }
public void DrawStereoscopy(Matrix4d transformacja) { const int renderWidth = 1440; const int renderHeight = 750; GL.Begin(BeginMode.Lines); GL.Color3(0.6, 0, 0); Matrix4d projekcja = MatrixProvider.RightProjectionMatrix(); foreach (var relations in _relationsList) { var avertex = transformacja.Multiply(_verticesList[relations.Item1]); var avertex2 = transformacja.Multiply(_verticesList[relations.Item2]); var dx = projekcja.M13 * avertex.Z; var dx2 = projekcja.M13 * avertex2.Z; var vertex = projekcja.Multiply(avertex); var vertex2 = projekcja.Multiply(avertex2); GL.Vertex2(vertex.X, vertex.Y); GL.Vertex2(vertex2.X, vertex2.Y); } GL.End(); Bitmap bmp1 = new Bitmap(renderWidth, renderHeight); System.Drawing.Imaging.BitmapData dat = bmp1.LockBits(new Rectangle(0, 0, renderWidth, renderHeight), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); GL.ReadPixels(0, 0, renderWidth, renderHeight, PixelFormat.Bgra, PixelType.UnsignedByte, dat.Scan0); bmp1.UnlockBits(dat); //bmp1.Save("D:\\ModelowanieGeometryczne\\a1.bmp", ImageFormat.Bmp); GL.Clear(ClearBufferMask.ColorBufferBit); GL.Begin(BeginMode.Lines); GL.Color3(0, 0, 0.9); projekcja = MatrixProvider.LeftProjectionMatrix(); foreach (var relations in _relationsList) { var avertex = transformacja.Multiply(_verticesList[relations.Item1]); var avertex2 = transformacja.Multiply(_verticesList[relations.Item2]); var dx = projekcja.M13 * avertex.Z; var dx2 = projekcja.M13 * avertex2.Z; var vertex = projekcja.Multiply(avertex); var vertex2 = projekcja.Multiply(avertex2); GL.Vertex2(vertex.X, vertex.Y); GL.Vertex2(vertex2.X, vertex2.Y); } GL.End(); Bitmap bmp2 = new Bitmap(renderWidth, renderHeight); System.Drawing.Imaging.BitmapData dat2 = bmp2.LockBits(new Rectangle(0, 0, renderWidth, renderHeight), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); GL.ReadPixels(0, 0, renderWidth, renderHeight, PixelFormat.Bgra, PixelType.UnsignedByte, dat2.Scan0); bmp2.UnlockBits(dat2); // bmp2.Save("D:\\ModelowanieGeometryczne\\a2.bmp", ImageFormat.Bmp); GL.Clear(ClearBufferMask.ColorBufferBit); Bitmap bmp3 = bmp2; Color temp, pixeltemp, result; ////Działa dla dowolnego koloru torusa 1 i torusa 2 for (int i = 0; i < renderWidth; i++) { for (int j = 0; j < renderHeight; j++) { temp = bmp1.GetPixel(i, j); if (temp.R == 0 && temp.G == 0 && temp.B == 0) { } else { pixeltemp = bmp3.GetPixel(i, j); result = Color.FromArgb(Math.Min(temp.R + pixeltemp.R, 255), Math.Min(temp.G + pixeltemp.G, 255), Math.Min(temp.B + pixeltemp.B, 255)); bmp3.SetPixel(i, j, result); } } } //Writable bitmap bmp3.Save("D:\\ModelowanieGeometryczne\\a3.bmp", ImageFormat.Bmp); //Color k1 = Color.FromArgb(87, 0, 0); //Color k2 = Color.FromArgb(87, 0, 173); //for (int i = 0; i < RenderWidth; i++) //{ // for (int j = 0; j < RenderHeight; j++) // { // if (bmp1.GetPixel(i, j).R == 0) // { // } // else if (bmp3.GetPixel(i, j).B == 0) // { // //Blending colors overlapped lines. // bmp3.SetPixel(i, j, k1); // } // else // { // bmp3.SetPixel(i, j, k2); // } // } //} //bmp3.Save("D:\\ModelowanieGeometryczne\\a3.bmp", ImageFormat.Bmp); dat2 = bmp2.LockBits(new Rectangle(0, 0, renderWidth, renderHeight), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); GL.DrawPixels(renderWidth, renderHeight, PixelFormat.Bgra, PixelType.UnsignedByte, dat2.Scan0); bmp2.UnlockBits(dat2); }
private Matrix4d GetOrientationMatrix() { return(_cameraOrientation.Multiply(_tempCameraOrientation)); }
/// <summary> /// This is where we do our rendering /// Called from UI thread = UI code safe in this function /// </summary> public override void Render(DrawArgs drawArgs) { if (!isInitialized || (this.world.Name == "Earth" && World.Settings.EnableAtmosphericScattering)) { return; } // Camera & Device shortcuts ;) CameraBase camera = drawArgs.WorldCamera; Device device = drawArgs.device; //if(camera.Altitude > 200e3) return; Point3d cameraPos = camera.Position; double distToCenterOfPlanet = (camera.Altitude + camera.WorldRadius); // Create or refresh SkyGradient dome if (mesh == null || lastAltitude != camera.Altitude) { // Compute distance to horizon and dome radius double tangentalDistance = Math.Sqrt(distToCenterOfPlanet * distToCenterOfPlanet - camera.WorldRadius * camera.WorldRadius); double domeRadius = tangentalDistance; // horizon latitude double horizonLat = (-Math.PI / 2 + Math.Acos(tangentalDistance / distToCenterOfPlanet)) * 180 / Math.PI; // zenith latitude double zenithLat = 90; if (camera.Altitude >= thickness) { double tangentalDistanceZenith = Math.Sqrt(distToCenterOfPlanet * distToCenterOfPlanet - (camera.WorldRadius + thickness) * (camera.WorldRadius + thickness)); zenithLat = (-Math.PI / 2 + Math.Acos(tangentalDistanceZenith / distToCenterOfPlanet)) * 180 / Math.PI; } if (camera.Altitude < thickness && camera.Altitude > thickness * 0.8) { zenithLat = (thickness - camera.Altitude) / (thickness - thickness * 0.8) * 90; } // new mesh if (mesh != null) { mesh.Dispose(); } mesh = ColoredSphere(device, domeRadius, horizonLat, zenithLat, 128, 24); lastAltitude = camera.Altitude; } // set texture to null device.SetTexture(0, null); device.TextureState[0].ColorOperation = TextureOperation.BlendCurrentAlpha; device.VertexFormat = CustomVertex.PositionColored.Format; // save world and projection transform Matrix origWorld = device.Transform.World; Matrix origProjection = device.Transform.Projection; // move SkyGradient dome Matrix4d SkyGradientTrans; Point3d cameraCoord = MathEngine.CartesianToSpherical(cameraPos.X, cameraPos.Y, cameraPos.Z); double camLat = cameraCoord.Y; double camLon = cameraCoord.Z; SkyGradientTrans = Matrix4d.Translation(0, 0, distToCenterOfPlanet); SkyGradientTrans = Matrix4d.Multiply(SkyGradientTrans, Matrix4d.RotationY(-camLat + Math.PI / 2)); SkyGradientTrans = Matrix4d.Multiply(SkyGradientTrans, Matrix4d.RotationZ(camLon)); device.Transform.World = ConvertDX.FromMatrix4d(SkyGradientTrans); // Recenter Recenter(drawArgs); // Save fog status bool origFog = device.RenderState.FogEnable; device.RenderState.FogEnable = false; // Set new one (to avoid being clipped) - probably better ways of doing this? double aspectRatio = (double)device.Viewport.Width / device.Viewport.Height; device.Transform.Projection = ConvertDX.FromMatrix4d(Matrix4d.PerspectiveFovRH(camera.Fov.Radians, aspectRatio, 1000, 30000000.0)); // draw //device.RenderState.FillMode = FillMode.WireFrame; mesh.DrawSubset(0); // Restore device states device.RenderState.FillMode = FillMode.Solid; device.Transform.World = origWorld; device.Transform.Projection = origProjection; device.RenderState.FogEnable = origFog; device.RenderState.ZBufferEnable = true; // Fog effect if (useFog) { // Compute distance to horizon and camera altitude double tangentalDistance = Math.Sqrt(distToCenterOfPlanet * distToCenterOfPlanet - camera.WorldRadius * camera.WorldRadius); double a = camera.Altitude; device.RenderState.FogEnable = true; device.RenderState.FogColor = horizonColor; device.RenderState.FogTableMode = FogMode.Linear; device.RenderState.FogStart = (float)(a * nearFactor); device.RenderState.FogEnd = (float)(tangentalDistance * farFactor); } }
public override void DrawPolyline(Matrix4d transformacja) { if (_interpolation) { // var debor = CalculateInterpolationDeBoore(transformacja); CalculateInterpolationDeBoore(); var debor = _pointsCollectionInterpolation; if (IsBernsteinBasis) { if (PolylineEnabled) {//TODO: tu wroc CalculateAdditionalPoints(_pointsCollectionInterpolation); GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcja.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcja.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } else { if (PolylineEnabled) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < _pointsCollectionInterpolation.Count - 1; i++) { var windowCoordinates = projekcja.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcja.Multiply(transformacja.Multiply(_pointsCollectionInterpolation[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } } else { if (IsBernsteinBasis) { if (PolylineEnabled) { CalculateAdditionalPoints(PointsCollection); GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < _additionalPointsCollection2.Count - 1; i++) { var windowCoordinates = projekcja.Multiply(transformacja.Multiply(_additionalPointsCollection2[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcja.Multiply(transformacja.Multiply(_additionalPointsCollection2[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } else { if (PolylineEnabled) { GL.Begin(BeginMode.Lines); GL.Color3(1.0, 1.0, 1.0); for (int i = 0; i < PointsCollection.Count - 1; i++) { var windowCoordinates = projekcja.Multiply(transformacja.Multiply(PointsCollection[i].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); windowCoordinates = projekcja.Multiply(transformacja.Multiply(PointsCollection[i + 1].Coordinates)); GL.Vertex2(windowCoordinates.X, windowCoordinates.Y); } GL.End(); } } } }