/// <summary>
/// Initializes a new instance of the StateFactory
/// </summary>
/// <param name="device"></param>
/// <param name="enumType"></param>
/// <param name="ubershader"></param>
/// <param name="vertexInputElements"></param>
/// <param name="blendState"></param>
/// <param name="rasterizerState"></param>
public StateFactory( Ubershader ubershader, Type enumType, Primitive primitive, VertexInputElement[] vertexInputElements )
: base(ubershader.GraphicsDevice)
{
this.ubershader = ubershader;
Enumerate( enumType, ubershader, (ps,i) => { ps.VertexInputElements = vertexInputElements; ps.Primitive = primitive; } );
}
/// <summary>
/// Initializes a new instance of the StateFactory
/// </summary>
/// <param name="ubershader"></param>
/// <param name="enumType"></param>
/// <param name="enumAction"></param>
public StateFactory( Ubershader ubershader, Type enumType, Action<PipelineState,int> enumAction )
: base(ubershader.GraphicsDevice)
{
this.ubershader = ubershader;
Enumerate( enumType, ubershader, enumAction );
}
/// <summary>
///
/// </summary>
/// <param name="game"></param>
public GlobeLayer(Game game, LayerServiceConfig config) : base(game, config)
{
shader = Game.Content.Load <Ubershader>(@"Globe.hlsl");
constBuffer = new ConstBufferGeneric <ConstData>(Game.GraphicsDevice);
frame = Game.Content.Load <Texture2D>("redframe.tga");
railRoadsTex = Game.Content.Load <Texture2D>("Urban/Railroads.tga");
UpdateProjectionMatrix(Game.GraphicsDevice.DisplayBounds.Width, Game.GraphicsDevice.DisplayBounds.Height);
maxPitch = DMathUtil.DegreesToRadians(87.5);
minPitch = DMathUtil.DegreesToRadians(-87.5);
GoToPlace(Places.SaintPetersburg_VO);
InitDots();
InitAirLines();
Game.GetService <LayerService>().MapLayer.OnProjectionChanged += (s) => { updateTiles = true; };
CreateSphere(100, 50);
//AddDebugLine(new DVector3(10000, 0, 0), Color.Red, new DVector3(0, 0, 0), Color.Red);
//AddDebugLine(new DVector3(0, 10000, 0), Color.Green, new DVector3(0, 0, 0), Color.Green);
//AddDebugLine(new DVector3(0, 0, 10000), Color.Blue, new DVector3(0, 0, 0), Color.Blue);
myMiniFactory = new MyMiniFactory(Game, shader);
}
/// <summary>
/// Load content
/// </summary>
public void LoadContent()
{
uberShader = Content.Load <Ubershader>("render");
factory = new StateFactory(uberShader, typeof(RenderFlags), Primitive.TriangleList, VertexInputElement.FromStructure <CubeVertex>());
texture = Content.Load <Texture2D>(@"Scenes\lena");
vb = new VertexBuffer(GraphicsDevice, typeof(CubeVertex), 24);
ib = new IndexBuffer(GraphicsDevice, 36);
// create a new space with physics
space = new Space();
// update gravity force
space.ForceUpdater.Gravity = new Vector3BEPU(0, -9.81f, 0);
// add ground, ground has infinite mass
Box ground = new Box(new Vector3BEPU(0, 0, 0), 50, 1, 50);
space.Add(ground);
// create boxes with random position and add color as a tag, then add box to space
for (int i = 0; i < numberOfBoxes; i++)
{
Vector3Fusion vector = RandomExt.NextVector3(random, new Vector3Fusion(-10, 20, -10), new Vector3Fusion(10, 80, 10));
Box box = new Box(new Vector3BEPU(vector.X, vector.Y, vector.Z), 1, 1, 1, 1);
box.Tag = RandomExt.NextColor(random);
space.Add(box);
}
}
/// <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");
}
/// <summary>
///
/// </summary>
void LoadContent()
{
stereo = Game.Content.Load <Ubershader>("stereo");
SafeDispose(ref factory);
factory = stereo.CreateFactory(typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
}
public void LoadContent()
{
effect = Game.Content.Load <Ubershader>("debugRender.hlsl");
factory = effect.CreateFactory(typeof(RenderFlags), (ps, i) => Enum(ps, (RenderFlags)i));
//factory = effect.CreateFactory( typeof(RenderFlags), Primitive.LineList, VertexInputElement.FromStructure( typeof(LineVertex) ), BlendState.AlphaBlend, RasterizerState.CullNone, DepthStencilState.Default );
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose(ref factory);
skySphere = Game.Content.Load <Scene>("skySphere");
cloudSphere = Game.Content.Load <Scene>("cloudSphere");
clouds = Game.Content.Load <Texture2D>("clouds|srgb");
cirrus = Game.Content.Load <Texture2D>("cirrus|srgb");
noise = Game.Content.Load <Texture2D>("cloudNoise");
arrows = Game.Content.Load <Texture2D>("arrowsAll");
vertexBufferBlur = new VertexBuffer(Game.GraphicsDevice, typeof(VertexColorTextureTBN), 6);
vertexBuffers = skySphere.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
indexBuffers = skySphere.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
cloudVertexBuffers = cloudSphere.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
cloudIndexBuffers = cloudSphere.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
sky = Game.Content.Load <Ubershader>("sky");
factory = new StateFactory(sky, typeof(SkyFlags), (ps, i) => EnumFunc(ps, (SkyFlags)i));
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose(ref factory);
SafeDispose(ref vertexBuffers);
SafeDispose(ref indexBuffers);
surfaceShader = Game.Content.Load <Ubershader>("surface");
factory = new StateFactory(surfaceShader, typeof(SurfaceFlags), Primitive.TriangleList, VertexInputElement.FromStructure <VertexColorTextureTBN>());
scene = Game.Content.Load <Scene>(@"Scenes\testScene");
vertexBuffers = scene.Meshes
.Select(mesh => VertexBuffer.Create(Game.GraphicsDevice, mesh.Vertices.Select(v => VertexColorTextureTBN.Convert(v)).ToArray()))
.ToArray();
indexBuffers = scene.Meshes
.Select(mesh => IndexBuffer.Create(Game.GraphicsDevice, mesh.GetIndices()))
.ToArray();
surfaceProps = scene.Materials
.Select(mtrl => new SurfaceProperties()
{
Diffuse = LoadTexture2D(mtrl.TexturePath, "|srgb", defaultDiffuse),
Specular = LoadTexture2D(mtrl.TexturePath, "_spec", defaultSpecular),
NormalMap = LoadTexture2D(mtrl.TexturePath, "_local", defaultNormalMap),
Emission = LoadTexture2D(mtrl.TexturePath, "_glow|srgb", defaultEmission),
})
.ToArray();
}
/// <summary>
///
/// </summary>
void LoadContent()
{
shader = Game.Content.Load <Ubershader>("hdr");
//noiseTex = Game.Content.Load<DiscTexture>(@"noise\hdrDitherNoise");
//noiseTex = Game.Content.Load<DiscTexture>(@"noise\bayerMatrix8x8");
factory = shader.CreateFactory(typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
}
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()
{
SafeDispose(ref factory);
shader = Game.Content.Load <Ubershader>("hdr");
factory = new StateFactory(shader, typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
bloomMask = Game.Content.Load <Texture2D>("bloomMask");
}
void LoadContent()
{
SafeDispose(ref factory);
//texture = new Texture2D( GraphicsDevice, File.ReadAllBytes(@"D:\image.png"), false );
texture = Content.Load <Texture2D>("lena.tga");
ubershader = Content.Load <Ubershader>("test.hlsl");
factory = new StateFactory(ubershader, typeof(UberFlags), Primitive.TriangleList, VertexInputElement.FromStructure(typeof(Vertex)));
}
public MySceneDrawer(GraphicsDevice device, Scene scene) : base(device, scene)
{
constBuffer = new ConstantBuffer(GraphicsDevice, typeof(CBData));
constBufferBones = new ConstantBuffer(GraphicsDevice, typeof(Matrix), BoneCount);
uberShader = Game.Content.Load <Ubershader>("render");
factory = new StateFactory(uberShader, typeof(RenderFlags), Primitive.TriangleList, VertexInputElement.FromStructure <VertexColorSkin>());
boneTransforms = new Matrix[BoneCount];
}
/// <summary>
///
/// </summary>
public override void Initialize()
{
texture = Game.Content.Load <Texture2D>("smaller");
shader = Game.Content.Load <Ubershader>("shaders");
font = Game.Content.Load <SpriteFont>("segoe40");
calibri = Game.Content.Load <SpriteFont>("Calibri");
factory = new StateFactory(shader, typeof(Flags), (ps, i) => Enum(ps, (Flags)i));
int w = Game.GraphicsDevice.DisplayBounds.Width;
int h = Game.GraphicsDevice.DisplayBounds.Height;
var inpdevice = Game.InputDevice;
inpdevice.KeyDown += InputDevice_KeyDown;
var ui = Game.GetService <UserInterface>();
ui.RootFrame = new Frame(Game, 0, 0, w, h, "", Color.Transparent)
{
Border = 1
};
maxLinkCount = MaxSimulatedParticles * MaxSimulatedParticles;
paramsCB = new ConstantBuffer(Game.GraphicsDevice, typeof(Params));
var Dirs = Game.GetService <Directory>();
MaxParticleMass = cfg.Max_mass;
MinParticleMass = cfg.Min_mass;
spinRate = cfg.Rotation;
linkSize = 1.0f;
linkptr = true;
listForDfs = new bool[MaxInjectingParticles];
graphEdges = new List <List <int> >();
linkList = new List <Link>();
ParticleList = new List <Particle3d>();
linkPtrLists = new List <List <int> >();
graphTimer = 0;
graphPlay = false;
linkArr = new int[MaxInjectingParticles, MaxInjectingParticles];
linkCount = new int[MaxInjectingParticles];
state = State.RUN;
base.Initialize();
}
/// <summary>
/// Add services :
/// </summary>
protected override void Initialize()
{
// initialize services :
base.Initialize();
// create structured buffers and shaders :
argA = new StructuredBuffer(GraphicsDevice, typeof(float), BufferSize, StructuredBufferFlags.None);
argB = new StructuredBuffer(GraphicsDevice, typeof(float), BufferSize, StructuredBufferFlags.None);
result = new StructuredBuffer(GraphicsDevice, typeof(Result), BufferSize, StructuredBufferFlags.None);
paramsCB = new ConstantBuffer(GraphicsDevice, typeof(Params));
shader = Content.Load <Ubershader>("test");
factory = new StateFactory(shader, typeof(ShaderFlags), Primitive.TriangleList, VertexInputElement.Empty);
// write data :
var rand = new Random();
var a = Enumerable.Range(0, BufferSize).Select(i => rand.NextFloat(-1000, 1000)).ToArray();
var b = Enumerable.Range(0, BufferSize).Select(i => rand.NextFloat(-1000, 1000)).ToArray();
var r = Enumerable.Range(0, BufferSize).Select(i => new Result()).ToArray();
argA.SetData(a);
argB.SetData(b);
paramsCB.SetData(new Params()
{
Size = BufferSize
});
// bind objects :
GraphicsDevice.SetCSRWBuffer(0, argA);
GraphicsDevice.SetCSRWBuffer(1, argB);
GraphicsDevice.SetCSRWBuffer(2, result);
GraphicsDevice.ComputeShaderConstants[0] = paramsCB;
// set compute shader and dispatch threadblocks :
GraphicsDevice.PipelineState = factory[0];
GraphicsDevice.Dispatch(MathUtil.IntDivUp(BufferSize, 256));
// get data :
result.GetData(r);
Log.Message(" id : Sum Product gID gtID dtID gIdx");
for (int i = 0; i < BufferSize; i++)
{
Log.Message("[{0,4}] : {1}", i, r[i]);
}
// add keyboard handler :
InputDevice.KeyDown += InputDevice_KeyDown;
}
/// <summary>
/// Initializes a new instance of the StateFactory
/// </summary>
/// <param name="device"></param>
/// <param name="ubershader"></param>
public StateFactory( Ubershader ubershader, Type enumType, Primitive primitive, VertexInputElement[] vertexInputElements, BlendState blendState, RasterizerState rasterizerState )
: base(ubershader.GraphicsDevice)
{
this.ubershader = ubershader;
Enumerate( enumType, ubershader, (ps,i) => {
ps.Primitive = primitive;
ps.VertexInputElements = vertexInputElements;
ps.BlendState = blendState;
ps.RasterizerState = rasterizerState;
} );
}
public SimpleBuildings(Game game, List<SimpleBuilding> buildings, LayerServiceConfig config)
: base(game, config)
{
var rs = game.GraphicsDevice;
var ml = Game.GetService<LayerService>().MapLayer;
constBuffer = rs.CreateConstBuffer<ConstData>();
drawShader = rs.CreateUberShader("SimpleBuildings.hlsl", typeof(BuildingsFlags));
vertexBuffer = rs.CreateVertexBuffer(typeof(SimpleBuilding), buildings.Count);
vertexBuffer.SetData(buildings.ToArray(), 0, buildings.Count);
//MeshInstance mi = new MeshInstance(rs, GenerateMesh(buildings), Matrix.Scaling(ml.Zoom)*Matrix.Translation(ml.Offset.X, 0.0f, ml.Offset.Y), "Ololo");
//rs.Instances.Add(mi);
}
public SimpleBuildings(Game game, List <SimpleBuilding> buildings, LayerServiceConfig config) : base(game, config)
{
var rs = game.GraphicsDevice;
var ml = Game.GetService <LayerService>().MapLayer;
constBuffer = rs.CreateConstBuffer <ConstData>();
drawShader = rs.CreateUberShader("SimpleBuildings.hlsl", typeof(BuildingsFlags));
vertexBuffer = rs.CreateVertexBuffer(typeof(SimpleBuilding), buildings.Count);
vertexBuffer.SetData(buildings.ToArray(), 0, buildings.Count);
//MeshInstance mi = new MeshInstance(rs, GenerateMesh(buildings), Matrix.Scaling(ml.Zoom)*Matrix.Translation(ml.Offset.X, 0.0f, ml.Offset.Y), "Ololo");
//rs.Instances.Add(mi);
}
/// <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.PatchList3CP,
// VertexColorTextureTBN.Elements,
// BlendState.Opaque,
// RasterizerState.CullCW,
// DepthStencilState.Default
// );
factory = new StateFactory(uberShader, typeof(RenderFlags), (x, i) => EnumFunc(x, (RenderFlags)i));
scene = Content.Load <Scene>(@"scene");
vertexBuffers = scene.Meshes
.Select(m => VertexBuffer.Create(GraphicsDevice, m.Vertices.Select(VertexColorTextureTBN.Convert).ToArray()))
.ToArray();
indexBuffers = scene.Meshes
.Select(m => IndexBuffer.Create(GraphicsDevice, m.GetIndices()))
.ToArray();
textures = new Texture2D[5];
textures[0] = Content.Load <Texture2D>("checker");
textures[1] = Content.Load <Texture2D>(@"Textures\rockA");
textures[2] = Content.Load <Texture2D>(@"Textures\rockA_local");
textures[3] = Content.Load <Texture2D>(@"Textures\sandDune");
textures[4] = Content.Load <Texture2D>(@"Textures\sandDune_local");
worldMatricies = new Matrix[scene.Nodes.Count];
scene.CopyAbsoluteTransformsTo(worldMatricies);
Log.Message("{0}", scene.Nodes.Count(n => n.MeshIndex >= 0));
}
/// <summary>
///
/// </summary>
public override void Initialize()
{
particleTex = Game.Content.Load <Texture2D>("smaller");
highlightTex = Game.Content.Load <Texture2D>("selection");
sparkTex = Game.Content.Load <Texture2D>("spark");
renderShader = Game.Content.Load <Ubershader>("Render");
computeShader = Game.Content.Load <Ubershader>("Compute");
atlas = Game.Content.Load <TextureAtlas>("protein_textures");
// creating the layout system:
lay = new LayoutSystem(Game, computeShader);
lay.UseGPU = Config.UseGPU;
lay.RunPause = LayoutSystem.State.PAUSE;
factory = new StateFactory(renderShader, typeof(RenderFlags), (plState, comb) =>
{
plState.RasterizerState = RasterizerState.CullNone;
plState.BlendState = BlendMode;
plState.DepthStencilState = DepthStencilState.Readonly;
plState.Primitive = Primitive.PointList;
});
paramsCB = new ConstantBuffer(Game.GraphicsDevice, typeof(Params));
particleMass = 1.0f;
edgeSize = 1000.0f;
edgeList = new List <Link>();
nodeList = new List <Particle3d>();
edgeIndexLists = new List <List <int> >();
sparkList = new List <Spark>();
commandQueue = new Queue <int>();
referenceNodeIndex = 0;
Game.InputDevice.KeyDown += keyboardHandler;
base.Initialize();
}
/// <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>
/// Add services :
/// </summary>
protected override void Initialize ()
{
// initialize services :
base.Initialize();
// create structured buffers and shaders :
buffer1 = new StructuredBuffer( GraphicsDevice, typeof(Vector2), NumberOfElements , StructuredBufferFlags.None );
buffer2 = new StructuredBuffer( GraphicsDevice, typeof(Vector2), NumberOfElements , StructuredBufferFlags.None );
paramsCB = new ConstantBuffer( GraphicsDevice, typeof(Params) );
shader = Content.Load<Ubershader>("test");
factory = new StateFactory( shader, typeof(ShaderFlags), Primitive.TriangleList, VertexInputElement.Empty );
//
// Create and write data :
//
var rand = new Random();
var input = Enumerable.Range(0, NumberOfElements).Select( i => new Vector2( rand.NextFloat(0,100), i ) ).ToArray();
buffer1.SetData( input );
// add keyboard handler :
InputDevice.KeyDown += InputDevice_KeyDown;
}
// Constructor: ----------------------------------------------------------------------------------------
public LayoutSystem(Game game, Ubershader ubershader)
{
env = game;
shader = ubershader;
device = env.GraphicsDevice;
factory = new StateFactory(shader, typeof(ComputeFlags), (plState, comb) =>
{
plState.RasterizerState = RasterizerState.CullNone;
plState.BlendState = BlendState.NegMultiply;
plState.DepthStencilState = DepthStencilState.Readonly;
plState.Primitive = Primitive.PointList;
});
paramsCB = new ConstantBuffer(env.GraphicsDevice, typeof(ComputeParams));
categories = new List <Category>();
categoryIndices = new List <int>();
SpringTension = env.GetService <GraphSystem>().Config.SpringTension;
StepMode = env.GetService <GraphSystem>().Config.StepMode;
calcAuto = new CalculationSystemAuto(this);
calcFixed = new CalculationSystemFixed(this);
calcWolfram = new CalculationSystemWolfram(this);
}
/// <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" );
}
/// <summary>
///
/// </summary>
void LoadContent()
{
surfaceShader = Game.Content.Load <Ubershader>("surface");
factory = surfaceShader.CreateFactory(typeof(SurfaceFlags), (ps, i) => Enum(ps, (SurfaceFlags)i));
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose( ref factory );
lightingShader = Game.Content.Load<Ubershader>("lighting");
factory = new StateFactory( lightingShader, typeof(LightingFlags), Primitive.TriangleList, VertexInputElement.Empty );
}
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 ) );
}
void LoadContent()
{
SafeDispose( ref factory );
//texture = new Texture2D( GraphicsDevice, File.ReadAllBytes(@"D:\image.png"), false );
texture = Content.Load<Texture2D>("lena.tga" );
ubershader = Content.Load<Ubershader>("test.hlsl");
factory = new StateFactory( ubershader, typeof(UberFlags), Primitive.TriangleList, VertexInputElement.FromStructure(typeof(Vertex) ) );
}
/// <summary>
///
/// </summary>
public override void Initialize()
{
particleTex = Game.Content.Load<Texture2D>("smaller");
selectionTex = Game.Content.Load<Texture2D>("selection");
renderShader = Game.Content.Load<Ubershader>("Render");
computeShader = Game.Content.Load<Ubershader>("Compute");
// creating the layout system:
lay = new LayoutSystem(Game, computeShader);
lay.UseGPU = Config.UseGPU;
lay.RunPause = LayoutSystem.State.PAUSE;
factory = new StateFactory( renderShader, typeof(RenderFlags), ( plState, comb ) =>
{
plState.RasterizerState = RasterizerState.CullNone;
plState.BlendState = BlendState.Screen;// на черном фоне будет белым BlendState.Multiply (Neg)
plState.DepthStencilState = DepthStencilState.Readonly;
plState.Primitive = Primitive.PointList;
} );
paramsCB = new ConstantBuffer( Game.GraphicsDevice, typeof(Params) );
particleMass = 1.0f;
edgeSize = 1000.0f;
edgeList = new List<Link>();
nodeList = new List<Particle3d>();
edgeIndexLists = new List<List<int> >();
commandQueue = new Queue<int>();
numSelectedNodes = 0;
numSelectedEdges = 0;
referenceNodeIndex = 0;
Game.InputDevice.KeyDown += keyboardHandler;
base.Initialize();
}
/// <summary>
/// Load content
/// </summary>
public void LoadContent ()
{
uberShader = Content.Load<Ubershader>("render");
factory = new StateFactory(uberShader, typeof(RenderFlags), Primitive.TriangleList, VertexInputElement.FromStructure<CubeVertex>());
texture = Content.Load<Texture2D>(@"Scenes\lena");
vb = new VertexBuffer(GraphicsDevice, typeof(CubeVertex), 24);
ib = new IndexBuffer(GraphicsDevice, 36);
// create a new space with physics
space = new Space();
// update gravity force
space.ForceUpdater.Gravity = new Vector3BEPU(0, -9.81f, 0);
// add ground, ground has infinite mass
Box ground = new Box(new Vector3BEPU(0, 0, 0), 50, 1, 50);
space.Add(ground);
// create boxes with random position and add color as a tag, then add box to space
for ( int i = 0; i < numberOfBoxes; i++ ) {
Vector3Fusion vector = RandomExt.NextVector3(random, new Vector3Fusion(-10, 20, -10), new Vector3Fusion(10, 80, 10));
Box box = new Box(new Vector3BEPU(vector.X, vector.Y, vector.Z), 1, 1, 1, 1);
box.Tag = RandomExt.NextColor(random);
space.Add(box);
}
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
SafeDispose( ref factory );
shader = Game.Content.Load<Ubershader>("ssao");
factory = new StateFactory( shader, typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None );
}
/// <summary>
///
/// </summary>
void LoadContent()
{
lightingShader = Game.Content.Load <Ubershader>("lighting");
factory = lightingShader.CreateFactory(typeof(LightingFlags), Primitive.TriangleList, VertexInputElement.Empty);
}
/// <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.PatchList3CP,
// VertexColorTextureTBN.Elements,
// BlendState.Opaque,
// RasterizerState.CullCW,
// DepthStencilState.Default
// );
factory = new StateFactory(uberShader, typeof(RenderFlags), (x, i) => EnumFunc(x, (RenderFlags)i));
scene = Content.Load<Scene>(@"scene");
vertexBuffers = scene.Meshes
.Select(m => VertexBuffer.Create(GraphicsDevice, m.Vertices.Select(VertexColorTextureTBN.Convert).ToArray()))
.ToArray();
indexBuffers = scene.Meshes
.Select( m => IndexBuffer.Create( GraphicsDevice, m.GetIndices() ) )
.ToArray();
textures = new Texture2D[5];
textures[0] = Content.Load<Texture2D>("checker");
textures[1] = Content.Load<Texture2D>(@"Textures\rockA");
textures[2] = Content.Load<Texture2D>(@"Textures\rockA_local");
textures[3] = Content.Load<Texture2D>(@"Textures\sandDune");
textures[4] = Content.Load<Texture2D>(@"Textures\sandDune_local");
worldMatricies = new Matrix[ scene.Nodes.Count ];
scene.CopyAbsoluteTransformsTo( worldMatricies );
Log.Message("{0}", scene.Nodes.Count( n => n.MeshIndex >= 0 ) );
}
/// <summary>
///
/// </summary>
void LoadContent()
{
shader = Game.Content.Load <Ubershader>("vtcache");
factory = shader.CreateFactory(typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty);
}
void LoadContent()
{
shader = Game.Content.Load <Ubershader>("sprite");
factory = shader.CreateFactory(typeof(Flags), (ps, i) => StateEnum(ps, (Flags)i));
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
stereo = Game.Content.Load<Ubershader>("stereo");
factory = stereo.CreateFactory( typeof(Flags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None );
}
public void Init(Game game, int Capacity, Vector2 leftBottom, Vector2 rightTop, int Width, int Height)
{
this.game = game;
this.Capacity = Capacity;
this.Width = Width;
this.Height = Height;
var rs = game.GraphicsDevice;
//////////////////////////// Init buffers ///////////////////////////////////////////
var dataBufDesc = new BufferDescription {
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.BufferStructured,
Usage = ResourceUsage.Default,
SizeInBytes = Capacity * Marshal.SizeOf(typeof(Element)),
StructureByteStride = Marshal.SizeOf(typeof(Element))
};
dataBuffer = new Buffer(rs.Device, dataBufDesc);
var stagingBufDesc = new BufferDescription {
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Write,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Staging,
SizeInBytes = dataBufDesc.SizeInBytes,
StructureByteStride = dataBufDesc.StructureByteStride
};
stagingBuffer = new Buffer(rs.Device, stagingBufDesc);
stagingBufDesc.CpuAccessFlags = CpuAccessFlags.Read;
readBuffer = new Buffer(rs.Device, stagingBufDesc);
///////////////////// ////////////////////////////////////
var rwBufDesc = new BufferDescription {
BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.BufferAllowRawViews,
Usage = ResourceUsage.Default,
SizeInBytes = Width * Height * Marshal.SizeOf(typeof(uint)),
StructureByteStride = Marshal.SizeOf(typeof(uint))
};
rwBuffer = new Buffer(rs.Device, rwBufDesc);
var textDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource | BindFlags.UnorderedAccess,
CpuAccessFlags = CpuAccessFlags.None,
Format = Format.R32G32B32A32_Float,
Width = Width,
Height = Height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
SampleDescription = new SampleDescription {
Count = 1
}
};
finalTexture = new Texture2D(rs.Device, textDesc);
tempTexture = new Texture2D(rs.Device, textDesc);
///////////////////////////// Init UAV and SRV //////////////////////////////////////////
ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription {
Format = Format.Unknown,
Buffer = { ElementCount = Capacity, FirstElement = 0 },
Dimension = ShaderResourceViewDimension.Buffer
};
dataSRV = new ShaderResourceView(rs.Device, dataBuffer, srvDesc);
var rwUAVDesc = new UnorderedAccessViewDescription {
Format = Format.R32_Typeless,
Dimension = UnorderedAccessViewDimension.Buffer,
Buffer = new UnorderedAccessViewDescription.BufferResource {
ElementCount = Width * Height, FirstElement = 0, Flags = UnorderedAccessViewBufferFlags.Raw
}
};
rwUAV = new UnorderedAccessView(rs.Device, rwBuffer, rwUAVDesc);
var uavDesc = new UnorderedAccessViewDescription
{
Format = Format.R32G32B32A32_Float,
Dimension = UnorderedAccessViewDimension.Texture2D,
Texture2D = new UnorderedAccessViewDescription.Texture2DResource {
MipSlice = 0
}
};
finalTextureUAV = new UnorderedAccessView(rs.Device, finalTexture, uavDesc);
tempUAV = new UnorderedAccessView(rs.Device, tempTexture, uavDesc);
var rwSRVDesc = new ShaderResourceViewDescription {
Format = Format.R32_UInt,
Dimension = ShaderResourceViewDimension.Buffer,
Buffer = new ShaderResourceViewDescription.BufferResource {
ElementCount = Width * Height, FirstElement = 0
}
};
rwSRV = new ShaderResourceView(rs.Device, rwBuffer, rwSRVDesc);
var srvTexDesc = new ShaderResourceViewDescription
{
Format = Format.R32G32B32A32_Float,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource {
MipLevels = 1, MostDetailedMip = 0
}
};
FinalSRV = new ShaderResourceView(rs.Device, finalTexture, srvTexDesc);
tempSRV = new ShaderResourceView(rs.Device, tempTexture, srvTexDesc);
computeShader = rs.CreateUberShader("effects/HeatMap.hlsl", typeof(HeatMapFlags));
cBuffer = rs.CreateConstBuffer <HeatMapCData>();
rightTopMerc = GeoHelper.WorldToTilePos(rightTop);
leftBottomMerc = GeoHelper.WorldToTilePos(leftBottom);
CellStep = rightTopMerc - leftBottomMerc;
CellStep.X = CellStep.X / Width;
CellStep.Y = CellStep.X; //CellStep.Y / Height;
pallete = game.Content.Load <Texture2D>("textures/pallete.tga");
}
/// <summary>
///
/// </summary>
/// <param name="?"></param>
void Enumerate( Type enumType, Ubershader ubershader, Action<PipelineState,int> enumAction )
{
pipelineStates = new Dictionary<int,PipelineState>();
combinerEnum = enumType;
//
// validate enum :
//
if (Enum.GetUnderlyingType(enumType)!=typeof(int)) {
throw new ArgumentException("Underlying type should be Int32");
}
Dictionary<string,int> enumDict = new Dictionary<string,int>();
foreach ( var enumValue in Enum.GetValues( enumType ) ) {
if ( !MathUtil.IsPowerOfTwo( (int)enumValue ) && (int)enumValue!=0 ) {
throw new ArgumentException("Each value must be zero or power of two");
}
enumDict.Add( enumValue.ToString(), (int)enumValue );
}
//
// Enumerate :
//
var defineList = ubershader.Defines;
foreach ( var defines in defineList ) {
int combination = 0;
if ( GetCombinerSet( enumDict, defines, out combination ) ) {
var ps = new PipelineState( device );
ps.PixelShader = ubershader.GetPixelShader ( defines );
ps.VertexShader = ubershader.GetVertexShader ( defines );
ps.GeometryShader = ubershader.GetGeometryShader ( defines );
ps.HullShader = ubershader.GetHullShader ( defines );
ps.DomainShader = ubershader.GetDomainShader ( defines );
ps.ComputeShader = ubershader.GetComputeShader ( defines );
enumAction( ps, combination );
pipelineStates.Add( combination, ps );
}
}
}
/// <summary>
///
/// </summary>
void LoadContent ()
{
SafeDispose( ref factory );
skySphere = Game.Content.Load<Scene>("skySphere");
cloudSphere = Game.Content.Load<Scene>("cloudSphere");
clouds = Game.Content.Load<Texture2D>("clouds|srgb");
cirrus = Game.Content.Load<Texture2D>("cirrus|srgb");
noise = Game.Content.Load<Texture2D>("cloudNoise");
arrows = Game.Content.Load<Texture2D>("arrowsAll");
vertexBuffers = skySphere.Meshes
.Select( mesh => VertexBuffer.Create( Game.GraphicsDevice, mesh.Vertices.Select( v => VertexColorTextureTBN.Convert( v ) ).ToArray() ) )
.ToArray();
indexBuffers = skySphere.Meshes
.Select( mesh => IndexBuffer.Create( Game.GraphicsDevice, mesh.GetIndices() ) )
.ToArray();
cloudVertexBuffers = cloudSphere.Meshes
.Select( mesh => VertexBuffer.Create( Game.GraphicsDevice, mesh.Vertices.Select( v => VertexColorTextureTBN.Convert( v ) ).ToArray() ) )
.ToArray();
cloudIndexBuffers = cloudSphere.Meshes
.Select( mesh => IndexBuffer.Create( Game.GraphicsDevice, mesh.GetIndices() ) )
.ToArray();
sky = Game.Content.Load<Ubershader>("sky");
factory = new StateFactory( sky, typeof(SkyFlags), (ps,i) => EnumFunc(ps, (SkyFlags)i) );
}
/// <summary>
/// Add services :
/// </summary>
protected override void Initialize ()
{
// initialize services :
base.Initialize();
// create structured buffers and shaders :
argA = new StructuredBuffer( GraphicsDevice, typeof(float), BufferSize , StructuredBufferFlags.None );
argB = new StructuredBuffer( GraphicsDevice, typeof(float), BufferSize , StructuredBufferFlags.None );
result = new StructuredBuffer( GraphicsDevice, typeof(Result), BufferSize , StructuredBufferFlags.None );
paramsCB = new ConstantBuffer( GraphicsDevice, typeof(Params) );
shader = Content.Load<Ubershader>("test");
factory = new StateFactory( shader, typeof(ShaderFlags), Primitive.TriangleList, VertexInputElement.Empty );
// write data :
var rand = new Random();
var a = Enumerable.Range(0, BufferSize).Select( i => rand.NextFloat(-1000,1000) ).ToArray();
var b = Enumerable.Range(0, BufferSize).Select( i => rand.NextFloat(-1000,1000) ).ToArray();
var r = Enumerable.Range(0, BufferSize).Select( i => new Result() ).ToArray();
argA.SetData( a );
argB.SetData( b );
paramsCB.SetData( new Params(){ Size = BufferSize } );
// bind objects :
GraphicsDevice.SetCSRWBuffer( 0, argA );
GraphicsDevice.SetCSRWBuffer( 1, argB );
GraphicsDevice.SetCSRWBuffer( 2, result );
GraphicsDevice.ComputeShaderConstants[0] = paramsCB ;
// set compute shader and dispatch threadblocks :
GraphicsDevice.PipelineState = factory[0];
GraphicsDevice.Dispatch( MathUtil.IntDivUp(BufferSize,256) );
// get data :
result.GetData( r );
Log.Message(" id : Sum Product gID gtID dtID gIdx");
for (int i=0; i<BufferSize; i++) {
Log.Message("[{0,4}] : {1}", i, r[i] );
}
// add keyboard handler :
InputDevice.KeyDown += InputDevice_KeyDown;
}
// Constructor: ----------------------------------------------------------------------------------------
public LayoutSystem(Game game, Ubershader ubershader)
{
env = game;
shader = ubershader;
device = env.GraphicsDevice;
factory = new StateFactory(shader, typeof(ComputeFlags), (plState, comb) =>
{
plState.RasterizerState = RasterizerState.CullNone;
plState.BlendState = BlendState.AlphaBlend; //BlendState.NegMultiply;
plState.DepthStencilState = DepthStencilState.Readonly;
plState.Primitive = Primitive.PointList;
});
paramsCB = new ConstantBuffer(env.GraphicsDevice, typeof(ComputeParams));
categories = new List<Category>();
categoryIndices = new List<int>();
SpringTension = env.GetService<GraphSystem>().Config.SpringTension;
StepMode = env.GetService<GraphSystem>().Config.StepMode;
calcAuto = new CalculationSystemAuto(this);
calcFixed = new CalculationSystemFixed(this);
calcWolfram = new CalculationSystemWolfram(this);
}
public MyMiniFactory(Game Game, Ubershader Shader)
{
game = Game;
shader = Shader;
}
/// <summary>
///
/// </summary>
void LoadContent()
{
shaders = Game.Content.Load <Ubershader>("filter");
factory = shaders.CreateFactory(typeof(ShaderFlags), (ps, i) => Enum(ps, (ShaderFlags)i));
}
void LoadContent()
{
fontTexture = device.Game.Content.Load<Texture2D>( @"debugFont.tga" );
shader = Game.Content.Load<Ubershader>(@"spriteBatch.hlsl");
DisposePSO();
foreach (SpriteBlend blend in Enum.GetValues(typeof(SpriteBlend))) {
var ps = new PipelineState( Game.GraphicsDevice );
ps.RasterizerState = RasterizerState.CullNone;
ps.DepthStencilState = DepthStencilState.None;
if (blend==SpriteBlend.Opaque ) ps.BlendState = BlendState.Opaque;
if (blend==SpriteBlend.AlphaBlend ) ps.BlendState = BlendState.AlphaBlend;
if (blend==SpriteBlend.AlphaBlendPreMul ) ps.BlendState = BlendState.AlphaBlendPreMul;
if (blend==SpriteBlend.Additive ) ps.BlendState = BlendState.Additive;
if (blend==SpriteBlend.Screen ) ps.BlendState = BlendState.Screen;
if (blend==SpriteBlend.Multiply ) ps.BlendState = BlendState.Multiply;
if (blend==SpriteBlend.NegMultiply ) ps.BlendState = BlendState.NegMultiply;
if (blend==SpriteBlend.ClearAlpha ) ps.BlendState = BlendState.ClearAlpha;
ps.VertexInputElements = VertexInputElement.FromStructure( typeof(SpriteVertex) );
ps.PixelShader = shader.GetPixelShader("");
ps.VertexShader = shader.GetVertexShader("");
ps.Primitive = Primitive.TriangleList;
pipelineStates.Add( blend, ps );
}
}
/// <summary>
///
/// </summary>
void LoadContent()
{
SafeDispose(ref factory);
shaders = Game.Content.Load <Ubershader>("filter");
factory = new StateFactory(shaders, typeof(ShaderFlags), Primitive.TriangleList, VertexInputElement.Empty, BlendState.Opaque, RasterizerState.CullNone, DepthStencilState.None);
}
public MySceneDrawer(GraphicsDevice device, Scene scene) : base(device, scene)
{
constBuffer = new ConstantBuffer(GraphicsDevice, typeof(CBData));
uberShader = Game.Content.Load <Ubershader>("render");
factory = new StateFactory(uberShader, typeof(RenderFlags), Primitive.TriangleList, VertexColorTextureNormal.Elements);
}
/// <summary>
/// Initialization
/// </summary>
public override void Initialize()
{
base.Initialize();
var dev = Game.GraphicsDevice;
effect = Game.Content.Load<Ubershader>("debugRender.hlsl");
factory = new StateFactory( effect, 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>
/// Loads content
/// </summary>
void LoadContent(object sender, EventArgs args)
{
shader = Game.Content.Load <Ubershader>("particles");
factory = shader.CreateFactory(typeof(Flags), (ps, i) => EnumAction(ps, (Flags)i));
}
/// <summary>
///
/// </summary>
void LoadContent()
{
sky = Game.Content.Load <Ubershader>("sky");
factory = sky.CreateFactory(typeof(SkyFlags), (ps, i) => EnumFunc(ps, (SkyFlags)i));
}
/// <summary>
///
/// </summary>
public override void Initialize()
{
particleTex = Game.Content.Load<Texture2D>("smaller");
highlightTex = Game.Content.Load<Texture2D>("selection");
sparkTex = Game.Content.Load<Texture2D>("spark");
renderShader = Game.Content.Load<Ubershader>("Render");
computeShader = Game.Content.Load<Ubershader>("Compute");
atlas = Game.Content.Load<TextureAtlas>("protein_textures");
// creating the layout system:
lay = new LayoutSystem(Game, computeShader);
lay.UseGPU = Config.UseGPU;
lay.RunPause = LayoutSystem.State.PAUSE;
factory = new StateFactory( renderShader, typeof(RenderFlags), ( plState, comb ) => Enum( plState, (RenderFlags) comb) );
paramsCB = new ConstantBuffer( Game.GraphicsDevice, typeof(Params) );
particleMass = 1.0f;
edgeSize = 1000.0f;
edgeList = new List<Link>();
nodeList = new List<Particle3d>();
edgeIndexLists = new List<List<int>>();
sparkList = new List<Spark>();
commandQueue = new Queue<int>();
referenceNodeIndex = 0;
Game.InputDevice.KeyDown += keyboardHandler;
base.Initialize();
}
