internal static unsafe void UpdateVertexBuffer(InstancingId id)
{
var info = id.Info;
if (info.VisibleCapacity == 0)
return;
fixed(byte *ptr = info.Data)
{
IVertexBuffer buffer = Data[id.Index].VB;
if (buffer == null)
{
Data[id.Index].VB = MyManagers.Buffers.CreateVertexBuffer(
info.DebugName, info.VisibleCapacity, info.Stride,
new IntPtr(ptr), SharpDX.Direct3D11.ResourceUsage.Dynamic);
}
else if (buffer.ElementCount < info.VisibleCapacity ||
buffer.Description.StructureByteStride != info.Stride)
{
MyManagers.Buffers.Resize(Data[id.Index].VB, info.VisibleCapacity, info.Stride, new IntPtr(ptr));
}
else
{
var mapping = MyMapping.MapDiscard(MyImmediateRC.RC, buffer);
mapping.WriteAndPosition(info.Data, info.VisibleCapacity * info.Stride);
mapping.Unmap();
}
}
}
internal unsafe void RecordCommands(MyRenderableProxy proxy, IVertexBuffer stream, int voxelMatId)
{
if (stream == null) return;
var foliageType = MyVoxelMaterials1.Table[voxelMatId].FoliageType;
MyMapping mapping = MyMapping.MapDiscard(RC, proxy.ObjectBuffer);
mapping.WriteAndPosition(ref proxy.NonVoxelObjectData);
mapping.WriteAndPosition(ref proxy.CommonObjectData);
mapping.Unmap();
RC.AllShaderStages.SetConstantBuffer(MyCommon.OBJECT_SLOT, proxy.ObjectBuffer);
RC.GeometryShader.Set(m_GS[foliageType]);
RC.PixelShader.Set(m_PS[foliageType]);
if (MyVoxelMaterials1.Table[voxelMatId].FoliageColorTextureArray != null)
{
RC.AllShaderStages.SetSrv(0, MyVoxelMaterials1.Table[voxelMatId].FoliageColorTextureArray);
RC.AllShaderStages.SetSrv(1, MyVoxelMaterials1.Table[voxelMatId].FoliageNormalTextureArray);
}
else
{
MyFileTextureManager texManager = MyManagers.FileTextures;
RC.AllShaderStages.SetSrv(0, texManager.GetTexture(MyVoxelMaterials1.Table[voxelMatId].FoliageArray_Texture, MyFileTextureEnum.COLOR_METAL, true));
RC.AllShaderStages.SetSrv(1, texManager.GetTexture(MyVoxelMaterials1.Table[voxelMatId].FoliageArray_NormalTexture, MyFileTextureEnum.NORMALMAP_GLOSS, true));
}
RC.SetVertexBuffer(0, stream);
RC.DrawAuto();
}
public void DrawVertexBuffer(IVertexBuffer<Vertex> buffer, int start, int length, PrimitiveType type, Sheet sheet)
{
shader.SetTexture("DiffuseTexture", sheet.Texture);
renderer.Device.SetBlendMode(BlendMode.Alpha);
shader.Render(() => renderer.DrawBatch(buffer, start, length, type));
renderer.Device.SetBlendMode(BlendMode.None);
}
private IVertexBuffer CreateVertexBuffer(ImDrawListPtr DrawList)
{
Vertex[] Verts = new Vertex[DrawList.VtxBuffer.Size];
for (int x = 0; x < DrawList.VtxBuffer.Size; x++)
{
Verts[x] = new Vertex
{
Location = new System.Numerics.Vector3(DrawList.VtxBuffer[x].pos, 0),
UV = DrawList.VtxBuffer[x].uv,
Color = Color.FromArgb((int)DrawList.VtxBuffer[x].col)
};
}
ushort[] Ind = new ushort[DrawList.IdxBuffer.Size];
for (int x = 0; x < DrawList.IdxBuffer.Size; x++)
{
Ind[x] = DrawList.IdxBuffer[x];
}
if (VertexBuffer == null)
{
VertexBuffer = IEngine.Instance.Renderer.RendererResourceFactory.CreateVertexBuffer();
}
VertexBuffer.SetVertexData(Verts, Ind);
return(VertexBuffer);
}
public void Resize(IVertexBuffer buffer, int newElements, int newByteStride = -1, IntPtr?newData = null)
{
MyRenderProxy.Assert(newElements > 0);
MyRenderProxy.Assert(newByteStride > 0 || newByteStride == -1);
ResizeInternal(buffer as MyVertexBuffer, newElements, newByteStride, newData);
}
internal void Dispose()
{
if (VB != null)
MyManagers.Buffers.Dispose(VB); VB = null;
m_capacity = 0;
}
public TerrainRenderer(World world, WorldRenderer wr)
{
this.world = world;
this.map = world.Map;
var 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));
var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];
terrainSheet = tileMapping[map.MapTiles.Value[map.Bounds.Left, map.Bounds.Top]].sheet;
int nv = 0;
var terrainPalette = wr.Palette("terrain").Index;
for( int j = map.Bounds.Top; j < map.Bounds.Bottom; j++ )
for( int i = map.Bounds.Left; i < map.Bounds.Right; i++ )
{
var tile = tileMapping[map.MapTiles.Value[i, j]];
// TODO: move GetPaletteIndex out of the inner loop.
Util.FastCreateQuad(vertices, Game.CellSize * new float2(i, j), tile, terrainPalette, nv, tile.size);
nv += 4;
if (tileMapping[map.MapTiles.Value[i, j]].sheet != terrainSheet)
throw new InvalidOperationException("Terrain sprites span multiple sheets");
}
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer( vertices.Length );
vertexBuffer.SetData( vertices, nv );
}
internal static void Init()
{
//MyRender11.RegisterSettingsChangedListener(new OnSettingsChangedDelegate(RecreateShadersForSettings));
m_screenVertexShader = MyShaders.CreateVs("Debug/DebugBaseColor.hlsl");
m_baseColorShader = MyShaders.CreatePs("Debug/DebugBaseColor.hlsl");
m_albedoShader = MyShaders.CreatePs("Debug/DebugAlbedo.hlsl");
m_normalShader = MyShaders.CreatePs("Debug/DebugNormal.hlsl");
m_normalViewShader = MyShaders.CreatePs("Debug/DebugNormalView.hlsl");
m_glossinessShader = MyShaders.CreatePs("Debug/DebugGlossiness.hlsl");
m_metalnessShader = MyShaders.CreatePs("Debug/DebugMetalness.hlsl");
m_aoShader = MyShaders.CreatePs("Debug/DebugAmbientOcclusion.hlsl");
m_emissiveShader = MyShaders.CreatePs("Debug/DebugEmissive.hlsl");
m_ambientDiffuseShader = MyShaders.CreatePs("Debug/DebugAmbientDiffuse.hlsl");
m_ambientSpecularShader = MyShaders.CreatePs("Debug/DebugAmbientSpecular.hlsl");
m_edgeDebugShader = MyShaders.CreatePs("Debug/DebugEdge.hlsl");
m_shadowsDebugShader = MyShaders.CreatePs("Debug/DebugCascadesShadow.hlsl");
m_NDotLShader = MyShaders.CreatePs("Debug/DebugNDotL.hlsl");
m_LODShader = MyShaders.CreatePs("Debug/DebugLOD.hlsl");
m_depthShader = MyShaders.CreatePs("Debug/DebugDepth.hlsl");
m_depthReprojectionShader = MyShaders.CreateCs("Debug/DebugDepthReprojection.hlsl");
m_stencilShader = MyShaders.CreatePs("Debug/DebugStencil.hlsl");
m_rtShader = MyShaders.CreatePs("Debug/DebugRt.hlsl");
m_blitTextureShader = MyShaders.CreatePs("Debug/DebugBlitTexture.hlsl");
m_blitTexture3DShader = MyShaders.CreatePs("Debug/DebugBlitTexture3D.hlsl");
m_blitTextureArrayShader = MyShaders.CreatePs("Debug/DebugBlitTextureArray.hlsl");
m_inputLayout = MyShaders.CreateIL(m_screenVertexShader.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION2, MyVertexInputComponentType.TEXCOORD0));
m_quadBuffer = MyManagers.Buffers.CreateVertexBuffer(
"MyDebugRenderer quad", 6, MyVertexFormatPosition2Texcoord.STRIDE,
usage: ResourceUsage.Dynamic);
}
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);
}
internal void AllocateStreamOutBuffer(int vertexStride)
{
if (m_allocationSize == 0)
{
Dispose();
return;
}
if (m_stream != null)
{
if (m_allocationSize < m_stream.ElementCount)
{
return;
}
else
{
Dispose();
}
}
// padding to some power of 2
m_allocationSize = ((m_allocationSize + 511) / 512) * 512;
const int maxAlloc = 5 * 1024 * 1024;
m_allocationSize = Math.Min(maxAlloc, m_allocationSize);
Debug.Assert(m_stream == null);
m_stream = MyManagers.Buffers.CreateVertexBuffer("MyFoliageStream", m_allocationSize, vertexStride, isStreamOutput: true);
}
public void SetVertexBuffer(IVertexBuffer vertices)
{
var index = _vertices.Count;
_vertices.Add(vertices);
_buffer.Add(new GraphicsStateChange(CommandTypes.VertexBuffer, index));
}
/// <summary>
/// Updates the vertex buffer object from the <see cref="Vertices"/> array.
/// </summary>
/// <typeparam name="TVertex">The type of vertex buffer to use.</typeparam>
/// <param name="transform">Function that transforms the vertex array data to a interleaved struct format.</param>
private void UpdateVertices <TVertex>(
Func <Vector3, Vector3, Color4, TVertex> transform
) where TVertex : struct, IVertexData
{
// if the type of the vertex data has changed we need to create a new buffer
if (m_vertexBuffer != null && m_vertexBuffer.GetType() != typeof(VertexBuffer <TVertex>))
{
m_vertexBuffer.Dispose();
m_vertexBuffer = null;
}
// create vertex buffer if needed
if (m_vertexBuffer == null)
{
m_vertexBuffer = new VertexBuffer <TVertex>(m_vertices.Length);
}
// copy the vertices into the buffer
VertexBuffer <TVertex> buffer = m_vertexBuffer as VertexBuffer <TVertex>;
buffer.Clear();
int offset;
TVertex[] vertexArray = buffer.WriteDirectly(m_vertices.Length, out offset);
for (int i = 0; i < m_vertices.Length; i++)
{
vertexArray[i] = transform(m_vertices[i], m_normals[i], m_colors[i]);
}
// upload to the GPU
buffer.BufferData();
m_vertexBufferDirty = false;
}
private IVertexBuffer BindVertexBuffer(DrawList drawList)
{
Watertight.Math.Vertex[] Verts = new Math.Vertex[drawList.VertexBuffer.Count];
ushort[] Indicies = new ushort[drawList.IndexBuffer.Count];
for (int x = 0; x < drawList.VertexBuffer.Count; x++)
{
FlowUI.Draw.Vertex FlowVtx = drawList.VertexBuffer.ElementAt(x);
Verts[x] = new Math.Vertex
{
Location = new Vector3(FlowVtx.Pos, 0),
Color = FlowVtx.Color,
UV = FlowVtx.UV
};
}
for (int i = 0; i < drawList.IndexBuffer.Count; i++)
{
Indicies[i] = drawList.IndexBuffer.ElementAt(i);
}
if (InternalVertexBuffer == null)
{
InternalVertexBuffer = IEngine.Instance.Renderer.RendererResourceFactory.CreateVertexBuffer();
}
InternalVertexBuffer.SetVertexData(Verts, Indicies);
return(InternalVertexBuffer);
}
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 static void Init()
{
//MyRender11.RegisterSettingsChangedListener(new OnSettingsChangedDelegate(RecreateShadersForSettings));
m_screenVertexShader = MyShaders.CreateVs("Debug/DebugBaseColor.hlsl");
m_baseColorShader = MyShaders.CreatePs("Debug/DebugBaseColor.hlsl");
m_albedoShader = MyShaders.CreatePs("Debug/DebugAlbedo.hlsl");
m_normalShader = MyShaders.CreatePs("Debug/DebugNormal.hlsl");
m_normalViewShader = MyShaders.CreatePs("Debug/DebugNormalView.hlsl");
m_glossinessShader = MyShaders.CreatePs("Debug/DebugGlossiness.hlsl");
m_metalnessShader = MyShaders.CreatePs("Debug/DebugMetalness.hlsl");
m_aoShader = MyShaders.CreatePs("Debug/DebugAmbientOcclusion.hlsl");
m_emissiveShader = MyShaders.CreatePs("Debug/DebugEmissive.hlsl");
m_ambientDiffuseShader = MyShaders.CreatePs("Debug/DebugAmbientDiffuse.hlsl");
m_ambientSpecularShader = MyShaders.CreatePs("Debug/DebugAmbientSpecular.hlsl");
m_edgeDebugShader = MyShaders.CreatePs("Debug/DebugEdge.hlsl");
m_shadowsDebugShader = MyShaders.CreatePs("Debug/DebugCascadesShadow.hlsl");
m_NDotLShader = MyShaders.CreatePs("Debug/DebugNDotL.hlsl");
m_LODShader = MyShaders.CreatePs("Debug/DebugLOD.hlsl");
m_depthShader = MyShaders.CreatePs("Debug/DebugDepth.hlsl");
m_stencilShader = MyShaders.CreatePs("Debug/DebugStencil.hlsl");
m_rtShader = MyShaders.CreatePs("Debug/DebugRt.hlsl");
m_blitTextureShader = MyShaders.CreatePs("Debug/DebugBlitTexture.hlsl");
m_blitTexture3DShader = MyShaders.CreatePs("Debug/DebugBlitTexture3D.hlsl");
m_blitTextureArrayShader = MyShaders.CreatePs("Debug/DebugBlitTextureArray.hlsl");
m_inputLayout = MyShaders.CreateIL(m_screenVertexShader.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION2, MyVertexInputComponentType.TEXCOORD0));
m_quadBuffer = MyManagers.Buffers.CreateVertexBuffer(
"MyDebugRenderer quad", 6, MyVertexFormatPosition2Texcoord.STRIDE,
usage: ResourceUsage.Dynamic);
}
public TerrainPatchBuilder( )
{
int numVertices = 0;
for ( int level = 0; level < MaxLodLevels; ++level )
{
numVertices += LevelPoolSize( level ) * NumberOfLevelVertices( level );
}
VertexBufferFormat format = new VertexBufferFormat( );
format.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
format.Add( VertexFieldSemantic.Normal, VertexFieldElementTypeId.Float32, 3 );
GraphicsLog.Info( "Allocating terrain patch builder VBO: {0} vertices in format {1}", numVertices, format );
m_Buffer = Graphics.Factory.CreateVertexBuffer( );
m_Buffer.Create( format, numVertices );
int curVertexIndex = 0;
for ( int level = 0; level < MaxLodLevels; ++level )
{
Lod newLod = new Lod( );
m_LodLevels[ level ] = newLod;
int numLevelVertices = NumberOfLevelVertices( level );
int poolSize = LevelPoolSize( level );
for ( int poolIndex = 0; poolIndex < poolSize; ++poolIndex )
{
newLod.VbPool.Add( curVertexIndex );
curVertexIndex += numLevelVertices;
}
// NOTE: BP: BABY P SAYS HELLO
}
}
/// <summary>
/// Override this to prepare the render instruction to render queue
/// </summary>
/// <param name="renderer"></param>
/// <param name="node"></param>
/// <param name="entity"></param>
public override void PrepareRenderQueue(Renderer renderer, Node node, Entity entity)
{
//Bind the graphics pipeline
var lines = (Lines)entity;
var cl = renderer.GetCommandList(RenderQueueGroupId.Geometries);
cl.BindPipeline(pipeline);
//Bind buffer
IVertexBuffer vb = GetVertexBuffer(renderer, lines);
lines.Synchronize(vb);
cl.BindVertexBuffer(vb);
//Prepare the world view projection matrix
var wvp = renderer.Variables.MatrixWorldViewProjection;
ms.SetLength(0);
w.Write(wvp);
cl.PushConstants(ShaderStage.VertexShader, ms.GetBuffer(), (int)ms.Length);
//Draw the object
cl.Draw();
}
/// <summary>
/// Adds the specified vertex buffer.
/// </summary>
/// <param name="vertexBuffer">The vertex buffer.</param>
/// <exception cref="ArgumentNullException"></exception>
public void Add(IVertexBuffer vertexBuffer)
{
if (vertexBuffer?.Layout == null)
{
throw new ArgumentNullException();
}
Bind();
vertexBuffer.Bind();
uint index = 0;
foreach (var element in vertexBuffer.Layout.Elements)
{
Gl.EnableVertexAttribArray(index);
Gl.VertexAttribPointer(
index,
element.GetCount(),
ToOpenGLDataType(element.Type),
element.Normalized,
vertexBuffer.Layout.Stride,
new IntPtr(element.Offset)
);
index++;
}
_vertexBuffers.Add(vertexBuffer);
}
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;
}
internal unsafe void RecordCommands(MyRenderableProxy proxy, IVertexBuffer stream, int voxelMatId)
{
if (stream == null)
{
return;
}
var foliageType = MyVoxelMaterials1.Table[voxelMatId].FoliageType;
MyMapping mapping = MyMapping.MapDiscard(RC, proxy.ObjectBuffer);
mapping.WriteAndPosition(ref proxy.NonVoxelObjectData);
mapping.WriteAndPosition(ref proxy.CommonObjectData);
mapping.Unmap();
RC.AllShaderStages.SetConstantBuffer(MyCommon.OBJECT_SLOT, proxy.ObjectBuffer);
RC.GeometryShader.Set(m_GS[foliageType]);
RC.PixelShader.Set(m_PS[foliageType]);
if (MyVoxelMaterials1.Table[voxelMatId].FoliageColorTextureArray != null)
{
RC.AllShaderStages.SetSrv(0, MyVoxelMaterials1.Table[voxelMatId].FoliageColorTextureArray);
RC.AllShaderStages.SetSrv(1, MyVoxelMaterials1.Table[voxelMatId].FoliageNormalTextureArray);
}
else
{
MyFileTextureManager texManager = MyManagers.FileTextures;
RC.AllShaderStages.SetSrv(0, texManager.GetTexture(MyVoxelMaterials1.Table[voxelMatId].FoliageArray_Texture, MyFileTextureEnum.COLOR_METAL, true));
RC.AllShaderStages.SetSrv(1, texManager.GetTexture(MyVoxelMaterials1.Table[voxelMatId].FoliageArray_NormalTexture, MyFileTextureEnum.NORMALMAP_GLOSS, true));
}
RC.SetVertexBuffer(0, stream);
RC.DrawAuto();
}
public void DrawVertexBuffer(IVertexBuffer <Vertex> buffer, int start, int length, PrimitiveType type, Sheet sheet)
{
shader.SetTexture("DiffuseTexture", sheet.GetTexture());
renderer.Device.SetBlendMode(BlendMode.Alpha);
shader.Render(() => renderer.DrawBatch(buffer, start, length, type));
renderer.Device.SetBlendMode(BlendMode.None);
}
public TerrainSpriteLayer(World world, WorldRenderer wr, Sheet sheet, BlendMode blendMode, PaletteReference palette, bool restrictToBounds)
{
worldRenderer = wr;
this.restrictToBounds = restrictToBounds;
Sheet = sheet;
BlendMode = blendMode;
paletteIndex = palette.TextureIndex;
map = world.Map;
rowStride = 4 * map.MapSize.X;
vertices = new Vertex[rowStride * map.MapSize.Y];
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length);
emptySprite = new Sprite(sheet, Rectangle.Empty, TextureChannel.Alpha);
wr.PaletteInvalidated += () =>
{
paletteIndex = palette.TextureIndex;
// Everything in the layer uses the same palette,
// so we can fix the indices in one pass
for (var i = 0; i < vertices.Length; i++)
{
var v = vertices[i];
vertices[i] = new Vertex(v.X, v.Y, v.Z, v.U, v.V, paletteIndex, v.C);
}
for (var row = 0; row < map.MapSize.Y; row++)
{
dirtyRows.Add(row);
}
};
}
public Renderer(GraphicSettings graphicSettings, ServerSettings serverSettings)
{
var resolution = GetResolution(graphicSettings);
var rendererName = serverSettings.Dedicated ? "Null" : graphicSettings.Renderer;
var rendererPath = Platform.ResolvePath(".", "OpenRA.Platforms." + rendererName + ".dll");
Device = CreateDevice(Assembly.LoadFile(rendererPath), resolution.Width, resolution.Height, graphicSettings.Mode);
if (!serverSettings.Dedicated)
{
TempBufferSize = graphicSettings.BatchSize;
SheetSize = graphicSettings.SheetSize;
}
WorldSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("shp"));
WorldRgbaSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("rgba"));
WorldRgbaColorRenderer = new RgbaColorRenderer(this, Device.CreateShader("color"));
WorldVoxelRenderer = new VoxelRenderer(this, Device.CreateShader("vxl"));
RgbaColorRenderer = new RgbaColorRenderer(this, Device.CreateShader("color"));
RgbaSpriteRenderer = new SpriteRenderer(this, Device.CreateShader("rgba"));
SpriteRenderer = new SpriteRenderer(this, Device.CreateShader("shp"));
tempBuffer = Device.CreateVertexBuffer(TempBufferSize);
}
public void Update(IVertexBuffer buffer, DataArray data)
{
var dxBuffer = graphicsDevice.Cast <VertexBuffer>(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 VertexBuffer 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);
}
}
internal unsafe static void Init()
{
m_cbCustomProjections = MyManagers.Buffers.CreateConstantBuffer("BilloardCustomProjections", sizeof(Matrix) * MAX_CUSTOM_PROJECTIONS_SIZE, usage: ResourceUsage.Dynamic);
m_vs = MyShaders.CreateVs("Transparent/Billboards.hlsl");
m_ps = MyShaders.CreatePs("Transparent/Billboards.hlsl");
m_psOIT = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("OIT", null) });
m_vsLit = MyShaders.CreateVs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("LIT_PARTICLE", null) });
m_psLit = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("LIT_PARTICLE", null) });
m_psLitOIT = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("LIT_PARTICLE", null), new ShaderMacro("OIT", null) });
m_psAlphaCutout = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("ALPHA_CUTOUT", null) });
m_psAlphaCutoutAndLit = MyShaders.CreatePs("Transparent/Billboards.hlsl",
new[] { new ShaderMacro("ALPHA_CUTOUT", null), new ShaderMacro("LIT_PARTICLE", null) });
m_psAlphaCutoutOIT = MyShaders.CreatePs("Transparent/Billboards.hlsl",
new[] { new ShaderMacro("ALPHA_CUTOUT", null), new ShaderMacro("OIT", null) });
m_psAlphaCutoutAndLitOIT = MyShaders.CreatePs("Transparent/Billboards.hlsl",
new[] { new ShaderMacro("ALPHA_CUTOUT", null), new ShaderMacro("LIT_PARTICLE", null), new ShaderMacro("OIT", null) });
m_psDebugUniformAccum = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("DEBUG_UNIFORM_ACCUM", null) });
m_psDebugUniformAccumOIT = MyShaders.CreatePs("Transparent/Billboards.hlsl", new[] { new ShaderMacro("DEBUG_UNIFORM_ACCUM", null), new ShaderMacro("OIT", null) });
m_inputLayout = MyShaders.CreateIL(m_vs.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3, MyVertexInputComponentType.TEXCOORD0_H));
InitBillboardsIndexBuffer();
m_VB = MyManagers.Buffers.CreateVertexBuffer("MyBillboardRenderer", MAX_BILLBOARDS_SIZE * 4, sizeof(MyVertexFormatPositionTextureH), usage: ResourceUsage.Dynamic);
var stride = sizeof(MyBillboardData);
m_SB = MyManagers.Buffers.CreateSrv(
"MyBillboardRenderer", MAX_BILLBOARDS_SIZE, stride,
usage: ResourceUsage.Dynamic);
m_atlas = new MyTextureAtlas("Textures\\Particles\\", "Textures\\Particles\\ParticlesAtlas.tai");
}
private unsafe void InitVertexBuffer(int numberOfCascades)
{
DestroyVertexBuffer();
m_cascadesBoundingsVertices = MyManagers.Buffers.CreateVertexBuffer(
"MyShadowCascadesPostProcess", 8 * numberOfCascades, sizeof(Vector3),
usage: ResourceUsage.Dynamic);
}
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 TerrainSpriteLayer(World world, WorldRenderer wr, Sheet sheet, BlendMode blendMode, PaletteReference palette, bool restrictToBounds)
{
worldRenderer = wr;
this.restrictToBounds = restrictToBounds;
Sheet = sheet;
BlendMode = blendMode;
paletteIndex = palette.TextureIndex;
map = world.Map;
rowStride = 4 * map.MapSize.X;
vertices = new Vertex[rowStride * map.MapSize.Y];
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length);
emptySprite = new Sprite(sheet, Rectangle.Empty, TextureChannel.Alpha);
wr.PaletteInvalidated += () =>
{
paletteIndex = palette.TextureIndex;
// Everything in the layer uses the same palette,
// so we can fix the indices in one pass
for (var i = 0; i < vertices.Length; i++)
{
var v = vertices[i];
vertices[i] = new Vertex(v.X, v.Y, v.Z, v.U, v.V, paletteIndex, v.C);
}
for (var row = 0; row < map.MapSize.Y; row++)
dirtyRows.Add(row);
};
}
internal static void Init()
{
m_VSCopy = MyShaders.CreateVs("Postprocess/PostprocessCopy.hlsl");
{
m_VBFullscreen = MyManagers.Buffers.CreateVertexBuffer(
"MyScreenPass.VBFullscreen", 4, VRageRender.Vertex.MyVertexFormatPositionTextureH.STRIDE,
usage: ResourceUsage.Dynamic);
m_vbData[0] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(-1, -1, 0),
new VRageMath.PackedVector.HalfVector2(0, 1f));
m_vbData[1] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(-1, 1, 0),
new VRageMath.PackedVector.HalfVector2(0, 0));
m_vbData[2] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(1, -1, 0),
new VRageMath.PackedVector.HalfVector2(1, 1f));
m_vbData[3] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(1, 1, 0),
new VRageMath.PackedVector.HalfVector2(1, 0f));
MyMapping mapping = MyMapping.MapDiscard(RC, m_VBFullscreen);
mapping.WriteAndPosition(m_vbData, 4);
mapping.Unmap();
}
{
m_VBLeftPart = MyManagers.Buffers.CreateVertexBuffer(
"MyVRScreenPass.VBLeftPart", 4, VRageRender.Vertex.MyVertexFormatPositionTextureH.STRIDE,
usage: ResourceUsage.Dynamic);
m_vbData[0] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(-1, -1, 0),
new VRageMath.PackedVector.HalfVector2(0, 1));
m_vbData[1] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(-1, 1, 0),
new VRageMath.PackedVector.HalfVector2(0, 0));
m_vbData[2] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(0, -1, 0),
new VRageMath.PackedVector.HalfVector2(0.5f, 1));
m_vbData[3] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(0, 1, 0),
new VRageMath.PackedVector.HalfVector2(0.5f, 0f));
MyMapping mapping = MyMapping.MapDiscard(RC, m_VBLeftPart);
mapping.WriteAndPosition(m_vbData, 4);
mapping.Unmap();
}
{
m_VBRightPart = MyManagers.Buffers.CreateVertexBuffer(
"MyVRScreenPass.VBRightPart", 4, VRageRender.Vertex.MyVertexFormatPositionTextureH.STRIDE,
usage: ResourceUsage.Dynamic);
m_vbData[0] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(0, -1, 0),
new VRageMath.PackedVector.HalfVector2(0.5f, 1));
m_vbData[1] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(0, 1, 0),
new VRageMath.PackedVector.HalfVector2(0.5f, 0));
m_vbData[2] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(1, -1, 0),
new VRageMath.PackedVector.HalfVector2(1, 1));
m_vbData[3] = new VRageRender.Vertex.MyVertexFormatPositionTextureH(new Vector3(1, 1, 0),
new VRageMath.PackedVector.HalfVector2(1, 0));
MyMapping mapping = MyMapping.MapDiscard(RC, m_VBRightPart);
mapping.WriteAndPosition(m_vbData, 4);
mapping.Unmap();
}
// just some shader bytecode is selected
m_IL = MyShaders.CreateIL(m_VSCopy.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3, MyVertexInputComponentType.TEXCOORD0_H));
}
public void RefreshBuffer()
{
if (vertexBuffer != null)
vertexBuffer.Dispose();
vertexBuffer = Game.Renderer.CreateVertexBuffer(totalVertexCount);
vertexBuffer.SetData(vertices.SelectMany(v => v).ToArray(), totalVertexCount);
cachedVertexCount = totalVertexCount;
}
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 );
}
public SeaMesh( float width, float depth )
{
VertexBufferFormat vbFormat = new VertexBufferFormat( );
vbFormat.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
vbFormat.Add( VertexFieldSemantic.Normal, VertexFieldElementTypeId.Float32, 3 );
m_Vertices = Graphics.Factory.CreateVertexBuffer( );
}
public PartialModel(IVertexBuffer vertexBuffer, int startIndex, int startVertex, int indexCount, PrimitiveType primitiveType)
{
VertexBuffer = vertexBuffer;
StartIndex = startIndex;
StartVertex = startVertex;
IndexCount = indexCount;
PrimitiveType = primitiveType;
}
public void Dispose()
{
if (m_stream != null)
{
MyManagers.Buffers.Dispose(m_stream);
m_stream = null;
}
}
public void DrawVertexBuffer(IVertexBuffer <Vertex> buffer, int start, int length, PrimitiveType type, Sheet sheet, BlendMode blendMode)
{
shader.SetTexture("Texture0", sheet.GetTexture());
renderer.Context.SetBlendMode(blendMode);
shader.PrepareRender();
renderer.DrawBatch(buffer, start, length, type);
renderer.Context.SetBlendMode(BlendMode.None);
}
public void DrawBatch <T>(IVertexBuffer <T> vertices,
int firstVertex, int numVertices, PrimitiveType type)
where T : struct
{
vertices.Bind();
Device.DrawPrimitives(type, firstVertex, numVertices);
PerfHistory.Increment("batches", 1);
}
public unsafe MyDebugMesh(MyRenderMessageDebugDrawMesh message)
{
vbuffer = MyManagers.Buffers.CreateVertexBuffer(
"MyDebugMesh", message.VertexCount, sizeof(MyVertexFormatPositionColor),
usage: ResourceUsage.Dynamic);
Update(message);
}
public ThreadedVertexBuffer(ThreadedGraphicsContext device, IVertexBuffer <Vertex> vertexBuffer)
{
this.device = device;
bind = vertexBuffer.Bind;
setData1 = tuple => { var t = (Tuple <Vertex[], int>)tuple; vertexBuffer.SetData(t.Item1, t.Item2); device.ReturnVertices(t.Item1); };
setData2 = tuple => { var t = (Tuple <IntPtr, int, int>)tuple; vertexBuffer.SetData(t.Item1, t.Item2, t.Item3); return(null); };
dispose = vertexBuffer.Dispose;
}
public void Dispose()
{
if (m_stream != null)
{
MyManagers.Buffers.Dispose(m_stream);
m_stream = null;
}
}
/// <summary>
/// Destroys current vertex buffer
/// </summary>
private void DestroyVertices( )
{
if ( m_Vertices != null )
{
m_Vertices.Dispose( );
m_Vertices = null;
}
}
void IManagerDevice.OnDeviceReset()
{
MyManagers.Buffers.Dispose(m_vertexBuffer);
m_vertexBuffer = CreateVertexBuffer();
MyManagers.Buffers.Dispose(m_indexBuffer);
m_indexBuffer = CreateIndexBuffer();
}
/// <summary>
/// Move the managed data to GPU's memory
/// </summary>
/// <param name="buf"></param>
public void Synchronize(IVertexBuffer buf)
{
if (dirty)
{
buf.LoadData(lines.ToArray());
dirty = false;
}
}
internal void Close()
{
if (vbuffer != null)
{
MyManagers.Buffers.Dispose(vbuffer);
}
vbuffer = null;
}
public unsafe MyDebugMesh(MyRenderMessageDebugDrawMesh message)
{
vbuffer = MyManagers.Buffers.CreateVertexBuffer(
"MyDebugMesh", message.VertexCount, sizeof(MyVertexFormatPositionColor),
usage: ResourceUsage.Dynamic);
Update(message);
}
internal void AllocateStreamOutBuffer(int vertexStride)
{
Dispose();
// padding to some power of 2
m_allocationSize = ((m_allocationSize + 511) / 512) * 512;
const int maxAlloc = 5 * 1024 * 1024;
m_allocationSize = Math.Min(maxAlloc, m_allocationSize);
Debug.Assert(m_stream == null);
m_stream = MyManagers.Buffers.CreateVertexBuffer("MyFoliageStream", m_allocationSize, vertexStride, isStreamOutput: true);
}
//internal static void CreateInputLayout(byte[] bytecode)
//{
// m_inputLayout = MyVertexInputLayout.CreateLayout(MyVertexInputLayout.Empty().Append(MyVertexInputComponentType.POSITION3).Append(MyVertexInputComponentType.COLOR4), bytecode);
//}
internal unsafe static void Init()
{
m_currentBufferSize = 100000;
m_VB = MyManagers.Buffers.CreateVertexBuffer(
"MyPrimitivesRenderer", m_currentBufferSize, sizeof(MyVertexFormatPositionColor),
usage: ResourceUsage.Dynamic);
m_vs = MyShaders.CreateVs("Primitives/Primitives.hlsl");
m_ps = MyShaders.CreatePs("Primitives/Primitives.hlsl");
m_inputLayout = MyShaders.CreateIL(m_vs.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION3, MyVertexInputComponentType.COLOR4));
}
private Terrain(IOpenGL33 gl, IVertexArray vertexArray, IVertexBuffer vertexBuffer, IElementArray elementBuffer, TerrainShader shader)
{
_gl = gl;
_vertexArray = vertexArray;
_vertexBuffer = vertexBuffer;
_elementBuffer = elementBuffer;
_shader = shader;
Model = Matrix4f.Identity;
View = Matrix4f.Identity;
Projection = Matrix4f.Identity;
Diffuse = new Vector4f(Color.DodgerBlue.R / 255f, Color.DodgerBlue.G / 255f, Color.DodgerBlue.B / 255f, 1f);
}
private static void InitInternal(Vector2[] vertsForMask)
{
m_VB = MyManagers.Buffers.CreateVertexBuffer(
"MyStereoStencilMask.VB", vertsForMask.Length, MyVertexFormat2DPosition.STRIDE,
usage: ResourceUsage.Dynamic);
MyMapping mapping = MyMapping.MapDiscard(RC, m_VB);
mapping.WriteAndPosition(vertsForMask, vertsForMask.Length);
mapping.Unmap();
m_vs = MyShaders.CreateVs("Stereo/StereoStencilMask.hlsl");
m_ps = MyShaders.CreatePs("Stereo/StereoStencilMask.hlsl");
m_il = MyShaders.CreateIL(m_vs.BytecodeId, MyVertexLayouts.GetLayout(MyVertexInputComponentType.POSITION2));
}
public PatchGrid( Terrain terrain, int gridWidth, int gridHeight )
{
int highestRes = Patch.GetLevelResolution( Patch.HighestDetailLod );
highestRes *= highestRes;
VertexBufferFormat format = new VertexBufferFormat( );
format.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
m_Vb = RbGraphics.Factory.CreateVertexBuffer( );
m_Vb.Create( format, gridWidth * gridHeight * highestRes );
m_Patches = new Patch[ gridWidth, gridHeight ];
float z = -PatchDepth * ( gridHeight / 2 );
float xInc = PatchWidth;
float zInc = PatchDepth;
float maxWidth = gridWidth * PatchWidth;
float maxHeight = gridWidth * PatchDepth;
terrain.SetTerrainArea( maxWidth, maxHeight );
int vbOffset = 0;
for ( int row = 0; row < gridHeight; ++row, z += zInc )
{
float x = -PatchWidth * ( gridWidth / 2 );
for ( int col = 0; col < gridWidth; ++col, x += xInc )
{
Color c = ( ( col + row ) % 2 ) == 0 ? Color.Black : Color.White;
m_Patches[ col, row ] = new Patch( terrain, vbOffset, x, z, PatchWidth, PatchDepth, c );
vbOffset += highestRes;
}
}
int maxCol = gridWidth - 1;
int maxRow = gridHeight - 1;
for ( int row = 0; row < gridHeight; ++row )
{
for ( int col = 0; col < gridWidth; ++col )
{
Patch left = ( col == 0 ) ? null : ( m_Patches[ col - 1, row ] );
Patch right = ( col == maxCol ) ? null : ( m_Patches[ col + 1, row ] );
Patch up = ( row == 0 ) ? null : ( m_Patches[ col, row - 1] );
Patch down = ( row == maxRow ) ? null : ( m_Patches[ col, row + 1 ] );
m_Patches[ col, row ].Link( left, right, up, down );
}
}
}
/// <summary>
/// Default constructor
/// </summary>
public TerrainPatchVertices( )
{
VertexBufferFormat format = new VertexBufferFormat( );
format.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
format.Add( VertexFieldSemantic.Normal, VertexFieldElementTypeId.Float32, 3 );
format.Add( VertexFieldSemantic.Texture0, VertexFieldElementTypeId.Float32, 2 );
format.Add( VertexFieldSemantic.Texture1, VertexFieldElementTypeId.Float32, 2 );
GraphicsLog.Info( "Creating terrain patch vertex pool using format {0}", format );
m_Vb = Graphics.Factory.CreateVertexBuffer( );
m_Vb.Create( format, TerrainPatchConstants.PatchTotalVertexCount * PoolSize );
Clear( );
}
public QuadPatchVertices( )
{
VertexBufferFormat format = new VertexBufferFormat( );
format.Add( VertexFieldSemantic.Position, VertexFieldElementTypeId.Float32, 3 );
m_Vb = Graphics.Factory.CreateVertexBuffer( );
m_Vb.Create( format, QuadPatch.PatchResolution * QuadPatch.PatchResolution * PoolSize );
int vertexIndex = 0;
for ( int i = 0; i < PoolSize; ++i )
{
m_FreeList.Add( vertexIndex );
vertexIndex += QuadPatch.PatchResolution * QuadPatch.PatchResolution;
}
}
internal override void Construct()
{
base.Construct();
Type = MyActorComponentEnum.Instancing;
MyUtils.Init(ref m_owners);
m_owners.Clear();
MyUtils.Init(ref m_ID);
m_ID.Clear();
VB = null;
m_input = MyVertexInputLayout.Empty;
m_stride = -1;
m_type = MyRenderInstanceBufferType.Invalid;
m_capacity = -1;
}
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 TerrainSpriteLayer(World world, WorldRenderer wr, Sheet sheet, BlendMode blendMode, PaletteReference palette, bool restrictToBounds)
{
worldRenderer = wr;
this.restrictToBounds = restrictToBounds;
Sheet = sheet;
BlendMode = blendMode;
this.palette = palette;
map = world.Map;
rowStride = 6 * map.MapSize.X;
vertices = new Vertex[rowStride * map.MapSize.Y];
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length);
emptySprite = new Sprite(sheet, Rectangle.Empty, TextureChannel.Alpha);
wr.PaletteInvalidated += UpdatePaletteIndices;
}
internal unsafe static void Init()
{
m_vs = MyShaders.CreateVs("Primitives/Sprites.hlsl");
m_ps = MyShaders.CreatePs("Primitives/Sprites.hlsl");
m_inputLayout = MyShaders.CreateIL(m_vs.BytecodeId, MyVertexLayouts.GetLayout(
new MyVertexInputComponent(MyVertexInputComponentType.CUSTOM_HALF4_0, MyVertexInputComponentFreq.PER_INSTANCE),
new MyVertexInputComponent(MyVertexInputComponentType.CUSTOM_HALF4_1, MyVertexInputComponentFreq.PER_INSTANCE),
new MyVertexInputComponent(MyVertexInputComponentType.CUSTOM_HALF4_2, MyVertexInputComponentFreq.PER_INSTANCE),
new MyVertexInputComponent(MyVertexInputComponentType.COLOR4, MyVertexInputComponentFreq.PER_INSTANCE)
));
m_currentBufferSize = 100000;
m_VB = MyManagers.Buffers.CreateVertexBuffer(
"MySpritesRenderer", m_currentBufferSize, sizeof(MyVertexFormatSpritePositionTextureRotationColor),
usage: ResourceUsage.Dynamic);
m_contextsStack.Add(new MySpritesContext());
}
public TerrainRenderer(World world, WorldRenderer wr)
{
this.world = world;
this.map = world.Map;
var terrainPalette = wr.Palette("terrain").Index;
var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];
int nv = 0;
for (var j = map.Bounds.Top; j < map.Bounds.Bottom; j++)
for (var i = map.Bounds.Left; i < map.Bounds.Right; i++)
{
var tile = wr.Theater.TileSprite(map.MapTiles.Value[i, j]);
Util.FastCreateQuad(vertices, Game.CellSize * new float2(i, j), tile, terrainPalette, nv, tile.size);
nv += 4;
}
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length);
vertexBuffer.SetData(vertices, nv);
}
public TerrainRenderer(World world, WorldRenderer wr)
{
this.world = world;
this.map = world.Map;
var terrainPalette = wr.Palette("terrain").Index;
var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];
var nv = 0;
foreach (var cell in map.Cells)
{
var tile = wr.Theater.TileSprite(map.MapTiles.Value[cell]);
var pos = wr.ScreenPosition(map.CenterOfCell(cell)) - 0.5f * tile.size;
Util.FastCreateQuad(vertices, pos, tile, terrainPalette, nv, tile.size);
nv += 4;
}
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length);
vertexBuffer.SetData(vertices, nv);
}
internal SpriteBatch(
ISpriteSheet spriteSheet,
IShaderProgram shaderProgram,
IVertexArrayObject vao,
IVertexBuffer<VertexPositionColourTexture> vbo,
IDrawAdapter adapter)
{
spriteSheet.ThrowIfNull(nameof(spriteSheet));
this.spriteSheet = spriteSheet;
Debug.Assert(shaderProgram != null, $"{nameof(shaderProgram)} was null in SpriteBatch");
Debug.Assert(vao != null, $"{nameof(vao)} was null in SpriteBatch");
Debug.Assert(vbo != null, $"{nameof(vbo)} was null ins SpriteBatch");
Debug.Assert(adapter != null, $"{nameof(adapter)} was null in SpriteBatch");
this.shaderProgram = shaderProgram;
this.vao = vao;
this.vbo = vbo;
this.adapter = adapter;
Initialise();
}
public TerrainRenderer(World world, WorldRenderer wr)
{
worldRenderer = wr;
theater = wr.Theater;
map = world.Map;
mapTiles = map.MapTiles.Value;
terrainPaletteIndex = wr.Palette("terrain").TextureIndex;
rowStride = 4 * map.Bounds.Width;
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(rowStride * map.Bounds.Height);
UpdateMap();
map.MapTiles.Value.CellEntryChanged += UpdateCell;
map.MapHeight.Value.CellEntryChanged += UpdateCell;
wr.PaletteInvalidated += () =>
{
terrainPaletteIndex = wr.Palette("terrain").TextureIndex;
UpdateMap();
};
}
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 );
}
