public static void Draw(RenderContext11 renderContext, PositionColoredTextured[] points, int count, Texture11 texture, SharpDX.Direct3D.PrimitiveTopology primitiveType, float opacity = 1.0f) { if (VertexBuffer == null) { VertexBuffer = new Buffer(renderContext.Device, System.Runtime.InteropServices.Marshal.SizeOf(points[0]) * 2500, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, System.Runtime.InteropServices.Marshal.SizeOf(points[0])); VertexBufferBinding = new VertexBufferBinding(VertexBuffer, System.Runtime.InteropServices.Marshal.SizeOf((points[0])), 0); } renderContext.devContext.InputAssembler.PrimitiveTopology = primitiveType; renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.Off); SharpDX.Matrix mat = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mat.Transpose(); WarpOutputShader.MatWVP = mat; WarpOutputShader.Use(renderContext.devContext, texture != null, opacity); renderContext.SetVertexBuffer(VertexBufferBinding); DataBox box = renderContext.devContext.MapSubresource(VertexBuffer, 0, MapMode.WriteDiscard, MapFlags.None); Utilities.Write(box.DataPointer, points, 0, count); renderContext.devContext.UnmapSubresource(VertexBuffer, 0); if (texture != null) { renderContext.devContext.PixelShader.SetShaderResource(0, texture.ResourceView); } else { renderContext.devContext.PixelShader.SetShaderResource(0, null); } renderContext.devContext.Draw(count, 0); }
public static void Draw(RenderContext11 renderContext, PositionColoredTextured[] points, int count, Matrix mat, bool triangleStrip) { if (VertexBuffer == null) { VertexBuffer = new Buffer(renderContext.Device, System.Runtime.InteropServices.Marshal.SizeOf(points[0]) * 2500, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, System.Runtime.InteropServices.Marshal.SizeOf(points[0])); VertexBufferBinding = new VertexBufferBinding(VertexBuffer, System.Runtime.InteropServices.Marshal.SizeOf((points[0])), 0); } renderContext.devContext.InputAssembler.PrimitiveTopology = triangleStrip ? SharpDX.Direct3D.PrimitiveTopology.TriangleStrip : SharpDX.Direct3D.PrimitiveTopology.TriangleList; renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.Off); mat.Transpose(); WarpOutputShader.MatWVP = mat; WarpOutputShader.Use(renderContext.devContext, false); renderContext.SetVertexBuffer(VertexBufferBinding); DataBox box = renderContext.devContext.MapSubresource(VertexBuffer, 0, MapMode.WriteDiscard, MapFlags.None); Utilities.Write(box.DataPointer, points, 0, count); renderContext.devContext.UnmapSubresource(VertexBuffer, 0); renderContext.devContext.PixelShader.SetShaderResource(0, null); renderContext.devContext.Draw(count, 0); }
public void DrawLabels(RenderContext11 renderContext) { if (positions.Count < 1) { return; } InitLabelBuffer(); renderContext.SetVertexBuffer(labelBuffer); renderContext.BlendMode = BlendMode.Alpha; renderContext.DepthStencilMode = DepthStencilMode.Off; renderContext.setRasterizerState(TriangleCullMode.Off); var mvp = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mvp.Transpose(); PointSpriteShader11.WVPMatrix = mvp; PointSpriteShader11.Color = SharpDX.Color.White; var adjustedScale = .01f; // (float)(1 / (Earth3d.MainWindow.ZoomFactor / 360)); PointSpriteShader11.ViewportScale = new Vector2((2.0f / renderContext.ViewPort.Width) * adjustedScale, (2.0f / renderContext.ViewPort.Height) * adjustedScale); PointSpriteShader11.PointScaleFactors = new Vector3(0.0f, 0.0f, 10000.0f); PointSpriteShader11.Use(renderContext.Device.ImmediateContext); renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, texture.ResourceView); renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList; renderContext.devContext.Draw(labelBuffer.Count, 0); renderContext.Device.ImmediateContext.GeometryShader.Set(null); }
public override bool Draw(RenderContext11 renderContext, float opacity, bool flat) { if (bufferIsFlat != flat) { CleanUp(); bufferIsFlat = flat; } if (!CleanAndReady) { PrepVertexBuffer( opacity); } var oldWorld = renderContext.World; if (astronomical && !bufferIsFlat) { var ecliptic = Coordinates.MeanObliquityOfEcliptic(SpaceTimeController.JNow) / 180.0 * Math.PI; renderContext.World = Matrix3d.RotationX(ecliptic) * renderContext.World; } if (triangleList2d != null) { triangleList2d.Decay = decay; triangleList2d.Sky = Astronomical; triangleList2d.TimeSeries = timeSeries; triangleList2d.Draw(renderContext, opacity * Opacity, TriangleList.CullMode.CounterClockwise); } if (triangleList != null) { triangleList.Decay = decay; triangleList.Sky = Astronomical; triangleList.TimeSeries = timeSeries; triangleList.Draw(renderContext, opacity * Opacity, TriangleList.CullMode.CounterClockwise); } if (lineList != null) { lineList.Sky = Astronomical; lineList.Decay = decay; lineList.TimeSeries = timeSeries; lineList.DrawLines(renderContext, opacity * Opacity); } if (lineList2d != null) { lineList2d.Sky = !Astronomical; lineList2d.Decay = decay; lineList2d.TimeSeries = timeSeries; lineList2d.ShowFarSide = ShowFarSide; lineList2d.DrawLines(renderContext, opacity * Opacity); } if (textBatch != null) { var mode = renderContext.DepthStencilMode; renderContext.DepthStencilMode = DepthStencilMode.Off; textBatch.Draw(renderContext, 1, Color.White); renderContext.DepthStencilMode = mode; } if (astronomical && !bufferIsFlat) { renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; } else { renderContext.DepthStencilMode = DepthStencilMode.Off; } var baseDate = new DateTime(2010, 1, 1, 12, 00, 00); renderContext.setRasterizerState(TriangleCullMode.Off); var cam = Vector3d.TransformCoordinate(renderContext.CameraPosition, Matrix3d.Invert(renderContext.World)).Vector311; var adjustedScale = scaleFactor; if (flat && astronomical && (markerScale == MarkerScales.World)) { adjustedScale = (float)(scaleFactor / (Earth3d.MainWindow.ZoomFactor / 360)); } var matrixWVP = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; matrixWVP.Transpose(); switch (plotType) { default: case PlotTypes.Gaussian: renderContext.BlendMode = BlendMode.Additive; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, Grids.StarProfile.ResourceView); break; case PlotTypes.Circle: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, CircleTexture.ResourceView); break; case PlotTypes.Point: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, PointTexture.ResourceView); break; case PlotTypes.Square: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, SquareTexture.ResourceView); break; case PlotTypes.Target1: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, Target1Texture.ResourceView); break; case PlotTypes.Target2: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, Target2Texture.ResourceView); break; case PlotTypes.PushPin: renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, PushPin.GetPushPinTexture(markerIndex).ResourceView); break; } columnChartsActivate.TargetState = plotType == PlotTypes.Column; if (shapeFileVertex != null) { if (plotType == PlotTypes.Column && !RenderContext11.Downlevel) // column chart mode { columnChartsActivate.TargetState = true; renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.CullClockwise); renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, null); renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; TimeSeriesColumnChartShader11.Constants.CameraPosition = new Vector4(cam, 1); TimeSeriesColumnChartShader11.Constants.JNow = (float)(SpaceTimeController.JNow - SpaceTimeController.UtcToJulian(baseDate)); TimeSeriesColumnChartShader11.Constants.Decay = timeSeries ? decay : 0f; TimeSeriesColumnChartShader11.Constants.Scale = adjustedScale; TimeSeriesColumnChartShader11.Constants.Sky = astronomical ? -1 : 1; TimeSeriesColumnChartShader11.Constants.Opacity = opacity * Opacity; TimeSeriesColumnChartShader11.Constants.ShowFarSide = ShowFarSide ? 1f : 0f; TimeSeriesColumnChartShader11.Color = new Color4(Color.R / 255f, Color.G / 255f, Color.B / 255f, Color.A / 255f); TimeSeriesColumnChartShader11.Constants.WorldViewProjection = matrixWVP; TimeSeriesColumnChartShader11.ViewportScale = new Vector2(2.0f / renderContext.ViewPort.Width, 2.0f / renderContext.ViewPort.Height); TimeSeriesColumnChartShader11.Use(renderContext.devContext); } else if (plotType == PlotTypes.Cylinder && !RenderContext11.Downlevel) { renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.CullClockwise); renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, null); renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; TimeSeriesColumnChartShaderNGon11.Constants.CameraPosition = new Vector4(cam, 1); TimeSeriesColumnChartShaderNGon11.Constants.JNow = (float)(SpaceTimeController.JNow - SpaceTimeController.UtcToJulian(baseDate)); TimeSeriesColumnChartShaderNGon11.Constants.Decay = timeSeries ? decay : 0f; TimeSeriesColumnChartShaderNGon11.Constants.Scale = adjustedScale; TimeSeriesColumnChartShaderNGon11.Constants.Sky = astronomical ? -1 : 1; TimeSeriesColumnChartShaderNGon11.Constants.Opacity = opacity * Opacity; TimeSeriesColumnChartShaderNGon11.Constants.ShowFarSide = ShowFarSide ? 1f : 0f; TimeSeriesColumnChartShaderNGon11.Color = new Color4(Color.R / 255f, Color.G / 255f, Color.B / 255f, Color.A / 255f); TimeSeriesColumnChartShaderNGon11.Constants.WorldViewProjection = matrixWVP; TimeSeriesColumnChartShaderNGon11.ViewportScale = new Vector2(2.0f / renderContext.ViewPort.Width, 2.0f / renderContext.ViewPort.Height); TimeSeriesColumnChartShaderNGon11.Use(renderContext.devContext); } else { TimeSeriesPointSpriteShader11.Constants.CameraPosition = new Vector4(cam, 1); var jBase = SpaceTimeController.UtcToJulian(baseDate); TimeSeriesPointSpriteShader11.Constants.JNow = (float)(SpaceTimeController.JNow - jBase); TimeSeriesPointSpriteShader11.Constants.Decay = timeSeries ? decay : 0f; TimeSeriesPointSpriteShader11.Constants.Scale = ((markerScale == MarkerScales.World) ? adjustedScale : (-adjustedScale)); TimeSeriesPointSpriteShader11.Constants.Sky = astronomical ? -1 : 1; TimeSeriesPointSpriteShader11.Constants.Opacity = opacity * Opacity; TimeSeriesPointSpriteShader11.Constants.ShowFarSide = ShowFarSide ? 1f : 0f; TimeSeriesPointSpriteShader11.Color = new Color4(Color.R / 255f, Color.G / 255f, Color.B / 255f, Color.A / 255f); TimeSeriesPointSpriteShader11.Constants.WorldViewProjection = matrixWVP; TimeSeriesPointSpriteShader11.ViewportScale = new Vector2(2.0f / renderContext.ViewPort.Width, 2.0f / renderContext.ViewPort.Height); TimeSeriesPointSpriteShader11.PointScaleFactors = new Vector3(0.0f, 0.0f, 10.0f); if (shapeFileVertex.Downlevel) { DownlevelTimeSeriesPointSpriteShader.Use(renderContext.devContext, shapeFileVertex.Instanced); } else { TimeSeriesPointSpriteShader11.Use(renderContext.devContext); } } shapeFileVertex.Draw(renderContext, shapeFileVertex.Count, null, 1.0f); } renderContext.Device.ImmediateContext.GeometryShader.Set(null); renderContext.BlendMode = BlendMode.Alpha; renderContext.World = oldWorld; return true; }
public override bool Draw3D(RenderContext11 renderContext, float opacity, Tile parent) { InViewFrustum = true; RenderedGeneration = CurrentRenderGeneration; if (!ReadyToRender) { TileCache.AddTileToQueue(this); return false; } InViewFrustum = true; if (starVertexBuffer == null) { starProfile = Texture11.FromBitmap( Resources.StarProfile); var count = stars.Count; var index = 0; starCount = count; starVertexBuffer = new PositionColorSizeVertexBuffer11(count, RenderContext11.PrepDevice); var points = (PositionColorSize[])starVertexBuffer.Lock(0, 0); // Lock the buffer (which will return our structs) foreach (var star in stars) { var pos = Coordinates.RADecTo3d(star.RA + 12, star.Dec, 1f); points[index].Position = pos.Vector3; points[index].Color = star.Col; var radDec = (.5) / Math.Pow(1.6, star.Magnitude); points[index].size = (float)radDec; index++; } starVertexBuffer.Unlock(); } renderContext.SetVertexBuffer(starVertexBuffer); renderContext.BlendMode = BlendMode.Additive; renderContext.DepthStencilMode = DepthStencilMode.Off; renderContext.setRasterizerState(TriangleCullMode.Off); var mvp = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mvp.Transpose(); PointSpriteShader11.WVPMatrix = mvp; PointSpriteShader11.Color = Color.White; var adjustedScale = (float)(1 / (Earth3d.MainWindow.ZoomFactor / 360)); PointSpriteShader11.ViewportScale = new Vector2((2.0f / renderContext.ViewPort.Width) * adjustedScale, (2.0f / renderContext.ViewPort.Height) * adjustedScale); PointSpriteShader11.PointScaleFactors = new Vector3(0.0f, 0.0f, 10000.0f); PointSpriteShader11.Use(renderContext.Device.ImmediateContext); renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, starProfile.ResourceView); renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList; renderContext.devContext.Draw(starCount, 0); renderContext.Device.ImmediateContext.GeometryShader.Set(null); // Reset blend mode so we don't mess up subsequent sky layer rendering renderContext.BlendMode = BlendMode.Alpha; return true; }
public void Render(RenderContext11 renderContext, float opacity) { if (dirty && !(ISSLayer)) { Reload(); } Matrix3d oldWorld = renderContext.World; Vector3 offset = mesh.BoundingSphere.Center; float unitScale = 1.0f; if (mesh.BoundingSphere.Radius > 0.0f) { unitScale = 1.0f / mesh.BoundingSphere.Radius; } renderContext.World = Matrix3d.Translation(-offset.X, -offset.Y, -offset.Z) * Matrix3d.Scaling(unitScale, unitScale, unitScale) * oldWorld; Matrix3d worldView = renderContext.World * renderContext.View; Vector3d v = worldView.Transform(Vector3d.Empty); double scaleFactor = Math.Sqrt(worldView.M11 * worldView.M11 + worldView.M22 * worldView.M22 + worldView.M33 * worldView.M33) / unitScale; double dist = v.Length(); double radius = scaleFactor; // Calculate pixelsPerUnit which is the number of pixels covered // by an object 1 AU at the distance of the planet center from // the camera. This calculation works regardless of the projection // type. int viewportHeight = (int)renderContext.ViewPort.Height; double p11 = renderContext.Projection.M11; double p34 = renderContext.Projection.M34; double p44 = renderContext.Projection.M44; double w = Math.Abs(p34) * dist + p44; float pixelsPerUnit = (float)(p11 / w) * viewportHeight; float radiusInPixels = (float)(radius * pixelsPerUnit); if (radiusInPixels < 0.5f) { // Too small to be visible; skip rendering return; } // These colors can be modified by shadows, distance from planet, etc. Restore // the original values after rendering. var savedSunlightColor = renderContext.SunlightColor; var savedReflectedColor = renderContext.ReflectedLightColor; var savedHemiColor = renderContext.HemisphereLightColor; if (Properties.Settings.Default.SolarSystemLighting) { SetupLighting(renderContext); renderContext.AmbientLightColor = System.Drawing.Color.FromArgb(11, 11, 11); } else { // No lighting: set ambient light to white and turn off all other light sources renderContext.SunlightColor = System.Drawing.Color.Black; renderContext.ReflectedLightColor = System.Drawing.Color.Black; renderContext.HemisphereLightColor = System.Drawing.Color.Black; renderContext.AmbientLightColor = System.Drawing.Color.White; } SharpDX.Direct3D11.Device device = renderContext.Device; if (mesh == null) { return; } //Object3dLayer.sketch.DrawLines(renderContext, 1.0f, System.Drawing.Color.Red); renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.BlendMode = BlendMode.Alpha; int count = meshMaterials.Count; mesh.beginDrawing(renderContext); if (count > 0) { for (int i = 0; i < meshMaterials.Count; i++) { if (meshMaterials[i].Default) { Material mat = meshMaterials[i]; mat.Diffuse = Color; mat.Ambient = Color; meshMaterials[i] = mat; } // Set the material and texture for this subset renderContext.SetMaterial(meshMaterials[i], meshTextures[i], meshSpecularTextures[i], meshNormalMaps[i], opacity); renderContext.PreDraw(); renderContext.setSamplerState(0, renderContext.WrapSampler); mesh.drawSubset(renderContext, i); } } else { renderContext.PreDraw(); for (int i = 0; i < meshTextures.Count; i++) { var key = new PlanetShaderKey(PlanetSurfaceStyle.Diffuse, false, 0); renderContext.SetupPlanetSurfaceEffect(key, 1.0f); if (meshTextures[i] != null) { renderContext.MainTexture = meshTextures[i]; } renderContext.PreDraw(); mesh.drawSubset(renderContext, i); } } renderContext.setSamplerState(0, renderContext.ClampSampler); renderContext.setRasterizerState(TriangleCullMode.CullClockwise); renderContext.World = oldWorld; renderContext.SunlightColor = savedSunlightColor; renderContext.ReflectedLightColor = savedReflectedColor; renderContext.HemisphereLightColor = savedHemiColor; renderContext.AmbientLightColor = System.Drawing.Color.Black; }
public override bool Draw(RenderContext11 renderContext, float opacity, bool flat) { Matrix3d oldWorld = renderContext.World; Matrix3d rotation = Matrix3d.RotationZ(-roll / 180f * Math.PI) * Matrix3d.RotationX(-pitch / 180f * Math.PI) * Matrix3d.RotationY(heading / 180f * Math.PI); renderContext.World = rotation * Matrix3d.Scaling(scale.X, scale.Y, scale.Z) * Matrix3d.Translation(translate) * oldWorld; renderContext.TwoSidedLighting = TwoSidedGeometry; renderContext.setRasterizerState(TwoSidedGeometry ? TriangleCullMode.Off : TriangleCullMode.CullCounterClockwise); if (lightID > 0) { //draw light // Planets.DrawPointPlanet(renderContext, new Vector3d(), 1, Color, false, 1.0f); } else { if (object3d != null) { object3d.Color = Color; object3d.Render(renderContext, opacity * Opacity); } } renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); renderContext.TwoSidedLighting = false; if (showEditUi) { if (lightID > 0) { //draw light Planets.DrawPointPlanet(renderContext, new Vector3d(), 1, Color, false, 1.0f); } DepthStencilMode oldDepthMode = renderContext.DepthStencilMode = DepthStencilMode.Off; renderContext.World = Matrix3d.Translation(translate) * oldWorld; Matrix3d wvp = renderContext.World * renderContext.View * renderContext.Projection; Vector3d vc = new Vector3d(0, 0, 0); Vector3d vc1 = new Vector3d(.001, 0, 0); Vector3d vc2 = new Vector3d(0, .001, 0); Vector3d vc3 = new Vector3d(0, 0, .001); Vector3d vs = Vector3d.TransformCoordinate(vc, wvp); Vector3d vs1 = Vector3d.TransformCoordinate(vc1, wvp); Vector3d vs2 = Vector3d.TransformCoordinate(vc2, wvp); Vector3d vs3 = Vector3d.TransformCoordinate(vc3, wvp); Vector2d vsa = new Vector2d(vs.X, vs.Y); Vector2d vsa1 = new Vector2d(vs1.X, vs1.Y) - vsa; Vector2d vsa2 = new Vector2d(vs2.X, vs2.Y) - vsa; Vector2d vsa3 = new Vector2d(vs3.X, vs3.Y) - vsa; uiScale = .0003 / Math.Sqrt((vsa1.Length * vsa1.Length + vsa2.Length * vsa2.Length + vsa3.Length * vsa3.Length)); Matrix3d matUIScale = Matrix3d.Scaling(uiScale, uiScale, uiScale); renderContext.World = matUIScale * renderContext.World; wvp = renderContext.World * renderContext.View * renderContext.Projection; vc1 = new Vector3d(.9, 0, 0); vc2 = new Vector3d(0, .9, 0); vc3 = new Vector3d(0, 0, .9); vs = Vector3d.TransformCoordinate(vc, wvp); vs1 = Vector3d.TransformCoordinate(vc1, wvp); vs2 = Vector3d.TransformCoordinate(vc2, wvp); vs3 = Vector3d.TransformCoordinate(vc3, wvp); double h = renderContext.ViewPort.Height; double w = renderContext.ViewPort.Width; xHandle = new Vector2d((vs1.X + 1) * w / 2, h - ((vs1.Y + 1) * h / 2)); yHandle = new Vector2d((vs2.X + 1) * w / 2, h - ((vs2.Y + 1) * h / 2)); zHandle = new Vector2d((vs3.X + 1) * w / 2, h - ((vs3.Y + 1) * h / 2)); // draw UI if (TranslateUI == null) { InitTranslateUI(); } bool showTranslate = Control.ModifierKeys != Keys.Control && Control.ModifierKeys != Keys.Shift; bool showRotate = Control.ModifierKeys == Keys.Control; bool showScale = Control.ModifierKeys == Keys.Shift; if (showTranslate) { TranslateUILines.DrawLines(renderContext, 1.0f); TranslateUI.Draw(renderContext, 1.0f, TriangleList.CullMode.Clockwise); } else { if (showScale) { TranslateUILines.DrawLines(renderContext, 1.0f); ScaleUI.Draw(renderContext, 1.0f, TriangleList.CullMode.Clockwise); } else { xHandle = new Vector2d(-1000, 0); yHandle = new Vector2d(-1000, 0); zHandle = new Vector2d(-1000, 0); } } renderContext.World = rotation * renderContext.World; if (showRotate) { wvp = renderContext.World * renderContext.View * renderContext.Projection; Vector3d[] hprPoints = new Vector3d[] { new Vector3d(0,0,1), new Vector3d(0,0,-1), new Vector3d(0,1,0), new Vector3d(0,-1,0), new Vector3d(-1,0,0), new Vector3d(1,0,0) }; hprHandles = new Vector2d[6]; for (int i = 0; i < 6; i++) { Vector3d vt = Vector3d.TransformCoordinate(hprPoints[i], wvp); hprHandles[i] = new Vector2d((vt.X + 1) * w / 2, h - ((vt.Y + 1) * h / 2)); } RotateUi.Draw(renderContext, 1.0f, TriangleList.CullMode.Clockwise); } else { hprHandles = new Vector2d[0]; } oldDepthMode = renderContext.DepthStencilMode = oldDepthMode; //restore matrix renderContext.World = oldWorld; showEditUi = false; } renderContext.World = oldWorld; return true; }
// Various input layouts used in 3D solar system mode // TODO Replace with an input layout cache static void DrawRings(RenderContext11 renderContext) { renderContext.setRasterizerState(TriangleCullMode.Off); var ringsKey = new PlanetShaderKey(PlanetSurfaceStyle.PlanetaryRings, false, 0); SetupPlanetSurfaceEffect(renderContext, ringsKey, 1.0f); renderContext.Shader.MainTexture = RingsMap.ResourceView; renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip; renderContext.Device.ImmediateContext.InputAssembler.InputLayout = renderContext.Shader.inputLayout(PlanetShader11.StandardVertexLayout.PositionNormalTex); renderContext.PreDraw(); renderContext.SetVertexBuffer(ringsVertexBuffer); renderContext.devContext.Draw((triangleCountRings+2), 0); renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); }
public static void Draw2D(RenderContext11 renderContext, Texture11 srcTexture, SizeF size, PointF rotationCenter, float rotationAngle, PointF position, System.Drawing.Color color) { cornerPoints[0].Position = MakePosition(position.X, position.Y, -size.Width / 2, -size.Height / 2, rotationAngle).Vector4; cornerPoints[0].Tu = 0; cornerPoints[0].Tv = 0; cornerPoints[0].Color = color; cornerPoints[1].Position = MakePosition(position.X, position.Y, size.Width / 2, -size.Height / 2, rotationAngle).Vector4; cornerPoints[1].Tu = 1; cornerPoints[1].Tv = 0; cornerPoints[1].Color = color; cornerPoints[2].Position = MakePosition(position.X, position.Y, -size.Width / 2, size.Height / 2, rotationAngle).Vector4; cornerPoints[2].Tu = 0; cornerPoints[2].Tv = 1; cornerPoints[2].Color = color; cornerPoints[3].Position = MakePosition(position.X, position.Y, size.Width / 2, size.Height / 2, rotationAngle).Vector4; cornerPoints[3].Tu = 1; cornerPoints[3].Tv = 1; cornerPoints[3].Color = color; renderContext.setRasterizerState(TriangleCullMode.Off); renderContext.DepthStencilMode = DepthStencilMode.Off; DrawForScreen(renderContext, cornerPoints, 4, srcTexture, SharpDX.Direct3D.PrimitiveTopology.TriangleStrip); }
// ** Begin public static void DrawMPC3D(RenderContext11 renderContext, float opacity, Vector3d centerPoint) { var zoom = Earth3d.MainWindow.ZoomFactor; var distAlpha = ((Math.Log(Math.Max(1, zoom), 4)) - 15.5) * 90; var alpha = Math.Min(255, Math.Max(0, (int)distAlpha)); if (alpha > 254) { return; } if (mpcVertexBuffer == null) { for (var i = 0; i < 7; i++) { mpcBlendStates[i] = new BlendState(false, 1000, 0); } if (!initBegun) { var initDelegate = new MethodInvoker(StartInit); initDelegate.BeginInvoke(null, null); initBegun = true; } return; } renderContext.DepthStencilMode = DepthStencilMode.Off; renderContext.setRasterizerState(TriangleCullMode.Off); var offset = Matrix3d.Translation(-centerPoint); var world = renderContext.World * offset; var matrixWVP = (world * renderContext.View * renderContext.Projection).Matrix11; matrixWVP.Transpose(); var cam = Vector3.TransformCoordinate(renderContext.CameraPosition.Vector311, Matrix.Invert(renderContext.World.Matrix11)); renderContext.Device.ImmediateContext.PixelShader.SetShaderResource(0, Grids.StarProfile.ResourceView); renderContext.BlendMode = BlendMode.Additive; if (mpcVertexBuffer != null) { for (var i = 0; i < 7; i++) { mpcBlendStates[i].TargetState = ((Properties.Settings.Default.MinorPlanetsFilter & (int)Math.Pow(2, i)) != 0); if (mpcBlendStates[i].State) { if (mpcVertexBuffer[i].Downlevel) { DownlevelKeplerPointSpriteShader11.Constants.JNow = (float)(SpaceTimeController.JNow - KeplerVertex.baseDate); DownlevelKeplerPointSpriteShader11.Constants.Opacity = opacity * mpcBlendStates[i].Opacity; DownlevelKeplerPointSpriteShader11.Constants.MM = 0; DownlevelKeplerPointSpriteShader11.Constants.WorldViewProjection = matrixWVP; DownlevelKeplerPointSpriteShader11.Constants.Scale = new Vector2(100f, 100f); DownlevelKeplerPointSpriteShader11.Constants.ViewportScale = new Vector2(2f / renderContext.ViewPort.Width, 2f / renderContext.ViewPort.Height); DownlevelKeplerPointSpriteShader11.Constants.CameraPosition = new Vector4(cam, 1); DownlevelKeplerPointSpriteShader11.Use(renderContext.devContext, mpcVertexBuffer[i].Instanced); } else { KeplerPointSpriteShader11.Constants.JNow = (float)(SpaceTimeController.JNow - KeplerVertex.baseDate); KeplerPointSpriteShader11.Constants.Opacity = opacity * mpcBlendStates[i].Opacity; KeplerPointSpriteShader11.Constants.MM = 0; KeplerPointSpriteShader11.Constants.WorldViewProjection = matrixWVP; KeplerPointSpriteShader11.Constants.Scale = new Vector2(100f, 100f); KeplerPointSpriteShader11.Constants.ViewportScale = new Vector2(2f / renderContext.ViewPort.Width, 2 / renderContext.ViewPort.Height); KeplerPointSpriteShader11.Constants.CameraPosition = new Vector4(cam, 1); KeplerPointSpriteShader11.Use(renderContext.devContext); } mpcVertexBuffer[i].Draw(renderContext, mpcVertexBuffer[i].Count, null, opacity); } } } renderContext.BlendMode = BlendMode.Alpha; renderContext.Device.ImmediateContext.GeometryShader.Set(null); }
public virtual bool Draw3D(RenderContext11 renderContext, bool showOnlySelected, float opacity, string focusConsteallation, bool reverse) { constToDraw = focusConsteallation; Lineset lsSelected = null; foreach (Lineset ls in this.lines) { bool enabled = boundry ? Settings.Active.ConstellationBoundariesFilter.IsSet(ls.Name) : Settings.Active.ConstellationFiguresFilter.IsSet(ls.Name); if (enabled) { if (constToDraw == ls.Name && boundry) { lsSelected = ls; } else if (!showOnlySelected || !boundry) { DrawSingleConstellation(renderContext, ls, opacity, reverse, true); } } } if (lsSelected != null) { DrawSingleConstellation(renderContext, lsSelected, opacity, reverse, true); } renderContext.setRasterizerState(TriangleCullMode.Off, true); return true; }
public static void DrawForScreen(RenderContext11 renderContext, PositionColoredTextured[] points, int count, Texture11 texture, PrimitiveTopology primitiveType) { if (VertexBuffer == null) { VertexBuffer = new Buffer(renderContext.Device, Marshal.SizeOf(points[0]) * 2500, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None, Marshal.SizeOf(points[0])); VertexBufferBinding = new VertexBufferBinding(VertexBuffer, Marshal.SizeOf((points[0])), 0); } renderContext.devContext.InputAssembler.PrimitiveTopology = primitiveType; renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.Off); var mat = Matrix.Translation(-renderContext.ViewPort.Width / 2, -renderContext.ViewPort.Height / 2, 0) * Matrix.Scaling(1f, -1f, 1f) * Matrix.OrthoLH(renderContext.ViewPort.Width, renderContext.ViewPort.Height, 1, -1); mat.Transpose(); WarpOutputShader.MatWVP = mat; WarpOutputShader.Use(renderContext.devContext, texture != null); renderContext.SetVertexBuffer(VertexBufferBinding); var box = renderContext.devContext.MapSubresource(VertexBuffer, 0, MapMode.WriteDiscard, MapFlags.None); Utilities.Write(box.DataPointer, points, 0, count); renderContext.devContext.UnmapSubresource(VertexBuffer, 0); if (texture != null) { renderContext.devContext.PixelShader.SetShaderResource(0, texture.ResourceView); } else { renderContext.devContext.PixelShader.SetShaderResource(0, null); } renderContext.devContext.Draw(count, 0); }
public static void DrawPointPlanet(RenderContext11 renderContext, Vector3d location, float size, Color color, bool zOrder, float opacity) { var vertices = new PositionColorSize[1]; vertices[0].Position = location.Vector311; vertices[0].size = size * 200; vertices[0].Color = color; if (planetsPointSet == null) { planetsPointSet = new PointSpriteSet(renderContext.Device, vertices); planetsPointSet.PointScaleFactors = new Vector3(1.0f, 0.0f, 0.0f); } else { planetsPointSet.updateVertexBuffer(vertices); } renderContext.BlendMode = BlendMode.Additive; renderContext.DepthStencilMode = zOrder ? DepthStencilMode.ZReadOnly : DepthStencilMode.Off; renderContext.setRasterizerState(TriangleCullMode.Off); planetsPointSet.Draw(renderContext, 1, Grids.StarProfile, opacity); renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.BlendMode = BlendMode.Alpha; }
public static bool DrawPlanets3D(RenderContext11 renderContext, float opacity, Vector3d centerPoint) { InitPlanetResources(); renderContext.LightingEnabled = Settings.Active.SolarSystemLighting; if (!Properties.Settings.Default.SolarSystemPlanets.TargetState) { return true; } drawOrder.Clear(); var camera = new Vector3d(renderContext.CameraPosition); for (var planetId = 0; planetId < 14; planetId++) { if (!planetLocations[planetId].Eclipsed) { var distVector = camera - (planet3dLocations[planetId] - centerPoint); if (!drawOrder.ContainsKey(-distVector.Length())) { drawOrder.Add(-distVector.Length(), planetId); } } } var distVectorEarth = camera - (planet3dLocations[(int)SolarSystemObjects.Earth] - centerPoint); if (!drawOrder.ContainsKey(-distVectorEarth.Length())) { drawOrder.Add(-distVectorEarth.Length(), (int)SolarSystemObjects.Earth); } renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); foreach (var planetId in drawOrder.Values) { DrawPlanet3d(renderContext, planetId, centerPoint, opacity); } var distss = UiTools.SolarSystemToMeters(Earth3d.MainWindow.SolarSystemCameraDistance); //double val1 = Math.Log(200000000, 10)-7.3; //double val2 = Math.Log(20000000, 10)-7.3; var moonFade = (float)Math.Min(1, Math.Max(Math.Log(distss, 10) - 7.3, 0)); var fade = (float)Math.Min(1, Math.Max(Math.Log(distss, 10) - 8.6, 0)); if (Properties.Settings.Default.SolarSystemOrbits.State ) // && fade > 0) { renderContext.DepthStencilMode = DepthStencilMode.ZReadOnly; renderContext.BlendMode = BlendMode.Alpha; renderContext.setRasterizerState(TriangleCullMode.Off, false); var orbitColor = Color.FromArgb((int)(Properties.Settings.Default.SolarSystemOrbits.Opacity * 255), Properties.Settings.Default.SolarSystemOrbitColor).ToArgb(); for (var ii = 1; ii < 10; ii++) { var id = ii; if (ii == 9) { id = 19; } var angle = Math.Atan2(planet3dLocations[id].Z, planet3dLocations[id].X); orbitBlendStates[id].TargetState = (Properties.Settings.Default.PlanetOrbitsFilter & (int)Math.Pow(2, id)) != 0; if (orbitBlendStates[id].State) { if (Properties.Settings.Default.UsePlanetColorsForOrbits) { DrawSingleOrbit(renderContext, UiTools.GetTransparentColor(planetColors[id].ToArgb(), Properties.Settings.Default.SolarSystemOrbits.Opacity * fade * orbitBlendStates[id].Opacity), id, centerPoint, angle, planet3dLocations[id]); } else { DrawSingleOrbit(renderContext, orbitColor, id, centerPoint, angle, planet3dLocations[id]); } } } // Show the orbit of the Moon orbitBlendStates[(int)SolarSystemObjects.Moon].TargetState = (Properties.Settings.Default.PlanetOrbitsFilter & (int)Math.Pow(2, (int)SolarSystemObjects.Moon)) != 0; if (orbitBlendStates[(int)SolarSystemObjects.Moon].State) { var id = (int)SolarSystemObjects.Moon; DrawSingleOrbit(renderContext, UiTools.GetTransparentColor(planetColors[id].ToArgb(), Properties.Settings.Default.SolarSystemOrbits.Opacity * moonFade * orbitBlendStates[(int)SolarSystemObjects.Moon].Opacity), id, centerPoint, 0.0, planet3dLocations[id]); } // Show orbits of the Galilean satellites { var deltaT = 1.0 / 1440.0 * 0.1; // Compute the positions of the Galilean satellites at two times; we need // the second in order to estimate the velocity. var gal0 = CAAGalileanMoons.Calculate(jNow); var gal1 = CAAGalileanMoons.Calculate(jNow - deltaT); CAA3DCoordinate[] position0 = { gal0.Satellite1.EclipticRectangularCoordinates, gal0.Satellite2.EclipticRectangularCoordinates, gal0.Satellite3.EclipticRectangularCoordinates, gal0.Satellite4.EclipticRectangularCoordinates }; CAA3DCoordinate[] position1 = { gal1.Satellite1.EclipticRectangularCoordinates, gal1.Satellite2.EclipticRectangularCoordinates, gal1.Satellite3.EclipticRectangularCoordinates, gal1.Satellite4.EclipticRectangularCoordinates }; SolarSystemObjects[] galileans = { SolarSystemObjects.Io, SolarSystemObjects.Europa, SolarSystemObjects.Ganymede, SolarSystemObjects.Callisto }; for (var i = 0; i < 4; ++i) { var id = (int)galileans[i]; orbitBlendStates[id].TargetState = (Properties.Settings.Default.PlanetOrbitsFilter & (int)Math.Pow(2, id)) != 0; if (orbitBlendStates[id].State) { // Estimate velocity through differences var r0 = new Vector3d(position0[i].X, position0[i].Z, position0[i].Y); var r1 = new Vector3d(position1[i].X, position1[i].Z, position1[i].Y); var v = (r0 - r1) / deltaT; var elements = stateVectorToKeplerian(r0, v, muJupiter); DrawSingleOrbit(renderContext, UiTools.GetTransparentColor(planetColors[id].ToArgb(), Properties.Settings.Default.SolarSystemOrbits.Opacity * moonFade * orbitBlendStates[id].Opacity), id, centerPoint, 0.0, planet3dLocations[id], elements); } } } renderContext.setRasterizerState(TriangleCullMode.Off, true); } renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.BlendMode = BlendMode.None; return true; }
static void DrawSphere(RenderContext11 renderContext, Texture11 texture, int planetID, int sphereIndex, bool noMultires, bool drawLayers, PlanetShaderKey shaderKey) { var useMultires = Settings.Active.SolarSystemMultiRes && !noMultires; // Let an override layer take the place of the standard layer IImageSet defaultLayer = null; var defaultLayerColor = Color.White; if (drawLayers) { var referenceFrameName = Enum.GetName(typeof(SolarSystemObjects), (SolarSystemObjects)planetID); foreach (var layer in LayerManager.AllMaps[referenceFrameName].Layers) { if (layer.Enabled && layer is ImageSetLayer) { if (((ImageSetLayer)layer).OverrideDefaultLayer) { defaultLayer = ((ImageSetLayer)layer).ImageSet; defaultLayerColor = layer.Color; useMultires = true; break; } } } } if (useMultires) { renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; if (sphereIndex < 4) { IImageSet planet = null; if (defaultLayer != null) { planet = defaultLayer; } else { var planetName = GetNameFrom3dId(planetID); var imageSetName = planetName == "Mars" ? "Visible Imagery" : planetName; planet = Earth3d.MainWindow.GetImagesetByName(imageSetName); } if (planet != null) { var normColor = new Vector4(defaultLayerColor.R, defaultLayerColor.G, defaultLayerColor.B, defaultLayerColor.A) * (1.0f / 255.0f); if (RenderContext11.sRGB) { normColor.X = (float) Math.Pow(normColor.X, 2.2); normColor.Y = (float)Math.Pow(normColor.Y, 2.2); normColor.Z = (float)Math.Pow(normColor.Z, 2.2); } renderContext.Shader.DiffuseColor = normColor; renderContext.setRasterizerState(TriangleCullMode.CullClockwise); Earth3d.MainWindow.DrawTiledSphere(planet, 100, Color.White); if (planetID == (int)SolarSystemObjects.Earth && Settings.Active.ShowClouds) { if (CloudTexture != null) { var cloudShaderKey = new PlanetShaderKey(PlanetSurfaceStyle.Diffuse, Settings.Active.ShowEarthSky, 0); cloudShaderKey.eclipseShadowCount = shaderKey.eclipseShadowCount; cloudShaderKey.HasAtmosphere = shaderKey.HasAtmosphere; if (!Settings.Active.SolarSystemLighting) { cloudShaderKey.style = PlanetSurfaceStyle.Emissive; } SetupPlanetSurfaceEffect(renderContext, cloudShaderKey, 1.0f); SetAtmosphereConstants(renderContext, planetID, 1.0f, CalcSkyGeometryHeight(planetID)); renderContext.MainTexture = CloudTexture; var savedWorld = renderContext.World; var cloudScale = 1.0 + (EarthCloudHeightMeters) / 6378100.0; renderContext.World = Matrix3d.Scaling(cloudScale, cloudScale, cloudScale) * renderContext.World; renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); renderContext.DepthStencilMode = DepthStencilMode.Off; renderContext.BlendMode = BlendMode.Alpha; DrawFixedResolutionSphere(renderContext, sphereIndex); renderContext.World = savedWorld; renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.BlendMode = BlendMode.None; } } return; } } } renderContext.MainTexture = texture; renderContext.Device.ImmediateContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList; renderContext.Device.ImmediateContext.InputAssembler.InputLayout = renderContext.Shader.inputLayout(PlanetShader11.StandardVertexLayout.PositionNormalTex2); renderContext.PreDraw(); renderContext.SetVertexBuffer(sphereVertexBuffers[sphereIndex]); renderContext.SetIndexBuffer(sphereIndexBuffers[sphereIndex]); renderContext.devContext.DrawIndexed(sphereIndexBuffers[sphereIndex].Count, 0, 0); }
public void DrawLines(RenderContext11 renderContext, float opacity, Color color) { if (linePoints.Count < 2) { return; } InitLineBuffer(); Matrix3d savedWorld = renderContext.World; Matrix3d savedView = renderContext.View; if (localCenter != Vector3d.Empty) { usingLocalCenter = true; Vector3d temp = localCenter; if (UseNonRotatingFrame) { renderContext.World = Matrix3d.Translation(temp) * renderContext.WorldBaseNonRotating * Matrix3d.Translation(-renderContext.CameraPosition); } else { renderContext.World = Matrix3d.Translation(temp) * renderContext.WorldBase * Matrix3d.Translation(-renderContext.CameraPosition); } renderContext.View = Matrix3d.Translation(renderContext.CameraPosition) * renderContext.ViewBase; } renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.LineList; Color col = Color.FromArgb((int)(color.A * opacity), (int)(color.R * opacity), (int)(color.G * opacity), (int)(color.B * opacity)); SimpleLineShader11.Color = col; SharpDX.Matrix mat = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mat.Transpose(); SimpleLineShader11.WVPMatrix = mat; SimpleLineShader11.CameraPosition = Vector3d.TransformCoordinate(renderContext.CameraPosition, Matrix3d.Invert(renderContext.World)).Vector3; SimpleLineShader11.ShowFarSide = true; SimpleLineShader11.Sky = Sky; renderContext.setRasterizerState(TriangleCullMode.CullClockwise); if (DepthBuffered) { renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; } else { renderContext.DepthStencilMode = DepthStencilMode.Off; } SimpleLineShader11.Use(renderContext.devContext); if (aaFix) { renderContext.setRasterizerState(TriangleCullMode.Off, false); } foreach (PositionVertexBuffer11 lineBuffer in lineBuffers) { renderContext.SetVertexBuffer(lineBuffer); renderContext.SetIndexBuffer(null); renderContext.devContext.Draw(lineBuffer.Count, 0); } if (aaFix) { renderContext.setRasterizerState(TriangleCullMode.Off, true); } if (usingLocalCenter) { renderContext.World = savedWorld; renderContext.View = savedView; } }
public void Draw(RenderContext11 renderContext, float opacity, CullMode cull) { renderContext.BlendMode = BlendMode.Alpha; if (trianglePoints.Count < 1 && !dataToDraw) { return; } InitTriangleBuffer(); renderContext.DepthStencilMode = DepthBuffered ? (WriteZbuffer ? DepthStencilMode.ZReadWrite : DepthStencilMode.ZReadOnly) : DepthStencilMode.Off; renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList; switch (cull) { case CullMode.Clockwise: renderContext.setRasterizerState(TriangleCullMode.CullClockwise); break; case CullMode.CounterClockwise: renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); break; case CullMode.None: renderContext.setRasterizerState(TriangleCullMode.Off); break; default: break; } if (AutoTime) { DateTime baseDate = new DateTime(2010, 1, 1, 12, 00, 00); LineShaderNormalDates11.Constants.JNow = (float)(SpaceTimeController.JNow - SpaceTimeController.UtcToJulian(baseDate)); } else { LineShaderNormalDates11.Constants.JNow = (float)JNow; } LineShaderNormalDates11.Constants.Sky = 0 ; LineShaderNormalDates11.Constants.ShowFarSide = ShowFarSide ? 1 : 0; if (TimeSeries) { LineShaderNormalDates11.Constants.Decay = (float)Decay; } else { LineShaderNormalDates11.Constants.Decay = 0; } LineShaderNormalDates11.Constants.Opacity = opacity; LineShaderNormalDates11.Constants.CameraPosition = new SharpDX.Vector4(Vector3d.TransformCoordinate(renderContext.CameraPosition, Matrix3d.Invert(renderContext.World)).Vector311, 1); SharpDX.Matrix mat = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mat.Transpose(); LineShaderNormalDates11.Constants.WorldViewProjection = mat; LineShaderNormalDates11.Use(renderContext.devContext); foreach (TimeSeriesLineVertexBuffer11 vertBuffer in triangleBuffers) { renderContext.SetVertexBuffer(vertBuffer); renderContext.devContext.Draw(vertBuffer.Count, 0); } }
public void Draw(RenderContext11 renderContext, float opacity, Color color) { if (glyphCache == null || glyphCache.Version > glyphVersion) { PrepareBatch(); } Color col = Color.FromArgb((int)(color.A * opacity), (int)(color.R * opacity), (int)(color.G * opacity), (int)(color.B * opacity)); SimpleGeometryShader11.Color = col; SharpDX.Matrix mat = (renderContext.World * renderContext.View * renderContext.Projection).Matrix11; mat.Transpose(); SimpleGeometryShader11.WVPMatrix = mat; renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); BlendMode bm = renderContext.BlendMode; DepthStencilMode dm = renderContext.DepthStencilMode; //renderContext.DepthStencilMode = DepthStencilMode.ZReadOnly; renderContext.BlendMode = BlendMode.Alpha; SimpleGeometryShader11.Use(renderContext.devContext); renderContext.MainTexture = glyphCache.Texture; // Debug to get Glyhph textures and caches // SharpDX.Direct3D11.Texture2D.ToFile(renderContext.devContext, glyphCache.Texture.Texture, SharpDX.Direct3D11.ImageFileFormat.Png, "c:\\temp\\texture2.png"); renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList; renderContext.SetVertexBuffer(vertexBuffer); renderContext.devContext.Draw(vertexBuffer.Count, 0); renderContext.DepthStencilMode = dm; renderContext.BlendMode = bm; //dump cache // glyphCache.SaveToXML("c:\\temp\\glyphCache.xml"); }
private static void DrawPlanet3d(RenderContext11 renderContext, int planetID, Vector3d centerPoint, float opacity) { // Assume that KML is only used for Earth KmlLabels kmlMarkers = null; if (planetID == (int)SolarSystemObjects.Earth) { kmlMarkers = Earth3d.MainWindow.KmlMarkers; if (kmlMarkers != null) { kmlMarkers.ClearGroundOverlays(); } } var matOld = renderContext.World; var matOldBase = renderContext.WorldBase; var matOldNonRotating = renderContext.WorldBaseNonRotating; var radius = GetAdjustedPlanetRadius(planetID); SetupPlanetMatrix(renderContext, planetID, centerPoint, true); LayerManager.PreDraw(renderContext, 1.0f, false, Enum.GetName(typeof(SolarSystemObjects), (SolarSystemObjects)planetID), true); float planetWidth = 1; if (planetID == (int)SolarSystemObjects.Saturn) { planetWidth = 3; } if (IsPlanetInFrustum(renderContext, planetWidth)) { // Save all matrices modified by SetupMatrix... var matOld2 = renderContext.World; var matOldBase2 = renderContext.WorldBase; var matOldNonRotating2 = renderContext.WorldBaseNonRotating; renderContext.World = matOld; renderContext.WorldBase = matOldBase; renderContext.WorldBaseNonRotating = matOldNonRotating; SetupMatrixForPlanetGeometry(renderContext, planetID, centerPoint, true); var loc = planet3dLocations[planetID] - centerPoint; loc.Subtract(renderContext.CameraPosition); var dist = loc.Length(); var sizeIndexParam = (2 * Math.Atan(.5 * (radius / dist))) / Math.PI * 180; // Calculate pixelsPerUnit which is the number of pixels covered // by an object 1 AU at the distance of the planet center from // the camera. This calculation works regardless of the projection // type. var viewportHeight = renderContext.ViewPort.Height; var p11 = renderContext.Projection.M11; var p34 = renderContext.Projection.M34; var p44 = renderContext.Projection.M44; var w = Math.Abs(p34) * dist + p44; var pixelsPerUnit = (float)(p11 / w) * viewportHeight; var planetRadiusInPixels = (float)(radius * pixelsPerUnit); var sizeIndex = 0; if (sizeIndexParam > 10.5) { sizeIndex = 0; } else if (sizeIndexParam > 3.9) { sizeIndex = 1; } else if (sizeIndexParam > .72) { sizeIndex = 2; } else if (sizeIndexParam > 0.057) { sizeIndex = 3; } else { sizeIndex = 4; } var eclipseShadowCount = 0; var hasRingShadowsOnPlanet = false; // No shadows should be drawn if Solar System Lighting is OFF if (Settings.Active.SolarSystemLighting) { // Eclipse shadow setup for Earth if (planetID == (int)SolarSystemObjects.Earth) { if (sizeIndex < 2) { var width = Settings.Active.SolarSystemScale * .00001f; SetupShadow(renderContext, centerPoint, width, SolarSystemObjects.Moon, 0); eclipseShadowCount = 1; } } // Eclipse shadow setup for Jupiter // Shadow widths based only on moon diameter in relation to Moon diameter if (planetID == (int)SolarSystemObjects.Jupiter && sizeIndex < 3) { var p = 0; float width; if (planetLocations[(int)SolarSystemObjects.Callisto].Shadow) { width = Settings.Active.SolarSystemScale * .0000139f; SetupShadow(renderContext, centerPoint, width, SolarSystemObjects.Callisto, p++); } if (planetLocations[(int)SolarSystemObjects.Ganymede].Shadow) { width = Settings.Active.SolarSystemScale * .0000152f; SetupShadow(renderContext, centerPoint, width, SolarSystemObjects.Ganymede, p++); } if (planetLocations[(int)SolarSystemObjects.Io].Shadow) { width = Settings.Active.SolarSystemScale * .0000105f; SetupShadow(renderContext, centerPoint, width, SolarSystemObjects.Io, p++); } if (planetLocations[(int)SolarSystemObjects.Europa].Shadow) { width = Settings.Active.SolarSystemScale * .000009f; SetupShadow(renderContext, centerPoint, width, SolarSystemObjects.Europa, p++); } eclipseShadowCount = p; } // Ring shadows on Saturn if (planetID == (int)SolarSystemObjects.Saturn && Settings.Active.SolarSystemLighting) { hasRingShadowsOnPlanet = true; } //ShadowStuff end } // Get the position of the Sun relative to the planet center; the position is // in the world coordinate frame. var sunPosition = (planet3dLocations[0] - planet3dLocations[planetID]); renderContext.SunPosition = sunPosition; if (sizeIndex < 4) { var atmosphereOn = (planetID == 19 || planetID == 3) && Settings.Active.ShowEarthSky; if (planetID == 0 && sizeIndex > 1) { //todo11 //device.RenderState.Clipping = false; DrawPointPlanet(renderContext, new Vector3d(0, 0, 0), (float)Math.Min(1.6, sizeIndexParam) * 2, planetColors[planetID], true, opacity); //todo11 //device.RenderState.Clipping = true; } var surfaceStyle = PlanetSurfaceStyle.Diffuse; if (planetID == (int)SolarSystemObjects.Sun || !Settings.Active.SolarSystemLighting) { surfaceStyle = PlanetSurfaceStyle.Emissive; } else if (planetID == (int)SolarSystemObjects.Moon || planetID == (int)SolarSystemObjects.Mercury) { // Use Lommel-Seeliger photometric model for regolith covered bodies // surfaceStyle = PlanetSurfaceStyle.LommelSeeliger; } var skyGeometryHeight = CalcSkyGeometryHeight(planetID); var shaderKey = new PlanetShaderKey(surfaceStyle, atmosphereOn, eclipseShadowCount); shaderKey.HasRingShadows = hasRingShadowsOnPlanet; if (kmlMarkers != null) { shaderKey.overlayTextureCount = Math.Min(kmlMarkers.GroundOverlayCount, PlanetShader11.MaxOverlayTextures); } SetupPlanetSurfaceEffect(renderContext, shaderKey, opacity); renderContext.LocalCenter = Vector3d.Empty; // Set up any overlay textures if (shaderKey.overlayTextureCount > 0) { if (renderContext.ShadersEnabled) { kmlMarkers.SetupGroundOverlays(renderContext); } } if (shaderKey.eclipseShadowCount > 0) { renderContext.Shader.EclipseTexture = PlanetShadow.ResourceView; } if (shaderKey.HasRingShadows) { renderContext.Shader.RingTexture = RingsMap.ResourceView; } if (atmosphereOn) { SetAtmosphereConstants(renderContext, planetID, 1.0f, skyGeometryHeight); } // Disable overlays after we're done rendering the planet surface (i.e. we don't want // them on any rings, sky shell, or cloud layer.) shaderKey.overlayTextureCount = 0; renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); if (planetID == 19 && !Settings.Active.SolarSystemMultiRes && Settings.Active.SolarSystemLighting) { shaderKey.style = PlanetSurfaceStyle.DiffuseAndNight; SetupPlanetSurfaceEffect(renderContext, shaderKey, opacity); if (atmosphereOn) { SetAtmosphereConstants(renderContext, planetID, 1.0f, skyGeometryHeight); } // Set eclipse constants var eclipseShadowWidth = Settings.Active.SolarSystemScale * .00001f; if (shaderKey.eclipseShadowCount > 0) { SetupShadow(renderContext, centerPoint, eclipseShadowWidth, SolarSystemObjects.Moon, 0); renderContext.Shader.EclipseTexture = PlanetShadow.ResourceView; } renderContext.Shader.NightTexture = planetTexturesMaps[20].ResourceView; renderContext.BlendMode = BlendMode.None; DrawSphere(renderContext, planetTexturesMaps[planetID], planetID, sizeIndex, false, false, shaderKey); // Set up for rendering specular pass shaderKey.style = PlanetSurfaceStyle.SpecularPass; SetupPlanetSurfaceEffect(renderContext, shaderKey, opacity); if (shaderKey.eclipseShadowCount > 0) { SetupShadow(renderContext, centerPoint, eclipseShadowWidth, SolarSystemObjects.Moon, 0); renderContext.Shader.EclipseTexture = PlanetShadow.ResourceView; } if (atmosphereOn) { SetAtmosphereConstants(renderContext, planetID, 1.0f, skyGeometryHeight); } // Set up specular properties; this should eventually be abstracted by RenderContext renderContext.Shader.SpecularPower = 50.0f; renderContext.Shader.SpecularColor = new Vector4(0.5f, 0.5f, 0.5f, 0.0f); renderContext.BlendMode = BlendMode.Additive; DrawSphere(renderContext, planetTexturesMaps[21], planetID, sizeIndex, false, true, shaderKey); renderContext.BlendMode = BlendMode.None; } else { renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.PreDraw(); DrawSphere(renderContext, planetTexturesMaps[planetID], planetID, sizeIndex, false, true, shaderKey); } // Render the sky geometry. This is a sphere slightly larger than the planet where the // only light is from atmospheric scattering. We'll render inside of the sphere only. if (atmosphereOn) { // The sky geometry needs to be slightly larger than the planet itself, so adjust the // world matrix by a scale factor a bit greater than 1.0 var savedWorld = renderContext.World; var world = renderContext.World; var skyRadius = skyGeometryHeight + 1.0f; world.ScalePrepend(new Vector3d(skyRadius, skyRadius, skyRadius)); renderContext.World = world; shaderKey.style = PlanetSurfaceStyle.Sky; var atmosphereShader = SetupPlanetSurfaceEffect(renderContext, shaderKey, 1.0f); renderContext.Shader = atmosphereShader; // Set the shadow texture if there's an eclipse if (shaderKey.eclipseShadowCount > 0) { atmosphereShader.EclipseTexture = PlanetShadow.ResourceView; } // Atmosphere height is relative to the size of the sphere being rendered. Since we're // actually rendering the shell geometry here, we just use a value of 0 for the height // and a lower value for the zero height. SetAtmosphereConstants(renderContext, planetID, 1.0f + skyGeometryHeight, 0.0f); // We're rendering just the atmosphere; there's no contribution from a surface, so set the // diffuse color to black. atmosphereShader.DiffuseColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f); atmosphereShader.Opacity = 0.0f; //renderContext.BlendMode = BlendMode.Alpha; // Fade out the sky geometry as its screen size gets thin; this prevents terrible // aliasing that occurs. var skyShellPixels = (float)(skyGeometryHeight * radius * pixelsPerUnit); var blendFactor = Math.Min(3.0f, skyShellPixels) / 3.0f; renderContext.BlendMode = BlendMode.BlendFactorInverseAlpha; renderContext.BlendFactor = new Color4(blendFactor, blendFactor, blendFactor, 1.0f); renderContext.DepthStencilMode = DepthStencilMode.ZReadOnly; //Render the _inside_ of the sphere. No need for multires or layers when drawing the sky renderContext.setRasterizerState(TriangleCullMode.CullClockwise); DrawSphere(renderContext, planetTexturesMaps[planetID], planetID, 0/*sizeIndex*/, true, false, shaderKey); // Reset device state renderContext.setRasterizerState(TriangleCullMode.CullCounterClockwise); renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite; renderContext.BlendMode = BlendMode.None; // Restore the world matrix renderContext.World = savedWorld; } RestoreDefaultMaterialState(renderContext); if (planetID == 5) { var ringsKey = new PlanetShaderKey(PlanetSurfaceStyle.PlanetaryRings, false, 0); SetupPlanetSurfaceEffect(renderContext, ringsKey, 1.0f); DrawRings(renderContext); RestoreDefaultMaterialState(renderContext); } } else { if (planetID == 0) { DrawPointPlanet(renderContext, new Vector3d(0, 0, 0), (float)(10 * planetDiameters[planetID]), planetColors[planetID], true, opacity); } else if (planetID < (int)SolarSystemObjects.Moon || planetID == (int)SolarSystemObjects.Earth) { var size = (float)(800 * planetDiameters[planetID]); DrawPointPlanet(renderContext, new Vector3d(0, 0, 0), (float)Math.Max(.05, Math.Min(.1f, size)), planetColors[planetID], true, opacity); } else if (sizeIndexParam > .002) { var size = (float)(800 * planetDiameters[planetID]); DrawPointPlanet(renderContext, new Vector3d(0, 0, 0), (float)Math.Max(.05, Math.Min(.1f, size)), planetColors[planetID], true, opacity); } } // Restore all matrices modified by SetupMatrix... renderContext.World = matOld2; renderContext.WorldBase = matOldBase2; renderContext.WorldBaseNonRotating = matOldNonRotating2; } { var sunPosition = (planet3dLocations[0] - centerPoint); var planetPosition = planet3dLocations[planetID] - centerPoint; renderContext.SunPosition = sunPosition; renderContext.ReflectedLightPosition = planetPosition; if (planetID == (int)SolarSystemObjects.Earth) { renderContext.ReflectedLightColor = Color.FromArgb(50, 70, 90); renderContext.HemisphereLightColor = Color.FromArgb(100, 100, 100); } else { renderContext.ReflectedLightColor = Color.Black; renderContext.HemisphereLightColor = Color.Black; } renderContext.OccludingPlanetPosition = planetPosition; renderContext.OccludingPlanetRadius = planetDiameters[planetID] / 2.0; } LayerManager.Draw(renderContext, 1.0f, false, Enum.GetName(typeof(SolarSystemObjects), (SolarSystemObjects)planetID), true, false); // Reset render context state renderContext.ReflectedLightColor = Color.Black; renderContext.HemisphereLightColor = Color.Black; renderContext.World = matOld; Earth3d.MainWindow.MakeFrustum(); RestoreDefaultMaterialState(renderContext); renderContext.setRasterizerState(TriangleCullMode.CullClockwise); }