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 ); }