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);
}
// Draw an ellipse with the specified semi-major axis and eccentricity. The orbit is drawn over a single period,
// fading from full brightness at the given eccentric anomaly.
//
// In order to match exactly the position at which a planet is drawn, the planet's position at the current time
// must be passed as a parameter. positionNow is in the current coordinate system of the render context, not the
// translated and rotated system of the orbital plane.
public static void DrawEllipse(RenderContext11 renderContext, double semiMajorAxis, double eccentricity, double eccentricAnomaly, Color color, Matrix3d worldMatrix, Vector3d positionNow)
{
if (ellipseShader == null)
{
ellipseShader = new EllipseShader11();
}
if (ellipseVertexBuffer == null)
{
ellipseVertexBuffer = CreateEllipseVertexBuffer( 500);
}
Matrix3d savedWorld = renderContext.World;
renderContext.World = worldMatrix;
renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.LineStrip;
renderContext.SetVertexBuffer(ellipseVertexBuffer);
ellipseShader.UseShader(renderContext, semiMajorAxis, eccentricity, eccentricAnomaly, new SharpDX.Color(color.R, color.G, color.B, color.A), savedWorld, positionNow);
renderContext.devContext.Draw(ellipseVertexBuffer.Count, 0);
renderContext.World = savedWorld;
}
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 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 beginDrawing(RenderContext11 renderContext)
{
if (vertexBuffer != null)
{
renderContext.SetVertexBuffer(vertexBuffer);
}
else if (tangentVertexBuffer != null)
{
renderContext.SetVertexBuffer(tangentVertexBuffer);
}
if (indexBuffer != null)
{
renderContext.SetIndexBuffer(indexBuffer);
}
SharpDX.Direct3D11.DeviceContext devContext = renderContext.Device.ImmediateContext;
devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
}
public override bool Draw3D(RenderContext11 renderContext, float transparancy, Tile parent)
{
InViewFrustum = true;
transparancy = transparancy / 100;
if (transparancy > 1f)
{
transparancy = 1.0f;
}
if (transparancy < 0f)
{
transparancy = 0;
}
if (!ReadyToRender)
{
TileCache.AddTileToQueue(this);
if (texture == null)
{
return false;
}
}
if (!CreateGeometry(renderContext, true))
{
return false;
}
renderContext.MainTexture = texture;
renderContext.SetVertexBuffer(vertexBuffer);
renderContext.SetIndexBuffer(indexBuffer);
renderContext.PreDraw();
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
renderContext.devContext.DrawIndexed(6, 0, 0);
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 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");
}
public override bool Draw3D(RenderContext11 renderContext, float transparancy, Tile parent)
{
RenderedGeneration = CurrentRenderGeneration;
TilesTouched++;
InViewFrustum = true;
if (!ReadyToRender)
{
TileCache.AddTileToQueue(this);
return false;
}
TilesInView++;
if (!CreateGeometry(renderContext, true))
{
return false;
}
renderContext.SetVertexBuffer(vertexBuffer);
renderContext.MainTexture = texture;
renderContext.SetIndexBuffer( indexBuffer[0]);
int partCount = this.TriangleCount;
TrianglesRendered += partCount;
renderContext.devContext.DrawIndexed(indexBuffer[0].Count, 0, 0);
return true;
}
public virtual bool Draw3D(RenderContext11 renderContext, float opacity, Tile parent)
{
RenderedGeneration = CurrentRenderGeneration;
TilesTouched++;
AccessCount = TileCache.AccessID++;
if (errored)
{
return false;
}
int xMax = 2;
InViewFrustum = true;
if (!ReadyToRender)
{
if (fastLoad)
{
TextureReady = true;
DemReady = true;
if (!CreateGeometry(renderContext, false))
{
TextureReady = false;
DemReady = false;
TileCache.AddTileToQueue(this);
return false;
}
}
else
{
TileCache.AddTileToQueue(this);
return false;
}
}
int childIndex = 0;
int yOffset = 0;
if (dataset.Mercator || dataset.BottomsUp )
{
yOffset = 1;
}
int xOffset = 0;
if (PurgeRefresh)
{
PurgeTextureAndDemFiles();
}
Matrix3d savedWorld = renderContext.World;
Matrix3d savedView = renderContext.View;
bool usingLocalCenter = false;
if (localCenter != Vector3d.Empty)
{
usingLocalCenter = true;
Vector3d temp = localCenter;
renderContext.World = Matrix3d.Translation(temp) * renderContext.WorldBase * Matrix3d.Translation(-renderContext.CameraPosition);
renderContext.View = Matrix3d.Translation(renderContext.CameraPosition) * renderContext.ViewBase;
}
try
{
bool anythingToRender = false;
bool childRendered = false;
for (int y1 = 0; y1 < 2; y1++)
{
for (int x1 = 0; x1 < xMax; x1++)
{
// if (level < (demEnabled ? 12 : dataset.Levels))
if (level < dataset.Levels)
{
Tile child = TileCache.GetTile(level + 1, x * 2 + ((x1 + xOffset) % 2), y * 2 + ((y1 + yOffset) % 2), dataset, this);
childrenId[childIndex] = child.Key;
if (child.IsTileInFrustum(renderContext.Frustum))
{
InViewFrustum = true;
if (child.IsTileBigEnough(renderContext))
{
renderPart[childIndex].TargetState = !child.Draw3D(renderContext, opacity, this);
if (renderPart[childIndex].TargetState)
{
childRendered = true;
}
}
else
{
renderPart[childIndex].TargetState = true;
}
}
else
{
renderPart[childIndex].TargetState = renderPart[childIndex].State = false;
}
if (renderPart[childIndex].TargetState == true || !blendMode)
{
renderPart[childIndex].State = renderPart[childIndex].TargetState;
}
}
else
{
renderPart[childIndex].State = true;
}
if (renderPart[childIndex].State == true)
{
anythingToRender = true;
}
childIndex++;
}
}
if (childRendered || anythingToRender)
{
RenderedAtOrBelowGeneration = CurrentRenderGeneration;
if (parent != null)
{
parent.RenderedAtOrBelowGeneration = RenderedAtOrBelowGeneration;
}
}
if (!anythingToRender)
{
return true;
}
if (!CreateGeometry(renderContext, true))
{
return false;
}
TilesInView++;
if ( wireFrame)
{
renderContext.MainTexture = null;
}
else
{
renderContext.MainTexture = texture;
}
renderContext.SetVertexBuffer(vertexBuffer);
accomidation = ComputeAccomidation();
for (int i = 0; i < 4; i++)
{
if (blendMode) //|| ShowElevation == false)
{
if ((renderPart[i].State && opacity == 1.0) || renderPart[i].TargetState)
{
renderContext.LocalCenter = localCenter;
renderContext.PreDraw();
if (dataset.DataSetType == ImageSetType.Sky)
{
HDRPixelShader.constants.opacity = renderPart[i].Opacity * opacity;
HDRPixelShader.Use(renderContext.devContext);
}
RenderPart(renderContext, i, renderPart[i].Opacity * opacity, false);
}
}
else
{
if (renderPart[i].TargetState)
{
renderContext.LocalCenter = localCenter;
renderContext.PreDraw();
if (dataset.DataSetType == ImageSetType.Sky)
{
HDRPixelShader.constants.opacity = opacity;
HDRPixelShader.Use(renderContext.devContext);
}
RenderPart(renderContext, i, opacity, false);
}
}
}
}
finally
{
if (usingLocalCenter)
{
renderContext.World = savedWorld;
renderContext.View = savedView;
}
}
return true;
}
public void Draw(RenderContext11 renderContext, int count, Texture11 texture, float opacity, IndexBuffer11 indexBufferIn)
{
setupShader(renderContext, texture, opacity);
count = Math.Min(this.count, count);
switch (renderStrategy)
{
case RenderStrategy.GeometryShader:
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
renderContext.SetVertexBuffer(0, vertexBuffer);
renderContext.SetIndexBuffer(indexBufferIn);
renderContext.devContext.DrawIndexed(count, 0, 0);
renderContext.Device.ImmediateContext.GeometryShader.Set(null);
break;
}
}
public void Draw(RenderContext11 renderContext, int count, Texture11 texture, float opacity)
{
setupShader(renderContext, texture, opacity);
count = Math.Min(this.count, count);
switch (renderStrategy)
{
case RenderStrategy.GeometryShader:
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
renderContext.SetVertexBuffer(0, vertexBuffer);
renderContext.devContext.Draw(count, 0);
renderContext.Device.ImmediateContext.GeometryShader.Set(null);
break;
case RenderStrategy.Instanced:
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
renderContext.SetVertexBuffer(0, spriteCornerVertexBuffer);
renderContext.SetVertexBuffer(1, vertexBuffer);
renderContext.SetIndexBuffer(indexBuffer);
renderContext.devContext.DrawIndexedInstanced(6, count, 0, 0, 0);
break;
case RenderStrategy.Fallback:
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
renderContext.SetVertexBuffer(0, fallbackVertexBuffer);
renderContext.SetIndexBuffer(indexBuffer);
renderContext.devContext.DrawIndexed(count * 6, 0, 0);
break;
}
}
// This version of DrawEllipse works without a 'head' point
public static void DrawEllipse(RenderContext11 renderContext, double semiMajorAxis, double eccentricity, double eccentricAnomaly, Color color, Matrix3d worldMatrix)
{
if (ellipseShader == null)
{
ellipseShader = new EllipseShader11();
}
if (ellipseWithoutStartPointVertexBuffer == null)
{
ellipseWithoutStartPointVertexBuffer = CreateEllipseVertexBufferWithoutStartPoint(360);
}
var savedWorld = renderContext.World;
renderContext.World = worldMatrix;
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineStrip;
renderContext.SetVertexBuffer(ellipseWithoutStartPointVertexBuffer);
ellipseShader.UseShader(renderContext, semiMajorAxis, eccentricity, eccentricAnomaly, new SharpDX.Color(color.R, color.G, color.B, color.A), savedWorld, new Vector3d(0.0, 0.0, 0.0));
renderContext.devContext.Draw(ellipseWithoutStartPointVertexBuffer.Count, 0);
renderContext.World = savedWorld;
}
public void render(RenderContext11 renderContext, Color color, Matrix3d worldMatrix, double jd, Vector3d positionNow, double duration)
{
duration = pathDuration;
if (vertexBuffer != null)
{
var dt = coverageDuration / ((int) pointCount - 1);
var t0 = points[0].jd;
var firstPoint = (int)Math.Floor((t0 - jd) / dt);
firstPoint = Math.Max(0, firstPoint);
var lastPoint = (int)Math.Floor((t0 - (jd - duration)) / dt);
lastPoint = Math.Min(points.Length - 1, lastPoint);
var drawCount = lastPoint - firstPoint;
var timeOffset = (t0 - jd) / coverageDuration;
var savedWorld = renderContext.World;
renderContext.World = worldMatrix;
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineStrip;
OrbitTraceShader.UseShader(renderContext, new SharpDX.Color(color.R, color.G, color.B, color.A), savedWorld, positionNow, timeOffset, 1.5);
renderContext.SetVertexBuffer(vertexBuffer);
renderContext.Device.ImmediateContext.Draw(drawCount, firstPoint);
renderContext.World = savedWorld;
}
}
public static void DrawFixedResolutionSphere(RenderContext11 renderContext, int sphereIndex)
{
if (sphereVertexBuffers != null && sphereVertexBuffers[sphereIndex] != null)
{
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 override bool Draw(RenderContext11 renderContext, float opacity, bool flat)
{
if (shapefile == null)
{
return false;
}
if (shapeFileVertex == null)
{
var vertList = new List<Vector3>();
var indexList = new List<UInt32>();
UInt32 firstItemIndex = 0;
var lastItem = new Vector3();
var firstItem = true;
var north = true;
double offsetX = 0;
double offsetY = 0;
double centralMeridian = 0;
double mapScale = 0;
double standardParallel = 70;
if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
north = shapefile.FileHeader.ProjectionInfo.Name.ToLower().Contains("north");
standardParallel = shapefile.FileHeader.ProjectionInfo.GetParameter("standard_parallel_1");
centralMeridian = shapefile.FileHeader.ProjectionInfo.GetParameter("central_meridian");
mapScale = shapefile.FileHeader.ProjectionInfo.GetParameter("scale_factor");
offsetY = shapefile.FileHeader.ProjectionInfo.GetParameter("false_easting");
offsetX = shapefile.FileHeader.ProjectionInfo.GetParameter("false_northing");
}
UInt32 currentIndex = 0;
var color = Color;
var count = 360;
for (var i = 0; i < shapefile.Shapes.Count; i++)
{
if (shapefile.Shapes[i].GetType() == typeof(Polygon))
{
var p = (Polygon)shapefile.Shapes[i];
for (var z = 0; z < p.Rings.Length; z++)
{
count = (p.Rings[z].Points.Length);
// content from DBF
var dr = p.Rings[z].Attributes;
for (var k = 0; k < p.Rings[z].Points.Length; k++)
{
// 2D Point coordinates. 3d also supported which would add a Z. There's also an optional measure (M) that can be used.
var Xcoord = p.Rings[z].Points[k].X;
var Ycoord = p.Rings[z].Points[k].Y;
if (shapefile.Projection == ShapeFile.Projections.Geo)
{
lastItem = Coordinates.GeoTo3d(Ycoord, Xcoord);
}
else if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
lastItem = Coordinates.SterographicTo3d(Xcoord, Ycoord, 1, standardParallel, centralMeridian, offsetX, offsetY, mapScale, north).Vector3;
}
if (k == 0)
{
firstItemIndex = currentIndex;
firstItem = true;
}
vertList.Add(lastItem);
if (firstItem)
{
firstItem = false;
}
else
{
indexList.Add(currentIndex);
currentIndex++;
indexList.Add(currentIndex);
}
}
indexList.Add(currentIndex);
indexList.Add(firstItemIndex);
currentIndex++;
}
}
else if (shapefile.Shapes[i].GetType() == typeof(PolygonZ))
{
var p = (PolygonZ)shapefile.Shapes[i];
for (var z = 0; z < p.Rings.Length; z++)
{
count = (p.Rings[z].Points.Length);
// content from DBF
var dr = p.Rings[z].Attributes;
for (var k = 0; k < p.Rings[z].Points.Length; k++)
{
// 2D Point coordinates. 3d also supported which would add a Z. There's also an optional measure (M) that can be used.
var Xcoord = p.Rings[z].Points[k].X;
var Ycoord = p.Rings[z].Points[k].Y;
if (shapefile.Projection == ShapeFile.Projections.Geo)
{
lastItem = Coordinates.GeoTo3d(Ycoord, Xcoord);
}
else if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
lastItem = Coordinates.SterographicTo3d(Xcoord, Ycoord, 1, standardParallel, centralMeridian, offsetX, offsetY, mapScale, north).Vector3;
}
if (k == 0)
{
firstItemIndex = currentIndex;
firstItem = true;
}
vertList.Add(lastItem);
if (firstItem)
{
firstItem = false;
}
else
{
indexList.Add(currentIndex);
currentIndex++;
indexList.Add(currentIndex);
}
}
indexList.Add(currentIndex);
indexList.Add(firstItemIndex);
currentIndex++;
}
}
else if (shapefile.Shapes[i].GetType() == typeof(PolyLine))
{
var p = (PolyLine)shapefile.Shapes[i];
for (var z = 0; z < p.Lines.Length; z++)
{
count = (p.Lines[z].Points.Length);
firstItem = true;
for (var k = 0; k < p.Lines[z].Points.Length; k++)
{
// 2D Point coordinates. 3d also supported which would add a Z. There's also an optional measure (M) that can be used.
var Xcoord = p.Lines[z].Points[k].X;
var Ycoord = p.Lines[z].Points[k].Y;
if (shapefile.Projection == ShapeFile.Projections.Geo)
{
lastItem = Coordinates.GeoTo3d(Ycoord, Xcoord);
}
else if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
lastItem = Coordinates.SterographicTo3d(Xcoord, Ycoord, 1, standardParallel, centralMeridian, offsetX, offsetY, mapScale, north).Vector3;
}
if (k == 0)
{
firstItemIndex = currentIndex;
firstItem = true;
}
vertList.Add(lastItem);
if (firstItem)
{
firstItem = false;
}
else
{
indexList.Add(currentIndex);
currentIndex++;
indexList.Add(currentIndex);
}
}
currentIndex++;
}
}
else if (shapefile.Shapes[i].GetType() == typeof(PolyLineZ))
{
var p = (PolyLineZ)shapefile.Shapes[i];
for (var z = 0; z < p.Lines.Length; z++)
{
count = (p.Lines[z].Points.Length);
var points = new Vector3[(count)];
firstItem = true;
for (var k = 0; k < p.Lines[z].Points.Length; k++)
{
// 2D Point coordinates. 3d also supported which would add a Z. There's also an optional measure (M) that can be used.
var Xcoord = p.Lines[z].Points[k].X;
var Ycoord = p.Lines[z].Points[k].Y;
if (shapefile.Projection == ShapeFile.Projections.Geo)
{
lastItem = Coordinates.GeoTo3d(Ycoord, Xcoord);
}
else if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
lastItem = Coordinates.SterographicTo3d(Xcoord, Ycoord, 1, standardParallel, centralMeridian, offsetX, offsetY, mapScale, north).Vector3;
}
if (k == 0)
{
firstItemIndex = currentIndex;
firstItem = true;
}
vertList.Add(lastItem);
if (firstItem)
{
firstItem = false;
}
else
{
indexList.Add(currentIndex);
currentIndex++;
indexList.Add(currentIndex);
}
}
currentIndex++;
}
}
else if (shapefile.Shapes[i].GetType() == typeof(Point))
{
var p = (Point)shapefile.Shapes[i];
// 2D Point coordinates. 3d also supported which would add a Z. There's also an optional measure (M) that can be used.
var Xcoord = p.X;
var Ycoord = p.Y;
if (shapefile.Projection == ShapeFile.Projections.Geo)
{
lastItem = Coordinates.GeoTo3d(Ycoord, Xcoord);
}
else if (shapefile.Projection == ShapeFile.Projections.PolarStereo)
{
lastItem = Coordinates.SterographicTo3d(Xcoord, Ycoord, 1, standardParallel, centralMeridian, offsetX, offsetY, mapScale, north).Vector3;
}
vertList.Add(lastItem);
currentIndex++;
lines = false;
}
}
shapeVertexCount = vertList.Count;
shapeFileVertex = new PositionVertexBuffer11(vertList.Count, RenderContext11.PrepDevice);
var verts = (Vector3[])shapeFileVertex.Lock(0, 0); // Lock the buffer (which will return our structs)
var indexer = 0;
foreach (var vert in vertList)
{
verts[indexer++] = vert;
}
shapeFileVertex.Unlock();
shapeIndexCount = indexList.Count;
if (lines)
{
if (indexList.Count > 65500)
{
isLongIndex = true;
shapeFileIndex = new IndexBuffer11(typeof(UInt32), indexList.Count, RenderContext11.PrepDevice);
}
else
{
isLongIndex = false;
shapeFileIndex = new IndexBuffer11(typeof(short), indexList.Count, RenderContext11.PrepDevice);
}
if (isLongIndex)
{
indexer = 0;
var indexes = (UInt32[])shapeFileIndex.Lock();
foreach (var indexVal in indexList)
{
indexes[indexer++] = indexVal;
}
shapeFileIndex.Unlock();
}
else
{
indexer = 0;
var indexes = (short[])shapeFileIndex.Lock();
foreach (var indexVal in indexList)
{
indexes[indexer++] = (short)indexVal;
}
shapeFileIndex.Unlock();
}
}
}
renderContext.DepthStencilMode = DepthStencilMode.Off;
renderContext.BlendMode = BlendMode.Alpha;
SimpleLineShader11.Color = Color.FromArgb((int)(opacity * 255), Color);
var 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 = false;
SimpleLineShader11.Sky = false;
renderContext.SetVertexBuffer(shapeFileVertex);
SimpleLineShader11.Use(renderContext.devContext);
if (lines)
{
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.LineList;
renderContext.SetIndexBuffer(shapeFileIndex);
renderContext.devContext.DrawIndexed(shapeFileIndex.Count, 0, 0);
}
else
{
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.PointList;
renderContext.devContext.Draw(shapeVertexCount, 0);
}
renderContext.devContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
return true;
}
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 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 void DrawLines(RenderContext11 renderContext, float opacity)
{
if (linePoints.Count < 2 || opacity <= 0)
{
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;
}
DateTime baseDate = new DateTime(2010, 1, 1, 12, 00, 00);
renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.LineList;
LineShaderNormalDates11.Constants.JNow = (float)(SpaceTimeController.JNow - SpaceTimeController.UtcToJulian(baseDate));
LineShaderNormalDates11.Constants.Sky = Sky ? 1 : 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);
renderContext.DepthStencilMode = DepthBuffered ? DepthStencilMode.ZReadWrite : DepthStencilMode.Off;
int index = 0;
foreach (TimeSeriesLineVertexBuffer11 lineBuffer in lineBuffers)
{
renderContext.SetVertexBuffer(lineBuffer);
renderContext.devContext.Draw(lineBuffer.Count, 0);
}
renderContext.DepthStencilMode = DepthStencilMode.ZReadWrite;
if (usingLocalCenter)
{
renderContext.World = savedWorld;
renderContext.View = savedView;
}
}
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, Color drawColor)
{
if (glyphCache == null || glyphCache.Version > glyphVersion)
{
PrepareBatch();
}
//todo11 Use Shader
renderContext.SetupBasicEffect(BasicEffect.TextureColorOpacity, Opacity, drawColor);
renderContext.MainTexture = glyphCache.Texture;
renderContext.devContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
renderContext.PreDraw();
if (layout == null)
{
layout = new SharpDX.Direct3D11.InputLayout(renderContext.Device, renderContext.Shader.InputSignature, new[]
{
new SharpDX.Direct3D11.InputElement("POSITION", 0, SharpDX.DXGI.Format.R32G32B32_Float, 0, 0),
new SharpDX.Direct3D11.InputElement("TEXCOORD", 0, SharpDX.DXGI.Format.R32G32_Float, 12, 0),
});
}
renderContext.Device.ImmediateContext.InputAssembler.InputLayout = layout;
renderContext.SetVertexBuffer(vertexBuffer);
renderContext.devContext.Draw(vertexBuffer.Count, 0);
}
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 override void RenderPart(RenderContext11 renderContext, int part, float opacity, bool combine)
{
if (dsm != null && dsm.DsmIndex != null)
{
renderContext.SetIndexBuffer(dsm.DsmIndex);
renderContext.SetVertexBuffer(dsm.VertexBuffer);
if (dsm.Subsets.Length > 4)
{
switch (part)
{
case 0:
part = 2;
break;
case 1:
part = 3;
// return;
break;
case 2:
part = 0;
break;
case 3:
part = 1;
break;
}
renderContext.devContext.DrawIndexed(dsm.Subsets[part + 1] - dsm.Subsets[part], dsm.Subsets[part], 0);
}
else
{
if (dsm.Subsets.Length > 0)
{
renderContext.devContext.DrawIndexed(dsm.Subsets[0] , 0, 0);
}
}
}
else
{
base.RenderPart(renderContext, part, opacity, combine);
}
}
// 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);
}
