internal unsafe MyFoliageGeneratingPass()
{
var soElements = new StreamOutputElement[2];
soElements[0].Stream = 0;
soElements[0].SemanticName = "TEXCOORD";
soElements[0].SemanticIndex = 0;
soElements[0].ComponentCount = 3;
soElements[0].OutputSlot = 0;
soElements[1].Stream = 0;
soElements[1].SemanticName = "TEXCOORD";
soElements[1].SemanticIndex = 1;
soElements[1].ComponentCount = 1;
soElements[1].OutputSlot = 0;
var soStrides = new int[] { sizeof(Vector3) + sizeof(uint) };
if (m_geometryShader == GeometryShaderId.NULL)
{
m_geometryShader = MyShaders.CreateGs("passes/foliage_streaming/geometry_stage.hlsl", null, new MyShaderStreamOutputInfo {
Elements = soElements, Strides = soStrides, RasterizerStreams = GeometryShader.StreamOutputNoRasterizedStream
});
}
SetImmediate(true);
}
internal unsafe MyFoliageGeneratingPass()
{
var soElements = new StreamOutputElement[2];
soElements[0].Stream = 0;
soElements[0].SemanticName = "TEXCOORD";
soElements[0].SemanticIndex = 0;
soElements[0].ComponentCount = 3;
soElements[0].OutputSlot = 0;
soElements[1].Stream = 0;
soElements[1].SemanticName = "TEXCOORD";
soElements[1].SemanticIndex = 1;
soElements[1].ComponentCount = 1;
soElements[1].OutputSlot = 0;
var soStrides = new int[] { sizeof(Vector3) + sizeof(uint) };
if (m_geometryShader == GeometryShaderId.NULL)
{
string stageFile = Path.Combine(MyMaterialShaders.PassesFolder, MyMaterialShaders.FOLIAGE_STREAMING_PASS, "GeometryStage.hlsl");
m_geometryShader = MyShaders.CreateGs(stageFile, null, new MyShaderStreamOutputInfo {
Elements = soElements, Strides = soStrides, RasterizerStreams = GeometryShader.StreamOutputNoRasterizedStream
});
}
SetImmediate(true);
}
/// <summary>
/// Serializes a static <see cref="StreamOutputElement"/>.
/// </summary>
/// <param name="value">The <see cref="StreamOutputElement"/> to serialize</param>
/// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param>
/// <remarks>
/// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value.
/// </remarks>
public void Serialize(ref StreamOutputElement value, SerializeFlags serializeFlags = SerializeFlags.Normal)
{
int storeObjectRef;
if (SerializeIsNull(ref value, out storeObjectRef, serializeFlags))
{
return;
}
if (Mode == SerializerMode.Read)
{
value = new StreamOutputElement();
}
// Store ObjectRef
if (storeObjectRef >= 0)
{
StoreObjectRef(value, storeObjectRef);
}
Serialize(ref value.Stream);
Serialize(ref value.SemanticName);
Serialize(ref value.SemanticIndex);
Serialize(ref value.StartComponent);
Serialize(ref value.ComponentCount);
Serialize(ref value.OutputSlot);
}
public override void Preload(Renderer renderer)
{
if (_geometryShader.Get(renderer) == null)
{
SharpDX.Direct3D11.GeometryShader shader;
if (_streamOutType == null)
{
shader = new SharpDX.Direct3D11.GeometryShader(renderer.Device, _shaderByteCode);
}
else
{
FieldInfo[] infos = _streamOutType.GetFields(BindingFlags.Public | BindingFlags.Instance);
StreamOutputElement[] elements = new StreamOutputElement[infos.Length];
int[] strides = new int[1] {
0
};
for (int i = 0; i < infos.Length; i++)
{
FieldInfo info = infos[i];
elements[i] = new StreamOutputElement();
elements[i].SemanticName = info.Name;
if (info.FieldType == typeof(float))
{
elements[i].ComponentCount = 1;
}
else if (info.FieldType == typeof(Vector2))
{
elements[i].ComponentCount = 2;
}
else if (info.FieldType == typeof(Vector3))
{
elements[i].ComponentCount = 3;
}
else if (info.FieldType == typeof(Vector4))
{
elements[i].ComponentCount = 4;
}
else
{
throw new Exception("Unknown element type: " + info.FieldType.ToString());
}
strides[0] += sizeof(float) * elements[i].ComponentCount; // TODO ...
}
shader = new SharpDX.Direct3D11.GeometryShader(renderer.Device, _shaderByteCode, elements, strides, 0);
}
_geometryShader.Set(renderer, shader, _shaderByteCode.Data.LongLength);
}
}
/// <summary>
/// Serializes an array of static <see cref="StreamOutputElement"/>s.
/// </summary>
/// <param name="valueArray">An array of <see cref="StreamOutputElement"/>s to serialize</param>
/// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param>
/// <remarks>
/// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value.
/// </remarks>
public void Serialize(ref StreamOutputElement[] valueArray, SerializeFlags serializeFlags = SerializeFlags.Normal)
{
int storeObjectRef;
if (SerializeIsNull(ref valueArray, out storeObjectRef, serializeFlags))
{
return;
}
if (Mode == SerializerMode.Write)
{
// Store ObjectRef
if (storeObjectRef >= 0)
{
StoreObjectRef(valueArray, storeObjectRef);
}
WriteArrayLength(valueArray.Length);
for (int i = 0; i < valueArray.Length; i++)
{
Serialize(ref valueArray[i], serializeFlags);
}
}
else
{
var count = ReadArrayLength();
valueArray = new StreamOutputElement[count];
// Store ObjectRef
if (storeObjectRef >= 0)
{
StoreObjectRef(valueArray, storeObjectRef);
}
for (int index = 0; index < count; index++)
{
Serialize(ref valueArray[index], serializeFlags);
}
}
}
internal static unsafe void Init()
{
var soElements = new StreamOutputElement[2];
soElements[0].Stream = 0;
soElements[0].SemanticName = "TEXCOORD";
soElements[0].SemanticIndex = 0;
soElements[0].ComponentCount = 3;
soElements[0].OutputSlot = 0;
soElements[1].Stream = 0;
soElements[1].SemanticName = "TEXCOORD";
soElements[1].SemanticIndex = 1;
soElements[1].ComponentCount = 1;
soElements[1].OutputSlot = 0;
var soStrides = new int[] { sizeof(Vector3) + sizeof(uint) };
m_gs = MyShaders.CreateGs("passes/foliage_streaming/geometry_stage.hlsl", "gs", "", new MyShaderStreamOutputInfo {
Elements = soElements, Strides = soStrides, RasterizerStreams = GeometryShader.StreamOutputNoRasterizedStream
});
m_instance.SetImmediate(true);
}
private void CreateShaders()
{
foreach (var shaderBytecode in effectBytecode.Stages)
{
var bytecodeRaw = shaderBytecode.Data;
var reflection = effectBytecode.Reflection;
// TODO CACHE Shaders with a bytecode hash
switch (shaderBytecode.Stage)
{
case ShaderStage.Vertex:
vertexShader = new VertexShader(GraphicsDevice.NativeDevice, bytecodeRaw);
// Note: input signature can be reused when reseting device since it only stores non-GPU data,
// so just keep it if it has already been created before.
if (inputSignature == null)
{
inputSignature = EffectInputSignature.GetOrCreateLayout(new EffectInputSignature(shaderBytecode.Id, bytecodeRaw));
}
break;
case ShaderStage.Domain:
domainShader = new DomainShader(GraphicsDevice.NativeDevice, bytecodeRaw);
break;
case ShaderStage.Hull:
hullShader = new HullShader(GraphicsDevice.NativeDevice, bytecodeRaw);
break;
case ShaderStage.Geometry:
if (reflection.ShaderStreamOutputDeclarations != null && reflection.ShaderStreamOutputDeclarations.Count > 0)
{
// Calculate the strides
var soStrides = new List <int>();
foreach (var streamOutputElement in reflection.ShaderStreamOutputDeclarations)
{
for (int i = soStrides.Count; i < (streamOutputElement.Stream + 1); i++)
{
soStrides.Add(0);
}
soStrides[streamOutputElement.Stream] += streamOutputElement.ComponentCount * sizeof(float);
}
var soElements = new StreamOutputElement[0]; // TODO CREATE StreamOutputElement from bytecode.Reflection.ShaderStreamOutputDeclarations
geometryShader = new GeometryShader(GraphicsDevice.NativeDevice, bytecodeRaw, soElements, soStrides.ToArray(), reflection.StreamOutputRasterizedStream);
}
else
{
geometryShader = new GeometryShader(GraphicsDevice.NativeDevice, bytecodeRaw);
}
break;
case ShaderStage.Pixel:
pixelShader = new PixelShader(GraphicsDevice.NativeDevice, bytecodeRaw);
break;
case ShaderStage.Compute:
computeShader = new ComputeShader(GraphicsDevice.NativeDevice, bytecodeRaw);
break;
}
}
}
static void Main()
{
if (!SharpDevice.IsDirectX11Supported())
{
System.Windows.Forms.MessageBox.Show("DirectX11 Not Supported");
return;
}
//Init textured cube
int[] indices = new int[]
{
0, 1, 2, 0, 2, 3,
4, 6, 5, 4, 7, 6,
8, 9, 10, 8, 10, 11,
12, 14, 13, 12, 15, 14,
16, 18, 17, 16, 19, 18,
20, 21, 22, 20, 22, 23
};
TexturedVertex[] vertices = new[]
{
////TOP
new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(1, 1)),
new TexturedVertex(new Vector3(5, 5, 5), new Vector2(0, 1)),
new TexturedVertex(new Vector3(5, 5, -5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(1, 0)),
//BOTTOM
new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(1, 1)),
new TexturedVertex(new Vector3(5, -5, 5), new Vector2(0, 1)),
new TexturedVertex(new Vector3(5, -5, -5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(1, 0)),
//LEFT
new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(0, 1)),
new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(1, 0)),
new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(1, 1)),
//RIGHT
new TexturedVertex(new Vector3(5, -5, 5), new Vector2(1, 1)),
new TexturedVertex(new Vector3(5, 5, 5), new Vector2(1, 0)),
new TexturedVertex(new Vector3(5, 5, -5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(5, -5, -5), new Vector2(0, 1)),
//FRONT
new TexturedVertex(new Vector3(-5, 5, 5), new Vector2(1, 0)),
new TexturedVertex(new Vector3(5, 5, 5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(5, -5, 5), new Vector2(0, 1)),
new TexturedVertex(new Vector3(-5, -5, 5), new Vector2(1, 1)),
//BACK
new TexturedVertex(new Vector3(-5, 5, -5), new Vector2(0, 0)),
new TexturedVertex(new Vector3(5, 5, -5), new Vector2(1, 0)),
new TexturedVertex(new Vector3(5, -5, -5), new Vector2(1, 1)),
new TexturedVertex(new Vector3(-5, -5, -5), new Vector2(0, 1))
};
//render form
RenderForm form = new RenderForm();
form.Text = "Tutorial 14: Output Stream";
SharpFPS fpsCounter = new SharpFPS();
using (SharpDevice device = new SharpDevice(form))
{
//Init font
SharpBatch font = new SharpBatch(device, "textfont.dds");
//Init Mesh
SharpMesh mesh = SharpMesh.Create <TexturedVertex>(device, vertices, indices);
//Init shader from file
SharpShader shader = new SharpShader(device, "../../HLSL.txt",
new SharpShaderDescription()
{
VertexShaderFunction = "VS", PixelShaderFunction = "PS"
},
new InputElement[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0)
});
//output stream element declaration
StreamOutputElement[] soDeclaration = new StreamOutputElement[]
{
new StreamOutputElement()
{
SemanticName = "POSITION", ComponentCount = 3
},
new StreamOutputElement()
{
SemanticName = "TEXCOORD", ComponentCount = 2
}
};
const int streamOutputVertexSize = 20; //bytes (3 floats for position, 2 floats for texcoord)
//output shader
SharpShader shaderOutput = new SharpShader(device, "../../HLSL.txt",
new SharpShaderDescription()
{
VertexShaderFunction = "VS_O", GeometryShaderFunction = "GS_O", GeometrySO = soDeclaration
},
new InputElement[] {
new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0)
});
//declare 2 output buffer to switch between them
//one will contain the source and the other will be the target of the rendeinrg
SharpOutputBuffer outputBufferA = new SharpOutputBuffer(device, 100000);
SharpOutputBuffer outputBufferB = new SharpOutputBuffer(device, 100000);
//Create constant buffer
Buffer11 buffer = shader.CreateBuffer <Matrix>();
//Create texture from file
ShaderResourceView texture = ShaderResourceView.FromFile(device.Device, "../../texture.bmp");
fpsCounter.Reset();
//for updating
bool update = true;
Vector3 nextPosition = new Vector3();
form.KeyUp += (sender, e) =>
{
switch (e.KeyCode)
{
case Keys.Up:
update = true;
nextPosition += new Vector3(0, 10, 0);
break;
case Keys.Down:
update = true;
nextPosition += new Vector3(0, -10, 0);
break;
case Keys.A:
update = true;
nextPosition += new Vector3(-10, 0, 0);
break;
case Keys.D:
update = true;
nextPosition += new Vector3(10, 0, 0);
break;
case Keys.W:
update = true;
nextPosition += new Vector3(0, 0, 10);
break;
case Keys.S:
update = true;
nextPosition += new Vector3(0, 0, -10);
break;
}
};
//main loop
RenderLoop.Run(form, () =>
{
//Resizing
if (device.MustResize)
{
device.Resize();
font.Resize();
}
//apply states
device.UpdateAllStates();
//clear color
device.Clear(Color.CornflowerBlue);
//apply constant buffer to shader
device.DeviceContext.VertexShader.SetConstantBuffer(0, buffer);
//set texture
device.DeviceContext.PixelShader.SetShaderResource(0, texture);
//update output buffer only when needed
if (update)
{
//switch buffer
var t = outputBufferA;
outputBufferA = outputBufferB;
outputBufferB = t;
//apply shader
shaderOutput.Apply();
//start drawing on output buffer
outputBufferA.Begin();
//draw the other output buffer as source
device.UpdateData <Matrix>(buffer, Matrix.Identity);
outputBufferB.Draw(streamOutputVertexSize);
//draw the mesh to add it to buffer
device.UpdateData <Matrix>(buffer, Matrix.Translation(nextPosition));
//draw mesh
mesh.Draw();
//end rendering on buffer
outputBufferA.End();
//stop updating
update = false;
}
//set transformation matrix
float ratio = (float)form.ClientRectangle.Width / (float)form.ClientRectangle.Height;
Matrix projection = Matrix.PerspectiveFovLH(3.14F / 3.0F, ratio, 1, 1000);
Matrix view = Matrix.LookAtLH(new Vector3(0, 50, -100), new Vector3(), Vector3.UnitY);
Matrix world = Matrix.Identity;
Matrix WVP = world * view * projection;
device.UpdateData <Matrix>(buffer, WVP);
//stream
shader.Apply();
//draw all buffer every frame
outputBufferA.Draw(streamOutputVertexSize);
//begin drawing text
font.Begin();
//draw string
fpsCounter.Update();
font.DrawString("FPS: " + fpsCounter.FPS, 0, 0, Color.White);
font.DrawString("Press WASD, Up, Down to move cube", 0, 30, Color.White);
//flush text to view
font.End();
//present
device.Present();
});
//release resource
font.Dispose();
mesh.Dispose();
buffer.Dispose();
texture.Dispose();
}
}
public StreamOutputDescription(StreamOutputElement[] elements)
{
Elements = elements;
}
