public PointsGisLayerCPU(Game game, int maxPointsCount, bool isDynamic = true) : base(game)
{
PointsCountToDraw = maxPointsCount;
indeces = new int[maxPointsCount*6];
PointsDrawOffset = 0;
SizeMultiplier = 1;
var vbOptions = isDynamic ? VertexBufferOptions.Dynamic : VertexBufferOptions.Default;
currentBuffer = new VertexBuffer(Game.GraphicsDevice, typeof(Gis.CartPoint), maxPointsCount * 4, vbOptions);
PointsCpu = new Gis.CartPoint[maxPointsCount*4];
indBuf = new IndexBuffer(Game.GraphicsDevice, indeces.Length);
for (int i = 0; i < maxPointsCount; i += 1) {
indeces[i*6 + 0] = i*4 + 0;
indeces[i*6 + 1] = i*4 + 1;
indeces[i*6 + 2] = i*4 + 2;
indeces[i*6 + 3] = i*4 + 1;
indeces[i*6 + 4] = i*4 + 3;
indeces[i*6 + 5] = i*4 + 2;
}
indBuf.SetData(indeces);
shader = Game.Content.Load<Ubershader>("globe.Debug.hlsl");
factory = shader.CreateFactory(typeof(PointFlags), Primitive.TriangleList, VertexInputElement.FromStructure<Gis.CartPoint>(), BlendState.AlphaBlend, RasterizerState.CullCW, DepthStencilState.None);
}
/// <summary>
/// Creates pipeline state factory
/// </summary>
/// <param name="type"></param>
/// <param name="enumerator"></param>
/// <returns></returns>
public StateFactory CreateFactory(Type type, Action <PipelineState, int> enumerator)
{
lock (factories) {
var factory = new StateFactory(this, type, enumerator);
factories.Add(factory);
return(factory);
}
}
public DebugGisLayer(Game game) : base(game)
{
shader = game.Content.Load<Ubershader>("globe.Debug.hlsl");
factory = shader.CreateFactory(typeof(DebugFlags), Primitive.LineList, VertexInputElement.FromStructure<Gis.CartPoint>(), BlendState.AlphaBlend, RasterizerState.CullCW, DepthStencilState.Default);
buf = new VertexBuffer(Game.GraphicsDevice, typeof(Gis.CartPoint), 10000, VertexBufferOptions.Dynamic);
boxes = new List<Gis.CartPoint>();
lines = new List<Gis.CartPoint>();
}
public TilesGisLayer(Game engine, GlobeCamera camera) : base(engine)
{
RegisterMapSources();
CurrentMapSource = MapSources[9];
this.camera = camera;
frame = Game.Content.Load<Texture2D>("redframe.tga");
shader = Game.Content.Load<Ubershader>("globe.Tile.hlsl");
factory = shader.CreateFactory( typeof(TileFlags), Primitive.TriangleList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.AlphaBlend, RasterizerState.CullCW, DepthStencilState.Default);
}
/// <summary>
/// Initialization
/// </summary>
public override void Initialize ()
{
var dev = Game.GraphicsDevice;
effect = Game.Content.Load<Ubershader>("debugRender.hlsl");
factory = effect.CreateFactory( typeof(RenderFlags), Primitive.LineList, VertexInputElement.FromStructure( typeof(LineVertex) ), BlendState.AlphaBlend, RasterizerState.CullNone );
constData = new ConstData();
constBuffer = new ConstantBuffer(dev, typeof(ConstData));
// create vertex buffer :
vertexBuffer = new VertexBuffer(dev, typeof(LineVertex), vertexBufferSize, VertexBufferOptions.Dynamic );
vertexDataAccum.Capacity = vertexBufferSize;
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
shader = Game.Content.Load<Ubershader>("dof");
factory = shader.CreateFactory( typeof(Flags), (ps,i) => EnumAction(ps, (Flags)i ) );
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
surfaceShader = Game.Content.Load<Ubershader>("surface");
factory = surfaceShader.CreateFactory( typeof(SurfaceFlags), (ps,i) => Enum(ps, (SurfaceFlags)i ) );
}
void LoadContent ()
{
shader = device.Game.Content.Load<Ubershader>("sprite");
factory = shader.CreateFactory( typeof(Flags), (ps,i) => StateEnum( ps, (Flags)i) );
}
public LinesGisLayer(Game engine, int linesPointsCount, bool isDynamic = false) : base(engine)
{
shader = Game.Content.Load<Ubershader>("globe.Line.hlsl");
factory = shader.CreateFactory( typeof(LineFlags), Primitive.LineList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.AlphaBlend, RasterizerState.CullNone, DepthStencilState.None);
thinFactory = shader.CreateFactory( typeof(LineFlags), Primitive.LineList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.AlphaBlend, RasterizerState.CullNone, DepthStencilState.Readonly);
TransparencyMultiplayer = 1.0f;
OverallColor = Color4.White;
linesConstantBuffer = new ConstantBuffer(engine.GraphicsDevice, typeof(LinesConstDataStruct));
//linesConstantBuffer.SetData(linesConstData);
var vbOptions = isDynamic ? VertexBufferOptions.Dynamic : VertexBufferOptions.Default;
firstBuffer = new VertexBuffer(engine.GraphicsDevice, typeof(Gis.GeoPoint), linesPointsCount, vbOptions);
currentBuffer = firstBuffer;
PointsCpu = new Gis.GeoPoint[linesPointsCount];
Flags = (int)(LineFlags.ARC_LINE);
}
/// <summary>
/// Loads content
/// </summary>
void LoadContent ( object sender, EventArgs args )
{
shader = rs.Game.Content.Load<Ubershader>("particles.hlsl");
factory = shader.CreateFactory( typeof(Flags), (ps,i) => EnumAction( ps, (Flags)i ) );
}
protected void Initialize(Gis.GeoPoint[] points, int[] indeces, bool isDynamic)
{
shader = Game.Content.Load<Ubershader>("globe.Poly.hlsl");
factory = shader.CreateFactory(typeof(PolyFlags), EnumFunc);
factoryXray = shader.CreateFactory(typeof(PolyFlags), Primitive.TriangleList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.Additive, RasterizerState.CullCW, DepthStencilState.None);
var vbOptions = isDynamic ? VertexBufferOptions.Dynamic : VertexBufferOptions.Default;
firstBuffer = new VertexBuffer(Game.GraphicsDevice, typeof(Gis.GeoPoint), points.Length, vbOptions);
firstBuffer.SetData(points);
currentBuffer = firstBuffer;
indexBuffer = new IndexBuffer(Game.Instance.GraphicsDevice, indeces.Length);
indexBuffer.SetData(indeces);
PointsCpu = points;
cb = new ConstantBuffer(Game.GraphicsDevice, typeof(ConstData));
constData = new ConstData();
constData.Data = Vector4.One;
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
lightingShader = Game.Content.Load<Ubershader>("lighting");
factory = lightingShader.CreateFactory( typeof(LightingFlags), Primitive.TriangleList, VertexInputElement.Empty );
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void InstancingDemo_Reloading ( object sender, EventArgs e )
{
SafeDispose( ref factory );
us = Content.Load<Ubershader>("test");
factory = new StateFactory( us, typeof(UberFlags), Primitive.TriangleList, VertexInputElement.FromStructure( typeof(Vertex) ), BlendState.Additive, RasterizerState.CullNone, DepthStencilState.None );
tex = Content.Load<Texture2D>("block" );
}
public PointsGisLayer(Game engine, int maxPointsCount, bool isDynamic = false) : base(engine)
{
DotsBuffer = new ConstantBuffer(engine.GraphicsDevice, typeof(DotsData));
ColorBuffer = new ConstantBuffer(engine.GraphicsDevice, typeof(ColorData), 16);
PointsCountToDraw = maxPointsCount;
PointsDrawOffset = 0;
SizeMultiplier = 1;
IsDynamic = isDynamic;
var vbOptions = isDynamic ? VertexBufferOptions.Dynamic : VertexBufferOptions.Default;
firstBuffer = new VertexBuffer(engine.GraphicsDevice, typeof(Gis.GeoPoint), maxPointsCount, vbOptions);
currentBuffer = firstBuffer;
PointsCpu = new Gis.GeoPoint[maxPointsCount];
Flags = (int) (PointFlags.DOTS_WORLDSPACE);
shader = Game.Content.Load<Ubershader>("globe.Point.hlsl");
factory = shader.CreateFactory( typeof(PointFlags), Primitive.PointList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.AlphaBlend, RasterizerState.CullCCW, DepthStencilState.None);
ColorDatas = new ColorData[16];
for (int i = 0; i < ColorDatas.Length; i++) {
ColorDatas[i] = new ColorData {Color = Color.White};
}
ColorBuffer.SetData(ColorDatas);
}
void Game_Reloading ( object sender, EventArgs e )
{
SafeDispose( ref factory );
texture = Game.Content.Load<Texture2D>("particle2");
shader = Game.Content.Load<Ubershader>("test");
factory = new StateFactory( shader, typeof(Flags), (ps,i) => EnumAction( ps, (Flags)i ) );
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
shader = Game.Content.Load<Ubershader>("bitonicSort");
factory = shader.CreateFactory( typeof(ShaderFlags), Primitive.TriangleList, VertexInputElement.Empty );
}
public ModelLayer(Game engine, DVector2 lonLatPosition, string fileName, int maxInstancedCount = 0) : base(engine)
{
model = engine.Content.Load<Scene>(fileName);
transforms = new Matrix[model.Nodes.Count];
model.ComputeAbsoluteTransforms(transforms);
LonLatPosition = lonLatPosition;
Transparency = 1.0f;
constData = new ConstDataStruct();
modelBuf = new ConstantBuffer(Game.GraphicsDevice, typeof(ConstDataStruct));
shader = Game.Content.Load<Ubershader>("globe.Model.hlsl");
factory = shader.CreateFactory( typeof(ModelFlags), Primitive.TriangleList, VertexInputElement.FromStructure<VertexColorTextureTBNRigid>(), BlendState.AlphaBlend, RasterizerState.CullCW, DepthStencilState.Default);
factoryXray = shader.CreateFactory( typeof(ModelFlags), Primitive.TriangleList, VertexInputElement.FromStructure<VertexColorTextureTBNRigid>(), BlendState.AlphaBlend, RasterizerState.CullCW, DepthStencilState.Default);
if (maxInstancedCount > 0) {
InstancedCountToDraw = maxInstancedCount;
InstancedDataCPU = new InstancedDataStruct[maxInstancedCount];
instDataGpu = new StructuredBuffer(engine.GraphicsDevice, typeof(InstancedDataStruct), maxInstancedCount, StructuredBufferFlags.None);
}
selectInfo = new SelectInfo[model.Nodes.Count];
for (int i = 0; i < model.Nodes.Count; i++)
{
var meshindex = model.Nodes[i].MeshIndex;
if (meshindex < 0) continue;
selectInfo[i] = new SelectInfo
{
BoundingBox = model.Meshes[meshindex].ComputeBoundingBox(),
MeshIndex = meshindex,
NodeIndex = i,
NodeName = model.Nodes[i].Name
};
}
}
/// <summary>
/// Load content
/// </summary>
public void LoadContent ()
{
SafeDispose( ref factory );
SafeDispose( ref vertexBuffers );
SafeDispose( ref indexBuffers );
uberShader = Content.Load<Ubershader>("render");
factory = new StateFactory(
uberShader,
typeof(RenderFlags),
Primitive.TriangleList,
VertexColorTextureNormal.Elements,
BlendState.Opaque,
RasterizerState.CullCW,
DepthStencilState.Default
);
scene = Content.Load<Scene>(@"Scenes\testScene");
vertexBuffers = scene.Meshes
.Select( m => VertexBuffer.Create( GraphicsDevice, m.Vertices.Select( v => VertexColorTextureNormal.Convert(v) ).ToArray() ) )
.ToArray();
indexBuffers = scene.Meshes
.Select( m => IndexBuffer.Create( GraphicsDevice, m.GetIndices() ) )
.ToArray();
textures = scene.Materials
.Select( mtrl => Content.Load<Texture2D>( mtrl.TexturePath ) )
.ToArray();
worldMatricies = new Matrix[ scene.Nodes.Count ];
scene.CopyAbsoluteTransformsTo( worldMatricies );
//Log.Message("{0}", scene.Nodes.Count( n => n.MeshIndex >= 0 ) );
}
/// <summary>
/// Creates pipeline state factory
/// </summary>
/// <param name="type"></param>
/// <param name="enumerator"></param>
/// <returns></returns>
public StateFactory CreateFactory ( Type type, Action<PipelineState,int> enumerator )
{
lock (factories) {
var factory = new StateFactory( this, type, enumerator );
factories.Add(factory);
return factory;
}
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
shader = Game.Content.Load<Ubershader>("hdr");
factory = shader.CreateFactory( typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None );
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
sky = Game.Content.Load<Ubershader>("sky");
factory = sky.CreateFactory( typeof(SkyFlags), (ps,i) => EnumFunc(ps, (SkyFlags)i) );
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
shaders = Game.Content.Load<Ubershader>( "filter" );
factory = shaders.CreateFactory( typeof(ShaderFlags), (ps,i) => Enum(ps, (ShaderFlags)i) );
}
public HeatMapLayer(Game engine, Gis.GeoPoint[] points, int[] indeces, int mapDimX, int mapDimY, bool isDynamic = false) : base(engine)
{
Initialize(points, indeces, isDynamic);
factory = shader.CreateFactory( typeof(PolyFlags), Primitive.TriangleList, VertexInputElement.FromStructure<Gis.GeoPoint>(), BlendState.AlphaBlend, RasterizerState.CullNone, DepthStencilState.None);
MapDimX = mapDimX;
MapDimY = mapDimY;
HeatTexture = new Texture2D(Game.GraphicsDevice, MapDimX, MapDimY, ColorFormat.R32F, false);
Temp = new RenderTarget2D(Game.GraphicsDevice, ColorFormat.R32F, MapDimX, MapDimY, true);
FirstFinal = new RenderTarget2D(Game.GraphicsDevice, ColorFormat.R32F, MapDimX, MapDimY, true);
SecondFinal = new RenderTarget2D(Game.GraphicsDevice, ColorFormat.R32F, MapDimX, MapDimY, true);
Final = SecondFinal;
Prev = FirstFinal;
Data = new float[MapDimX * MapDimY];
//HeatMapPalettes = new Texture2D[1];
//HeatMapPalettes[0] = Game.Content.Load<Texture2D>("palette");
Palette = Game.Content.Load<Texture2D>("palette");
//cb = new ConstantBuffer(Game.GraphicsDevice, typeof(ConstData));
//constData = new ConstData();
Flags = (int)(PolyFlags.PIXEL_SHADER | PolyFlags.VERTEX_SHADER | PolyFlags.DRAW_HEAT);
blurFactory = shader.CreateFactory( typeof(PolyFlags), Primitive.TriangleList,
null,
BlendState.AlphaBlend,
RasterizerState.CullNone,
DepthStencilState.None);
MaxHeatMapLevel = 100;
MinHeatMapLevel = 0;
HeatMapTransparency = 1.0f;
}