public void SetIndexBuffer(IIndexBuffer indicies)
{
var index = _indicies.Count;
_indicies.Add(indicies);
_buffer.Add(new GraphicsStateChange(CommandTypes.IndexBuffer, index));
}
public override void Enable(IIndexBuffer indexBuffer, IVertexBuffer instanceBuffer)
{
this.currentIndexBuffer = (IndexBuffer)indexBuffer;
var ib = ((VertexBuffer)instanceBuffer);
com.Enable(((IndexBuffer)indexBuffer).com, ib.com, vertexByteSize, ib.vertexByteSize);
}
unsafe void IManagerDevice.OnDeviceInit()
{
if (m_markerConstantBuffer == null)
{
m_markerConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyPostprocessMarkCascades.MarkerConstantBuffer", sizeof(MyMarkerConstants), usage: ResourceUsage.Dynamic);
}
if (m_psMarker == PixelShaderId.NULL)
{
m_psMarker = MyShaders.CreatePs("Shadows\\StencilMarker.hlsl");
}
if (m_vsMarker == VertexShaderId.NULL)
{
m_vsMarker = MyShaders.CreateVs("Shadows\\StencilMarker.hlsl");
}
if (m_psDrawCoverage == PixelShaderId.NULL)
{
m_psDrawCoverage = MyShaders.CreatePs("Shadows\\CascadeCoverage.hlsl");
}
if (m_inputLayout == InputLayoutId.NULL)
{
m_inputLayout = MyShaders.CreateIL(m_vsMarker.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3));
}
m_vertexBuffer = CreateVertexBuffer();
m_indexBuffer = CreateIndexBuffer();
}
public StaticMesh LoadMesh <TVertex, TIndex>(string name, TVertex[] vertices, VertexDescription vertexDescription, TIndex[] indices, IndexFormat indexFormat)
where TVertex : struct
where TIndex : struct
{
if (vertices == null)
{
throw new ArgumentNullException("vertices");
}
if (vertices.Length == 0)
{
throw new ArgumentException("Vertices is empty.", "vertices");
}
if (indices == null)
{
throw new ArgumentNullException("indices");
}
if (indices.Length == 0)
{
throw new ArgumentException("Indices is empty.", "indices");
}
IVertexBuffer vertexBuffer = Engine.GraphicsDevice.Factory.CreateVertexBuffer(vertices, vertexDescription, ResourceUsage.Normal);
IIndexBuffer indexBuffer = Engine.GraphicsDevice.Factory.CreateIndexBuffer(indices, indexFormat, ResourceUsage.Normal);
return(new StaticMesh(this, name, AssetType.User, vertexBuffer, indexBuffer));
}
internal void Clear()
{
m_deviceContext.ClearState();
m_inputLayout = null;
m_primitiveTopology = PrimitiveTopology.Undefined;
m_indexBufferRef = null;
m_indexBufferFormat = 0;
m_indexBufferOffset = 0;
for (int i = 0; i < m_vertexBuffers.Length; i++)
m_vertexBuffers[i] = null;
for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
m_vertexBuffersStrides[i] = 0;
m_blendState = null;
m_stencilRef = 0;
m_depthStencilState = null;
m_rtvsCount = 0;
for (int i = 0; i < m_rtvs.Length; i++)
m_rtvs[i] = null;
m_dsv = null;
m_rasterizerState = null;
m_scissorLeftTop = new Vector2I(-1, -1);
m_scissorRightBottom = new Vector2I(-1, -1);
m_viewport = default(RawViewportF);
m_targetBuffer = null;
m_targetOffsets = 0;
m_statistics.ClearStates++;
}
public void Update(IIndexBuffer buffer, DataArray data, int count)
{
var dxBuffer = graphicsDevice.Cast <IndexBuffer>(buffer, "buffer");
if (dxBuffer.Usage == ResourceUsage.Immutable)
{
throw new ArgumentException("Can't update immutable resource.", "buffer");
}
if (data.Size != buffer.SizeBytes)
{
throw new ArgumentException("Data does not match IndexBuffer size.", "data");
}
if (dxBuffer.Usage == ResourceUsage.Normal)
{
renderContext.Context.UpdateSubresource(new SharpDX.DataBox(data.Pointer, 0, 0), dxBuffer.Buffer);
}
else
{
MapMode mapMode = dxBuffer.Usage == ResourceUsage.Dynamic ? MapMode.WriteDiscard : MapMode.Write;
SharpDX.DataBox box = renderContext.Context.MapSubresource(dxBuffer.Buffer, 0, mapMode, MapFlags.None);
SharpDX.Utilities.CopyMemory(box.DataPointer, data.Pointer, data.Size);
renderContext.Context.UnmapSubresource(dxBuffer.Buffer, 0);
}
}
public Sprite( ITexture2D texture, IEffect effect )
{
if ( effect == null )
{
if ( baseSpriteEffect == null )
baseSpriteEffect = new SpriteEffect ();
effect = baseSpriteEffect;
}
Texture = texture;
Effect = effect;
int width = 1, height = 1;
if ( texture != null ) { width = texture.Width; height = texture.Height; }
vertexBuffer = LiqueurSystem.GraphicsDevice.CreateVertexBuffer<SpriteVertex> ( SpriteVertexFormat, new SpriteVertex []
{
new SpriteVertex ( new Vector2 ( 0.001f, 0.001f ), Color.White, new Vector2 ( 0.001f, 0.001f ) ),
new SpriteVertex ( new Vector2 ( width, 0.001f ), Color.White, new Vector2 ( 1, 0.001f ) ),
new SpriteVertex ( new Vector2 ( 0.001f, height ), Color.White, new Vector2 ( 0.001f, 1 ) ),
new SpriteVertex ( new Vector2 ( width, height ), Color.White, new Vector2 ( 1, 1 ) ),
} );
if ( indexBuffer == null )
indexBuffer = LiqueurSystem.GraphicsDevice.CreateIndexBuffer ( new int [] { 0, 1, 2, 1, 3, 2 } );
indexReference++;
clippingArea = new Rectangle ( 0, 0, width, height );
TextureFilter = Liqueur.Graphics.TextureFilter.Nearest;
}
unsafe static void InitBillboardsIndexBuffer()
{
if (m_IB != null)
{
MyManagers.Buffers.Dispose(m_IB);
}
uint[] indices = new uint[MAX_BILLBOARDS_SIZE * 6];
for (int i = 0; i < MAX_BILLBOARDS_SIZE; i++)
{
indices[i * 6 + 0] = (uint)(i * 4 + 0);
indices[i * 6 + 1] = (uint)(i * 4 + 1);
indices[i * 6 + 2] = (uint)(i * 4 + 2);
indices[i * 6 + 3] = (uint)(i * 4 + 0);
indices[i * 6 + 4] = (uint)(i * 4 + 2);
indices[i * 6 + 5] = (uint)(i * 4 + 3);
}
fixed(uint *ptr = indices)
{
m_IB = MyManagers.Buffers.CreateIndexBuffer(
"MyBillboardRenderer", MAX_BILLBOARDS_SIZE * 6, new IntPtr(ptr),
MyIndexBufferFormat.UInt, ResourceUsage.Immutable);
}
}
internal static void OnDeviceEnd()
{
if (m_IB != null)
{
MyManagers.Buffers.Dispose(m_IB);
}
m_IB = null;
}
private void DestroyIndexBuffer()
{
if (m_cubeIB != null)
{
MyManagers.Buffers.Dispose(m_cubeIB);
}
m_cubeIB = null;
}
public SpriteRenderer(Renderer renderer, bool allowAlpha, IShader shader)
{
this.renderer = renderer;
this.shader = shader;
vertexBuffer = renderer.Device.CreateVertexBuffer( vertices.Length );
indexBuffer = renderer.Device.CreateIndexBuffer( indices.Length );
}
void IManagerDevice.OnDeviceReset()
{
MyManagers.Buffers.Dispose(m_vertexBuffer);
m_vertexBuffer = CreateVertexBuffer();
MyManagers.Buffers.Dispose(m_indexBuffer);
m_indexBuffer = CreateIndexBuffer();
}
public void Resize(IIndexBuffer buffer, int newElements, int newByteStride = -1, IntPtr?newData = null)
{
MyRenderProxy.Assert(newElements > 0);
MyRenderProxy.Assert(newByteStride > 0 || newByteStride == -1);
var indexBuffer = buffer as MyIndexBuffer;
ResizeInternal(indexBuffer, newElements, newByteStride, newData, b => b.Format = indexBuffer.Format);
}
public void SetIndexBuffer(IIndexBuffer indexBuffer)
{
var buffer = graphicsDevice.Cast <IndexBuffer>(indexBuffer, "indexBuffer");
if (currentIndexBuffer != buffer)
{
currentIndexBuffer = buffer;
}
}
private static void InitDevice()
{
m_particleBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::particleBuffer", MyGPUEmitters.MAX_PARTICLES, PARTICLE_STRIDE);
m_deadListBuffer = MyManagers.Buffers.CreateUav(
"MyGPUParticleRenderer::deadListBuffer", MyGPUEmitters.MAX_PARTICLES, sizeof(uint),
uavType: MyUavType.Append);
m_skippedParticleCountBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::skippedParticleCountBuffer", 1, sizeof(uint),
uavType: MyUavType.Counter);
// Create a staging buffer that is used to read GPU atomic counter into that can then be mapped for reading
// back to the CPU for debugging purposes
m_debugCounterBuffers[0] = MyManagers.Buffers.CreateRead("MyGPUParticleRenderer::debugCounterBuffers[0]", 1, sizeof(uint));
m_debugCounterBuffers[1] = MyManagers.Buffers.CreateRead("MyGPUParticleRenderer::debugCounterBuffers[1]", 1, sizeof(uint));
m_activeListConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyGPUParticleRenderer::activeListConstantBuffer", 4 * sizeof(uint));
m_emitterConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyGPUParticleRenderer::emitterConstantBuffer", EMITTERCONSTANTBUFFER_SIZE, usage: ResourceUsage.Dynamic);
m_emitterStructuredBuffer = MyManagers.Buffers.CreateSrv(
"MyGPUParticleRenderer::emitterStructuredBuffer", MyGPUEmitters.MAX_LIVE_EMITTERS, EMITTERDATA_SIZE,
usage: ResourceUsage.Dynamic);
m_aliveIndexBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::aliveIndexBuffer", MyGPUEmitters.MAX_PARTICLES, sizeof(float),
uavType: MyUavType.Counter);
m_indirectDrawArgsBuffer = MyManagers.Buffers.CreateIndirectArgsBuffer("MyGPUParticleRenderer::indirectDrawArgsBuffer", 5, sizeof(uint));
unsafe
{
uint[] indices = new uint[MyGPUEmitters.MAX_PARTICLES * 6];
for (uint i = 0, index = 0, vertex = 0; i < MyGPUEmitters.MAX_PARTICLES; i++)
{
indices[index + 0] = vertex + 0;
indices[index + 1] = vertex + 1;
indices[index + 2] = vertex + 2;
indices[index + 3] = vertex + 2;
indices[index + 4] = vertex + 1;
indices[index + 5] = vertex + 3;
vertex += 4;
index += 6;
}
fixed(uint *ptr = indices)
{
m_ib = MyManagers.Buffers.CreateIndexBuffer(
"MyGPUParticleRenderer::indexBuffer", MyGPUEmitters.MAX_PARTICLES * 6, new IntPtr(ptr),
MyIndexBufferFormat.UInt, ResourceUsage.Immutable);
}
}
//MyRender11.BlendAlphaPremult
}
/// <summary>
/// Sets the index buffer paired with this vertex array.
/// </summary>
/// <param name="indexBuffer">An index buffer object to bind to this object.</param>
public void SetIndexBuffer(IIndexBuffer indexBuffer)
{
ValidateDispose();
if (m_indexBuffer != indexBuffer)
{
m_indexBuffer = indexBuffer;
m_dirty = true;
}
}
public void SetIndexBuffer(IIndexBuffer indexBuffer)
{
var dxIndexBuffer = graphicsDevice.Cast <IndexBuffer>(indexBuffer, "indexBuffer");
if (currentIndexBuffer != dxIndexBuffer)
{
currentIndexBuffer = dxIndexBuffer;
indexBufferDirty = true;
}
}
public void SetIndexBuffer(IIndexBuffer indexBuffer)
{
var command = new GLCommand
{
Type = CommandType.SetIndexBuffer,
IndexBuffer = (GL46IndexBuffer)indexBuffer
};
_commandList.Add(command);
}
/// <summary>
/// Adds the specified index buffer.
/// </summary>
/// <param name="indexBuffer">The index buffer.</param>
/// <exception cref="ArgumentNullException"></exception>
public void Add(IIndexBuffer indexBuffer)
{
if (indexBuffer == null)
{
throw new ArgumentNullException();
}
Bind();
indexBuffer.Bind();
IndexBuffer = indexBuffer;
}
/// <summary>
/// Renders from the index and vertex buffers.
/// </summary>
protected override void OnRender()
{
IVertexBuffer vertBuf = m_vertexArray.VertexBuffer;
IIndexBuffer indexBuf = m_vertexArray.IndexBuffer;
if (vertBuf != null && vertBuf.Count > 0 && indexBuf != null && indexBuf.Count > 0)
{
m_vertexArray.Bind();
GL.DrawElements(PrimitiveType, indexBuf.Count, indexBuf.ElementType, 0);
m_vertexArray.Unbind();
}
}
/// <summary>
/// Sets an index buffer as the current buffer
/// </summary>
/// <param name="indices">Index buffer to set. Pass this as null to disable index buffer</param>
public void SetIndexBuffer(OpenGL.IIndexBuffer indices)
{
if (index_buffer != null)
{
index_buffer.MakeNonCurrent();
}
if (indices != null)
{
indices.MakeCurrent();
}
index_buffer = indices;
}
public ExampleLayer()
{
//Create camera
cameraController = new OrthographicCameraController(1280.0f / 720.0f);
//Shader library
shaderLibrary = new ShaderLibrary();
// ----------
//Square
// ----------
squareVertexArray = IVertexArray.Create();
float[] squareVertices =
{
-0.5f, -0.5f, 0.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f, 1.0f,
-0.5f, 0.5f, 0.0f, 0.0f, 1.0f
};
IVertexBuffer squareVertexBuffer = IVertexBuffer.Create(squareVertices, squareVertices.GetBytes());
BufferLayout squareBufferLayout = new BufferLayout(new[]
{
new BufferElement("a_Position", ShaderDataType.Float3),
new BufferElement("a_TexCoord", ShaderDataType.Float2)
});
squareVertexBuffer.SetLayout(squareBufferLayout);
squareVertexArray.AddVertexBuffer(squareVertexBuffer);
uint[] squareIndices = { 0, 1, 2, 2, 3, 0 };
IIndexBuffer squareIndexBuffer =
IIndexBuffer.Create(squareIndices, squareIndices.GetBytes() / sizeof(uint));
squareVertexArray.SetIndexBuffer(squareIndexBuffer);
//Square shader
shaderLibrary.LoadAndAddShader("Shaders/Square.glsl");
//Texture shader
IShader textureShader = IShader.Create("Shaders/Texture.glsl");
shaderLibrary.AddShader(textureShader);
birdiTexture = I2DTexture.Create("Textures/Birdi.png");
faceTexture = I2DTexture.Create("Textures/Face.png");
textureShader.Bind();
textureShader.SetInt("u_Texture", 0);
}
/// <summary>
/// Cleanup of unmanaged resources.
/// </summary>
protected override void OnDispose(bool disposing)
{
if (m_vertexBuffer != null)
{
m_vertexBuffer.Dispose();
m_vertexBuffer = null;
}
if (m_indexBuffer != null)
{
m_indexBuffer.Dispose();
m_indexBuffer = null;
}
}
public override void Build(IDevice device)
{
_indexBuffer = device.CreateIndexBuffer(new int[] { 0, 3, 1, 3, 2, 1 });
_vertexBuffer = device.CreateVertexBuffer(CreateCube());
using var pixelShaderBlob = new Blob(device.TEMPORARYCompiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferPixelShader.hlsl", "main", "ps_5_0"));
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
using var vertexShaderBlob = new Blob(device.TEMPORARYCompiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferVertexShader.hlsl", "main", "vs_5_0"));
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(2).Append("POSITION", VertexLayoutTypes.Position2D).Append("TEXCOORD", VertexLayoutTypes.Position2D), vertexShaderBlob);
_sampler = device.CreateSampler();
}
private static void DoneDevice()
{
MyManagers.Buffers.Dispose(m_ib); m_ib = null;
MyManagers.Buffers.Dispose(m_activeListConstantBuffer); m_activeListConstantBuffer = null;
MyManagers.Buffers.Dispose(m_indirectDrawArgsBuffer); m_indirectDrawArgsBuffer = null;
MyManagers.Buffers.Dispose(m_debugCounterBuffers); m_debugCounterBuffers = new IReadBuffer[m_debugCounterBuffers.Length];
MyManagers.Buffers.Dispose(m_aliveIndexBuffer); m_aliveIndexBuffer = null;
MyManagers.Buffers.Dispose(m_deadListBuffer); m_deadListBuffer = null;
MyManagers.Buffers.Dispose(m_skippedParticleCountBuffer); m_skippedParticleCountBuffer = null;
MyManagers.Buffers.Dispose(m_particleBuffer); m_particleBuffer = null;
MyManagers.Buffers.Dispose(m_emitterConstantBuffer); m_emitterConstantBuffer = null;
MyManagers.Buffers.Dispose(m_emitterStructuredBuffer); m_emitterStructuredBuffer = null;
}
public IIndexBuffer GetOrCreateIB(MyMwmData mwmData)
{
string filepath = mwmData.MwmFilepath;
if (m_ibs.ContainsKey(filepath))
{
return(m_ibs[filepath]);
}
IIndexBuffer ib = CreateSimpleIB(mwmData);
m_ibs.Add(filepath, ib);
return(m_ibs[filepath]);
}
internal void SetIndexBuffer(IIndexBuffer ib, MyIndexBufferFormat format, int offset)
{
if (ib == m_indexBufferRef &&
format == m_indexBufferFormat &&
offset == m_indexBufferOffset)
{
return;
}
m_indexBufferRef = ib;
m_indexBufferFormat = format;
m_indexBufferOffset = offset;
m_deviceContext.InputAssembler.SetIndexBuffer(ib.Buffer, (Format)format, offset);
m_statistics.SetIndexBuffers++;
}
public RenderToBackbufferPass(IDevice device, ID3DCompiler compiler)
{
_backBuffer = device.BackBuffer;
_depthStencil = device.DepthStencil;
_indexBuffer = device.CreateIndexBuffer(new int[] { 0, 3, 1, 3, 2, 1 });
_vertexBuffer = device.CreateVertexBuffer(CreateCube());
using var pixelShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferPixelShader.hlsl", "main", "ps_5_0"));
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
using var vertexShaderBlob = new Blob(compiler.CompileShaderFromFile(@"F:\Git\GameDev\resources\shaders\BackBufferVertexShader.hlsl", "main", "vs_5_0"));
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(2).Append("POSITION", VertexLayoutTypes.Position2D).Append("TEXCOORD", VertexLayoutTypes.Position2D), vertexShaderBlob);
_sampler = device.CreateSampler();
}
internal void Clear()
{
if (m_deviceContext != null)
{
m_deviceContext.ClearState();
}
m_inputLayout = null;
m_primitiveTopology = PrimitiveTopology.Undefined;
m_indexBufferRef = null;
m_indexBufferFormat = 0;
m_indexBufferOffset = 0;
for (int i = 0; i < m_vertexBuffers.Length; i++)
{
m_vertexBuffers[i] = null;
}
for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
{
m_vertexBuffersStrides[i] = 0;
}
for (int i = 0; i < m_vertexBuffersByteOffset.Length; i++)
{
m_vertexBuffersByteOffset[i] = 0;
}
m_blendState = null;
m_stencilRef = 0;
m_depthStencilState = null;
m_rtvsCount = 0;
for (int i = 0; i < m_rtvs.Length; i++)
{
m_rtvs[i] = null;
}
m_dsv = null;
m_rasterizerState = null;
m_scissorLeftTop = new Vector2I(-1, -1);
m_scissorRightBottom = new Vector2I(-1, -1);
m_viewport = default(RawViewportF);
m_targetBuffer = null;
m_targetOffsets = 0;
if (m_statistics != null)
{
m_statistics.ClearStates++;
}
}
public void Update(IIndexBuffer indexBuffer, DataArray data, int count)
{
var internalBuffer = graphicsDevice.Cast <IndexBuffer>(indexBuffer, "indexBuffer");
if (internalBuffer.IsDisposed)
{
throw new ObjectDisposedException("indexBuffer");
}
if (internalBuffer.Usage == ResourceUsage.Immutable)
{
throw new ArgumentException("Can't update immutable resource.", "indexBuffer");
}
internalBuffer.UpdateData(data);
}
/// <summary>
/// Updates the index buffer object from the <see cref="Triangles"/> array.
/// Ensures that the smallest unsigned integer type possible is used for the buffer.
/// </summary>
private void UpdateIndices()
{
// if the current type of index buffer can't store enough vertices get rid of it
if (m_indexBuffer != null && m_indexBuffer.MaxVertices < m_vertices.Length)
{
m_indexBuffer.Dispose();
m_indexBuffer = null;
}
// create a new index buffer able to address all of the vertices if needed
if (m_indexBuffer == null)
{
int capacity = m_triangles.Length * 3;
if (m_vertices.Length <= byte.MaxValue)
{
m_indexBuffer = new IndexBuffer <byte>(capacity);
}
else if (m_vertices.Length <= ushort.MaxValue)
{
m_indexBuffer = new IndexBuffer <ushort>(capacity);
}
else
{
m_indexBuffer = new IndexBuffer <uint>(capacity);
}
}
// copy the triangles' indices into the buffer
if (m_indexBuffer is IndexBuffer <byte> )
{
CopyIndices(m_indexBuffer as IndexBuffer <byte>, index => (byte)index);
}
else if (m_indexBuffer is IndexBuffer <ushort> )
{
CopyIndices(m_indexBuffer as IndexBuffer <ushort>, index => (ushort)index);
}
else
{
CopyIndices(m_indexBuffer as IndexBuffer <uint>, index => index);
}
// upload to the GPU
m_indexBuffer.BufferData();
m_indexBufferDirty = false;
}
internal void ReleaseBuffers()
{
if (IB != null)
{
MyManagers.Buffers.Dispose(IB);
IB = null;
}
if (VB != null)
{
foreach (var vb in VB)
{
//vb.Dispose();
MyManagers.Buffers.Dispose(vb);
}
VB = null;
}
}
internal void ReleaseBuffers()
{
if(IB != null)
{
MyManagers.Buffers.Dispose(IB);
IB = null;
}
if(VB != null)
{
foreach(var vb in VB)
{
//vb.Dispose();
MyManagers.Buffers.Dispose(vb);
}
VB = null;
}
}
unsafe void IManagerDevice.OnDeviceInit()
{
if (m_markerConstantBuffer == null)
m_markerConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyPostprocessMarkCascades.MarkerConstantBuffer", sizeof(MyMarkerConstants), usage: ResourceUsage.Dynamic);
if (m_psMarker == PixelShaderId.NULL)
m_psMarker = MyShaders.CreatePs("Shadows\\StencilMarker.hlsl");
if (m_vsMarker == VertexShaderId.NULL)
m_vsMarker = MyShaders.CreateVs("Shadows\\StencilMarker.hlsl");
if (m_psDrawCoverage == PixelShaderId.NULL)
m_psDrawCoverage = MyShaders.CreatePs("Shadows\\CascadeCoverage.hlsl");
if (m_inputLayout == InputLayoutId.NULL)
m_inputLayout = MyShaders.CreateIL(m_vsMarker.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3));
m_vertexBuffer = CreateVertexBuffer();
m_indexBuffer = CreateIndexBuffer();
}
public SpriteBatchRenderer(IDevice device, IBlobReader blobReader, ICameraFactory cameraFactory)
{
_device = device;
_context = _device.ImmediateContext;
_camera = cameraFactory.CreateOrhographicCamera();
_buffer = device.CreateVertexBuffer <Vertex2D>(MaxVertices, BufferUsage.Dynamic, BufferAccessFlags.Write);
_indices = device.CreateIndexBuffer(CreateIndices());
_sampler = device.CreateSampler(true);
_blendState = device.CreateBlendState();
_cameraBuffer = device.CreateConstantBuffer(new Camera {
Transform = _camera.ViewProjection
});
using var vertexShaderBlob = blobReader.ReadFromFile("Shaders/VertexShader2D.cso");
_vertexShader = device.CreateVertexShader(vertexShaderBlob);
using var pixelShaderBlob = blobReader.ReadFromFile("Shaders/PixelShader2D.cso");
_pixelShader = device.CreatePixelShader(pixelShaderBlob);
_inputLayout = device.CreateInputLayout(new VertexLayout(3).Append("Position", VertexLayoutTypes.Position2D).Append("Textures", VertexLayoutTypes.Texture2D).Append("Color", VertexLayoutTypes.Float4Color), vertexShaderBlob);
}
public TerrainRenderer(World world, WorldRenderer wr)
{
this.world = world;
this.map = world.Map;
Size tileSize = new Size( Game.CellSize, Game.CellSize );
var tileMapping = new Cache<TileReference<ushort,byte>, Sprite>(
x => Game.modData.SheetBuilder.Add(world.TileSet.GetBytes(x), tileSize));
Vertex[] vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];
ushort[] indices = new ushort[6 * map.Bounds.Height * map.Bounds.Width];
terrainSheet = tileMapping[map.MapTiles[map.Bounds.Left, map.Bounds.Top]].sheet;
int nv = 0;
int ni = 0;
for( int j = map.Bounds.Top; j < map.Bounds.Bottom; j++ )
for( int i = map.Bounds.Left; i < map.Bounds.Right; i++ )
{
Sprite tile = tileMapping[map.MapTiles[i, j]];
// TODO: The zero below should explicitly refer to the terrain palette, but this code is called
// before the palettes are created. Therefore assumes that "terrain" is the first palette to be defined
Util.FastCreateQuad(vertices, indices, Game.CellSize * new float2(i, j), tile, 0, nv, ni, tile.size);
nv += 4;
ni += 6;
if (tileMapping[map.MapTiles[i, j]].sheet != terrainSheet)
throw new InvalidOperationException("Terrain sprites span multiple sheets");
}
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer( vertices.Length );
vertexBuffer.SetData( vertices, nv );
indexBuffer = Game.Renderer.Device.CreateIndexBuffer( indices.Length );
indexBuffer.SetData( indices, ni );
}
public TerrainRenderer(World world, Renderer renderer, WorldRenderer wr)
{
this.renderer = renderer;
this.map = world.Map;
Size tileSize = new Size( Game.CellSize, Game.CellSize );
var tileMapping = new Cache<TileReference, Sprite>(
x => SheetBuilder.SharedInstance.Add(world.TileSet.GetBytes(x), tileSize));
Vertex[] vertices = new Vertex[4 * map.Height * map.Width];
ushort[] indices = new ushort[6 * map.Height * map.Width];
int nv = 0;
int ni = 0;
for( int j = map.YOffset ; j < map.YOffset + map.Height ; j++ )
for( int i = map.XOffset ; i < map.XOffset + map.Width; i++ )
{
Sprite tile = tileMapping[map.MapTiles[i, j]];
// TODO: The zero below should explicitly refer to the terrain palette, but this code is called
// before the palettes are created
Util.FastCreateQuad(vertices, indices, Game.CellSize * new float2(i, j), tile, 0, nv, ni, tile.size);
nv += 4;
ni += 6;
}
terrainSheet = tileMapping[map.MapTiles[map.XOffset, map.YOffset]].sheet;
vertexBuffer = renderer.Device.CreateVertexBuffer( vertices.Length );
vertexBuffer.SetData( vertices );
indexBuffer = renderer.Device.CreateIndexBuffer( indices.Length );
indexBuffer.SetData( indices );
overlayRenderer = new SmudgeRenderer( renderer, map );
}
// Correct normal calculations
//http://www.gamedev.net/reference/articles/article2264.asp
public unsafe void Build( TerrainPatchBuilder builder )
{
using ( IVertexBufferLock vbLock = m_VbRange.Lock( ) )
{
m_IndexBuffer = BuildIndexBuffer( );
TerrainVertex* firstVertex = ( TerrainVertex* )vbLock.Bytes;
TerrainVertex* curVertex = firstVertex;
Vector3 xInc = m_PatchXDir * ( m_PatchWidth / ( m_Size - 1 ) );
Vector3 zInc = m_PatchZDir * ( m_PatchHeight / ( m_Size - 1 ) );
Point3 rowStart = m_TopLeft;
for ( int row = 0; row < m_Size; ++row )
{
Point3 curPt = rowStart;
for ( int col = 0; col < m_Size; ++col )
{
Vector3 rlVec = ( curPt - Point3.Origin ).MakeNormal( );
Point3 rlPt = Point3.Origin + rlVec * 2;
float ptHeight = ( TestNoisePlanetTerrainGenerator.TerrainHeight( rlPt.X, rlPt.Y, rlPt.Z ) - 0.5f ) * 16.0f;
rlPt = Point3.Origin + rlVec * ( PlanetRadius + ptHeight );
curVertex->SetPosition( rlPt.X, rlPt.Y, rlPt.Z );
++curVertex;
curPt += xInc;
}
rowStart += zInc;
}
for ( int row = 0; row < m_Size - 1; ++row )
{
curVertex = firstVertex + ( row * m_Size );
for ( int col = 0; col < m_Size - 1; ++col )
{
Point3 pt0 = curVertex->Position;
Point3 pt1 = ( curVertex + m_Size )->Position;
Point3 pt2 = ( curVertex + 1 )->Position;
Vector3 vec = Vector3.Cross( pt1 - pt0, pt2 - pt0 ).MakeNormal( );
// TODO: Make correct normal calculation
curVertex->SetNormal( vec.X, vec.Y, vec.Z );
++curVertex;
}
}
}
}
public override void Intro( params object [] args )
{
IFileSystem fileSystem = FileSystemManager.GetFileSystem ( "ManifestFileSystem" );
contentManager = new ContentManager ( fileSystem );
contentManager.AddDefaultContentLoader ();
ImageInfo imageInfo = new PngDecoder ().Decode ( fileSystem.OpenFile ( "Test.Game.Terrain.Resources.terrain_01.png" ) );
Color [] decoded = imageInfo.GetPixel ( null );
terrainVertex = LiqueurSystem.GraphicsDevice.CreateVertexBuffer<TerrainVertex> (
FlexibleVertexFormat.PositionXYZ | FlexibleVertexFormat.Diffuse | FlexibleVertexFormat.TextureUV1,
imageInfo.Width * imageInfo.Height );
TerrainVertex [] tempVertices = new TerrainVertex [ terrainVertex.Length ];
int index = 0;
for ( int x = 0; x < imageInfo.Height; x++ )
{
for ( int z = 0; z < imageInfo.Width; z++ )
{
int location = x * imageInfo.Width + z;
tempVertices [ index ] = new TerrainVertex (
( x - imageInfo.Width / 2 ) * 5.0f, ( decoded [ location ].AlphaValue ) * 5.0f / 2,
( z - imageInfo.Width / 2 ) * 5.0f,
z / ( float ) imageInfo.Width, x / ( float ) imageInfo.Height
);
++index;
}
}
terrainVertex.Vertices = tempVertices;
terrainIndex = LiqueurSystem.GraphicsDevice.CreateIndexBuffer ( imageInfo.Width * imageInfo.Height * 2 * 3 );
int [] tempIndices = new int [ terrainIndex.Length ];
index = 0;
for ( int z = 0; z < imageInfo.Height - 1; z++ )
{
for ( int x = 0; x < imageInfo.Width - 1; x++ )
{
tempIndices [ index++ ] = z * imageInfo.Width + x;
tempIndices [ index++ ] = z * imageInfo.Width + ( x + 1 );
tempIndices [ index++ ] = ( z + 1 ) * imageInfo.Width + x;
tempIndices [ index++ ] = ( z + 1 ) * imageInfo.Width + x;
tempIndices [ index++ ] = z * imageInfo.Width + ( x + 1 );
tempIndices [ index++ ] = ( z + 1 ) * imageInfo.Width + ( x + 1 );
}
}
terrainIndex.Indices = tempIndices;
terrainEffect = new SpriteEffect ();
texture = contentManager.Load<ITexture2D> ( "Test.Game.Terrain.Resources.terrain_02.png" );
LiqueurSystem.GraphicsDevice.CullingMode = CullingMode.None;
LiqueurSystem.GraphicsDevice.IsZWriteEnable = true;
LiqueurSystem.GraphicsDevice.BlendState = true;
LiqueurSystem.GraphicsDevice.BlendOperation = BlendOperation.AlphaBlend;
base.Intro ( args );
}
private void DestroyIndexBuffer()
{
if (m_cubeIB != null)
MyManagers.Buffers.Dispose(m_cubeIB); m_cubeIB = null;
}
private unsafe void InitIndexBuffer()
{
DestroyIndexBuffer();
const int indexCount = 36;
ushort* indices = stackalloc ushort[indexCount];
indices[0] = 0; indices[1] = 1; indices[2] = 2;
indices[3] = 0; indices[4] = 2; indices[5] = 3;
indices[6] = 1; indices[7] = 5; indices[8] = 6;
indices[9] = 1; indices[10] = 6; indices[11] = 2;
indices[12] = 5; indices[13] = 4; indices[14] = 7;
indices[15] = 5; indices[16] = 7; indices[17] = 6;
indices[18] = 4; indices[19] = 0; indices[20] = 3;
indices[21] = 4; indices[22] = 3; indices[23] = 7;
indices[24] = 3; indices[25] = 2; indices[26] = 6;
indices[27] = 3; indices[28] = 6; indices[29] = 7;
indices[30] = 1; indices[31] = 0; indices[32] = 4;
indices[33] = 1; indices[34] = 4; indices[35] = 5;
m_cubeIB = MyManagers.Buffers.CreateIndexBuffer(
"MyScreenDecals", indexCount, new IntPtr(indices),
MyIndexBufferFormat.UShort, ResourceUsage.Immutable);
}
public override void Enable(IIndexBuffer indexBuffer)
{
com.Enable(((IndexBuffer)indexBuffer).com, null);
}
public override void Enable(IIndexBuffer indexBuffer, IVertexBuffer instanceBuffer)
{
com.Enable(((IndexBuffer)indexBuffer).com, ((VertexBuffer)instanceBuffer).com);
}
private void BuildBuffers( int maxParticles )
{
m_MaxParticles = maxParticles;
m_Vb = Graphics.Factory.CreateVertexBuffer( );
VertexBufferFormat vbFormat = new VertexBufferFormat( );
vbFormat.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
vbFormat.Add( VertexFieldSemantic.Texture0, VertexFieldElementTypeId.Float32, 2 );
vbFormat.Static = false;
m_Vb.Create( vbFormat, maxParticles * 4 );
m_Ib = Graphics.Factory.CreateIndexBuffer( );
ushort[] indices = new ushort[ maxParticles * 6 ];
int curIndex = 0;
ushort indexValue = 0;
for ( int particleCount = 0; particleCount < maxParticles; ++particleCount )
{
indices[ curIndex++ ] = indexValue;
indices[ curIndex++ ] = ( ushort )( indexValue + 1 );
indices[ curIndex++ ] = ( ushort )( indexValue + 3 );
indices[ curIndex++ ] = ( ushort )( indexValue + 1 );
indices[ curIndex++ ] = ( ushort )( indexValue + 2 );
indices[ curIndex++ ] = ( ushort )( indexValue + 3 );
indexValue += 4;
}
m_Ib.Create( indices, true );
}
/// <summary>
/// Sets an index buffer as the current buffer
/// </summary>
/// <param name="indices">Index buffer to set. Pass this as null to disable index buffer</param>
public void SetIndexBuffer(OpenGL.IIndexBuffer indices)
{
if (index_buffer != null)
index_buffer.MakeNonCurrent();
if (indices != null)
indices.MakeCurrent();
index_buffer = indices;
}
private static void InitDevice()
{
m_particleBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::particleBuffer", MyGPUEmitters.MAX_PARTICLES, PARTICLE_STRIDE);
m_deadListBuffer = MyManagers.Buffers.CreateUav(
"MyGPUParticleRenderer::deadListBuffer", MyGPUEmitters.MAX_PARTICLES, sizeof(uint),
uavType: MyUavType.Append);
m_skippedParticleCountBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::skippedParticleCountBuffer", 1, sizeof(uint),
uavType: MyUavType.Counter);
// Create a staging buffer that is used to read GPU atomic counter into that can then be mapped for reading
// back to the CPU for debugging purposes
m_debugCounterBuffers[0] = MyManagers.Buffers.CreateRead("MyGPUParticleRenderer::debugCounterBuffers[0]", 1, sizeof(uint));
m_debugCounterBuffers[1] = MyManagers.Buffers.CreateRead("MyGPUParticleRenderer::debugCounterBuffers[1]", 1, sizeof(uint));
m_activeListConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyGPUParticleRenderer::activeListConstantBuffer", 4 * sizeof(uint));
m_emitterConstantBuffer = MyManagers.Buffers.CreateConstantBuffer("MyGPUParticleRenderer::emitterConstantBuffer", EMITTERCONSTANTBUFFER_SIZE, usage: ResourceUsage.Dynamic);
m_emitterStructuredBuffer = MyManagers.Buffers.CreateSrv(
"MyGPUParticleRenderer::emitterStructuredBuffer", MyGPUEmitters.MAX_LIVE_EMITTERS, EMITTERDATA_SIZE,
usage: ResourceUsage.Dynamic);
m_aliveIndexBuffer = MyManagers.Buffers.CreateSrvUav(
"MyGPUParticleRenderer::aliveIndexBuffer", MyGPUEmitters.MAX_PARTICLES, sizeof(float),
uavType: MyUavType.Counter);
m_indirectDrawArgsBuffer = MyManagers.Buffers.CreateIndirectArgsBuffer("MyGPUParticleRenderer::indirectDrawArgsBuffer", 5, sizeof(uint));
unsafe
{
uint[] indices = new uint[MyGPUEmitters.MAX_PARTICLES * 6];
for (uint i = 0, index = 0, vertex = 0; i < MyGPUEmitters.MAX_PARTICLES; i++)
{
indices[index + 0] = vertex + 0;
indices[index + 1] = vertex + 1;
indices[index + 2] = vertex + 2;
indices[index + 3] = vertex + 2;
indices[index + 4] = vertex + 1;
indices[index + 5] = vertex + 3;
vertex += 4;
index += 6;
}
fixed (uint* ptr = indices)
{
m_ib = MyManagers.Buffers.CreateIndexBuffer(
"MyGPUParticleRenderer::indexBuffer", MyGPUEmitters.MAX_PARTICLES * 6, new IntPtr(ptr),
MyIndexBufferFormat.UInt, ResourceUsage.Immutable);
}
}
//MyRender11.BlendAlphaPremult
}
/// <summary>
/// Destroys the terrain index buffer
/// </summary>
private void DestroyIndexBuffer( )
{
if ( m_IndexBuffer != null )
{
m_IndexBuffer.Dispose( );
m_IndexBuffer = null;
}
}
internal void SetIndexBuffer(IIndexBuffer ib, MyIndexBufferFormat format, int offset)
{
if (ib == m_indexBufferRef
&& format == m_indexBufferFormat
&& offset == m_indexBufferOffset)
return;
m_indexBufferRef = ib;
m_indexBufferFormat = format;
m_indexBufferOffset = offset;
m_deviceContext.InputAssembler.SetIndexBuffer(ib.Buffer, (Format)format, offset);
m_statistics.SetIndexBuffers++;
}
void IManagerDevice.OnDeviceReset()
{
MyManagers.Buffers.Dispose(m_vertexBuffer);
m_vertexBuffer = CreateVertexBuffer();
MyManagers.Buffers.Dispose(m_indexBuffer);
m_indexBuffer = CreateIndexBuffer();
}
public LineRenderer( Renderer renderer )
{
this.renderer = renderer;
vertexBuffer = renderer.Device.CreateVertexBuffer(vertices.Length );
indexBuffer = renderer.Device.CreateIndexBuffer( indices.Length );
}
public override void Intro( params object [] args )
{
LiqueurSystem.GraphicsDevice.IsZWriteEnable = true;
LiqueurSystem.GraphicsDevice.CullingMode = CullingMode.None;
LiqueurSystem.GraphicsDevice.ScreenSize = new Vector2 ( 800, 600 );
LiqueurSystem.GraphicsDevice.BlendState = true;
LiqueurSystem.GraphicsDevice.BlendOperation = BlendOperation.AlphaBlend;
vertexShader = LiqueurSystem.GraphicsDevice.CreateShader ( @"#version 120
attribute vec3 a_position;
attribute vec2 a_texcoord;
uniform mat4 proj;
uniform mat4 modelView;
varying vec2 v_texcoord;
void main () {
vec4 pos = vec4(a_position, 1);
pos = modelView * pos;
pos = proj * pos;
gl_Position = pos;
v_texcoord = a_texcoord;
}
", ShaderType.VertexShader );
vertexShader.Option = new ShaderOption ()
{
AttributeOrdering = new ShaderOption.AttributeOrder []
{
new ShaderOption.AttributeOrder () { Name = "a_position", VertexType = FlexibleVertexFormat.PositionXYZ },
new ShaderOption.AttributeOrder () { Name = "a_texcoord", VertexType = FlexibleVertexFormat.TextureUV1 }
}
};
fragShader = LiqueurSystem.GraphicsDevice.CreateShader ( @"#version 120
varying vec2 v_texcoord;
uniform sampler2D texture;
void main () {
gl_FragColor = texture2D ( texture, v_texcoord.st );
}
", ShaderType.FragmentShader );
effect = LiqueurSystem.GraphicsDevice.CreateEffect ( vertexShader, fragShader );
effect.SetArgument<Matrix4x4> ( "modelView", Matrix4x4.Identity * new Daramkun.Liqueur.Mathematics.Transforms.View ( new Vector3 ( -7, 7, 10 ),
new Vector3 ( 0f, 0f, 0f ),
new Vector3 ( 0, 1, 0 ) ).Matrix );
effect.SetArgument<Matrix4x4> ( "proj", new PerspectiveFieldOfViewProjection ( ( float ) Math.PI / 4, 800 / 600.0f, 0.0001f, 1000.0f ).Matrix );
vertexBuffer = LiqueurSystem.GraphicsDevice.CreateVertexBuffer<Vertex> ( FlexibleVertexFormat.PositionXY |
FlexibleVertexFormat.Diffuse, new Vertex []
{
new Vertex ( new Vector2 ( -5.0f, +5.0f ), new Vector2 ( 0, 1 ) ),
new Vertex ( new Vector2 ( +5.0f, -5.0f ), new Vector2 ( 1, 0 ) ),
new Vertex ( new Vector2 ( -5.0f, -5.0f ), new Vector2 ( 0, 0 ) ),
new Vertex ( new Vector2 ( +5.0f, +5.0f ), new Vector2 ( 1, 1 ) ),
} );
indexBuffer = LiqueurSystem.GraphicsDevice.CreateIndexBuffer ( new int [] { 0, 2, 1, 0, 1, 3, } );
texture = LiqueurSystem.GraphicsDevice.CreateTexture2D ( new PngDecoder ().Decode (
Assembly.GetEntryAssembly ().GetManifestResourceStream ( "Test.Windows.CSharp.temp.png" ) )
);
renderBuffer = LiqueurSystem.GraphicsDevice.CreateRenderBuffer ( 1024, 1024 );
sprite = new Sprite ( texture );
font = new LsfFont ( Assembly.GetEntryAssembly ().GetManifestResourceStream ( "Test.Windows.CSharp.temp.lsf" ) );
FpsCalculator calc = new FpsCalculator ();
calc.DrawEvent += ( object sender, GameTimeEventArgs e ) =>
{
string fpsString = string.Format ( "Update FPS: {0:0.00}\nRender FPS: {1:0.00}", calc.UpdateFPS, calc.DrawFPS );
font.DrawFont ( fpsString, Color.Black,
new Vector2 ( 0, LiqueurSystem.GraphicsDevice.ScreenSize.Y - font.MeasureString ( fpsString ).Y ) );
};
Add ( calc );
base.Intro ( args );
}
private static void DoneDevice()
{
MyManagers.Buffers.Dispose(m_ib); m_ib = null;
MyManagers.Buffers.Dispose(m_activeListConstantBuffer); m_activeListConstantBuffer = null;
MyManagers.Buffers.Dispose(m_indirectDrawArgsBuffer); m_indirectDrawArgsBuffer = null;
MyManagers.Buffers.Dispose(m_debugCounterBuffers); m_debugCounterBuffers = new IReadBuffer[m_debugCounterBuffers.Length];
MyManagers.Buffers.Dispose(m_aliveIndexBuffer); m_aliveIndexBuffer = null;
MyManagers.Buffers.Dispose(m_deadListBuffer); m_deadListBuffer = null;
MyManagers.Buffers.Dispose(m_skippedParticleCountBuffer); m_skippedParticleCountBuffer = null;
MyManagers.Buffers.Dispose(m_particleBuffer); m_particleBuffer = null;
MyManagers.Buffers.Dispose(m_emitterConstantBuffer); m_emitterConstantBuffer = null;
MyManagers.Buffers.Dispose(m_emitterStructuredBuffer); m_emitterStructuredBuffer = null;
}
public void Dispose()
{
if ( indexReference != 0 )
{
indexReference--;
if ( indexReference == 0 )
{
indexBuffer.Dispose ();
indexBuffer = null;
if ( Effect != null )
{
if ( Effect is SpriteEffect )
Effect.Dispose ();
Effect = null;
}
}
}
if ( vertexBuffer != null )
{
vertexBuffer.Dispose ();
vertexBuffer = null;
}
}
