stjr/UltimateZoneBuilder
0
0
Fork 0
mirror of https://git.do.srb2.org/STJr/UltimateZoneBuilder.git synced 2025-01-18 22:41:46 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Simplify code

Browse source
This commit is contained in:
Magnus Norddahl 2019-08-08 07:10:35 +02:00
parent e4b257a89a
commit 8f15e8d5e7
13 changed files with 104 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
Source/Core/Data/DataManager.cs
View file

@ -3425,7 +3425,7 @@ namespace CodeImp.DoomBuilder.Data
// Make custom rendertarget
const int cubemaptexsize = 1024;
Texture rendertarget = new Texture(cubemaptexsize, cubemaptexsize, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
Texture rendertarget = new Texture(cubemaptexsize, cubemaptexsize, 1, Format.A8R8G8B8);
// Start rendering
General.Map.Graphics.StartRendering(true, new Color4(), rendertarget, true);
@ -3453,7 +3453,7 @@ namespace CodeImp.DoomBuilder.Data
yscale *= 1.65f;
// Make cubemap texture
CubeTexture cubemap = new CubeTexture(cubemaptexsize, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
CubeTexture cubemap = new CubeTexture(cubemaptexsize, 1, Format.A8R8G8B8);
// Set render settings...
General.Map.Graphics.SetRenderState(RenderState.ZEnable, false);
@ -3653,7 +3653,7 @@ namespace CodeImp.DoomBuilder.Data
// sides[] must contain 6 square Po2 images in this order: North, East, South, West, Top, Bottom
private static CubeTexture MakeSkyBox(Bitmap[] sides, int targetsize, bool fliptop)
{
CubeTexture cubemap = new CubeTexture(targetsize, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
CubeTexture cubemap = new CubeTexture(targetsize, 1, Format.A8R8G8B8);
// Draw faces
sides[3].RotateFlip(RotateFlipType.Rotate90FlipNone);
@ -3679,21 +3679,7 @@ namespace CodeImp.DoomBuilder.Data
private static void DrawCubemapFace(CubeTexture texture, CubeMapFace face, Bitmap image)
{
DataRectangle rect = texture.LockRectangle(face, 0, LockFlags.None);
if(rect.Data.CanWrite)
{
BitmapData data = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
int len = Math.Abs(data.Stride) * image.Height;
rect.Data.WriteRange(data.Scan0, len);
image.UnlockBits(data);
}
else
{
General.ErrorLogger.Add(ErrorType.Error, "Skybox creation failed: CubeTexture is unwritable...");
}
texture.UnlockRectangle(face, 0);
texture.SetPixels(face, image);
}
private static Bitmap ResizeImage(Image image, int width, int height)
@ -3774,7 +3760,7 @@ namespace CodeImp.DoomBuilder.Data
// Classic skies textures can be NPo2 (and D3D Texture is resized to Po2 by default),
// so we need to explicitly specify the size
return Texture.FromStream(ms, (int) ms.Length, image.Size.Width, image.Size.Height, 0, Usage.None, Format.Unknown, Pool.Managed);
return Texture.FromStream(ms, (int) ms.Length, image.Size.Width, image.Size.Height, 0, Format.Unknown);
}
}

29
Source/Core/Data/ImageData.cs
View file

@ -474,11 +474,11 @@ namespace CodeImp.DoomBuilder.Data
memstream.Seek(0, SeekOrigin.Begin);
if(dynamictexture)
{
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, mipmaplevels, Usage.Dynamic, Format.A8R8G8B8, Pool.Default);
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, mipmaplevels, Format.A8R8G8B8);
}
else
{
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, mipmaplevels, Usage.None, Format.Unknown, Pool.Managed);
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, mipmaplevels, Format.Unknown);
}
memstream.Dispose();
@ -505,30 +505,7 @@ namespace CodeImp.DoomBuilder.Data
{
if((texture != null) && !texture.Disposed)
{
// Lock the bitmap and texture
BitmapData bmpdata = bitmap.LockBits(new Rectangle(0, 0, bitmap.Size.Width, bitmap.Size.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
DataRectangle texdata = texture.LockRectangle(0, LockFlags.Discard);
// Copy data
int* bp = (int*)bmpdata.Scan0.ToPointer();
int* tp = (int*)texdata.Data.DataPointer.ToPointer();
for(int y = 0; y < bmpdata.Height; y++)
{
for(int x = 0; x < bmpdata.Width; x++)
{
*tp = *bp;
bp++;
tp++;
}
// Skip extra data in texture
int extrapitch = (texdata.Pitch >> 2) - bmpdata.Width;
tp += extrapitch;
}
// Unlock
texture.UnlockRectangle(0);
bitmap.UnlockBits(bmpdata);
texture.SetPixels(bitmap);
}
}
}

31
Source/Core/GZBuilder/md3/ModelReader.cs
View file

@ -991,17 +991,17 @@ namespace CodeImp.DoomBuilder.GZBuilder.MD3
//mesh
Mesh mesh = new Mesh(polyIndecesList.Count / 3, vertList.Count, MeshFlags.Use32Bit | MeshFlags.IndexBufferManaged | MeshFlags.VertexBufferManaged, vertexElements);
using(DataStream stream = mesh.LockVertexBuffer(LockFlags.None))
using(DataStream stream = mesh.VertexBuffer.Lock(LockFlags.None))
{
stream.WriteRange(vertList.ToArray());
}
mesh.UnlockVertexBuffer();
mesh.VertexBuffer.Unlock();
using(DataStream stream = mesh.LockIndexBuffer(LockFlags.None))
using(DataStream stream = mesh.IndexBuffer.Lock(LockFlags.None))
{
stream.WriteRange(polyIndecesList.ToArray());
}
mesh.UnlockIndexBuffer();
mesh.IndexBuffer.Unlock();
//store in result
result.Meshes.Add(mesh);
@ -1177,7 +1177,7 @@ namespace CodeImp.DoomBuilder.GZBuilder.MD3
using(Bitmap bmp = CreateVoxelTexture(palette)) bmp.Save(memstream, ImageFormat.Bmp);
memstream.Seek(0, SeekOrigin.Begin);
Texture texture = Texture.FromStream(memstream, (int)memstream.Length, 64, 64, 0, Usage.None, Format.Unknown, Pool.Managed);
Texture texture = Texture.FromStream(memstream, (int)memstream.Length, 64, 64, 0, Format.Unknown);
memstream.Dispose();
// Add texture
@ -1189,11 +1189,11 @@ namespace CodeImp.DoomBuilder.GZBuilder.MD3
Mesh mesh = new Mesh(facescount, verts.Count, meshflags, vertexElements);
DataStream mstream = mesh.VertexBuffer.Lock(0, 0, LockFlags.None);
DataStream mstream = mesh.VertexBuffer.Lock(LockFlags.None);
mstream.WriteRange(verts.ToArray());
mesh.VertexBuffer.Unlock();
mstream = mesh.IndexBuffer.Lock(0, 0, LockFlags.None);
mstream = mesh.IndexBuffer.Lock(LockFlags.None);
if(indices.Count > ushort.MaxValue - 1)
mstream.WriteRange(indices.ToArray());
@ -1703,14 +1703,7 @@ namespace CodeImp.DoomBuilder.GZBuilder.MD3
if(bitmap != null)
{
BitmapData bmlock = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
texture = new Texture(bitmap.Width, bitmap.Height, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
DataRectangle textureLock = texture.LockRectangle(0, LockFlags.None);
textureLock.Data.WriteRange(bmlock.Scan0, bmlock.Height * bmlock.Stride);
bitmap.UnlockBits(bmlock);
texture.UnlockRectangle(0);
texture.SetPixels(bitmap);
}
}
else
@ -1728,17 +1721,17 @@ namespace CodeImp.DoomBuilder.GZBuilder.MD3
//create mesh
Mesh mesh = new Mesh(indices.Count / 3, verts.Count, MeshFlags.Use32Bit | MeshFlags.IndexBufferManaged | MeshFlags.VertexBufferManaged, vertexElements);
using (DataStream stream = mesh.LockVertexBuffer(LockFlags.None))
using (DataStream stream = mesh.VertexBuffer.Lock(LockFlags.None))
{
stream.WriteRange(verts.ToArray());
}
mesh.UnlockVertexBuffer();
mesh.VertexBuffer.Unlock();
using(DataStream stream = mesh.LockIndexBuffer(LockFlags.None))
using(DataStream stream = mesh.IndexBuffer.Lock(LockFlags.None))
{
stream.WriteRange(indices.ToArray());
}
mesh.UnlockIndexBuffer();
mesh.IndexBuffer.Unlock();
//store in result
result.Meshes.Add(mesh);

110
Source/Core/Rendering/D3DDevice.cs
View file

@ -36,11 +36,6 @@ namespace CodeImp.DoomBuilder.Rendering
public VertexBuffer VertexBuffer { get; private set; }
public IndexBuffer IndexBuffer { get; private set; }
public DataStream LockVertexBuffer(LockFlags flags) { return null; }
public DataStream LockIndexBuffer(LockFlags flags) { return null; }
public void UnlockVertexBuffer() { }
public void UnlockIndexBuffer() { }
public void DrawSubset(int index) { }
public void Dispose() { }
@ -53,7 +48,6 @@ namespace CodeImp.DoomBuilder.Rendering
public void SetTexture(EffectHandle handle, BaseTexture texture) { }
public void SetValue<T>(EffectHandle handle, T value) where T : struct { }
public EffectHandle GetParameter(EffectHandle parameter, string name) { return null; }
public string Technique { set; private get; }
public void CommitChanges() { }
public void Begin() { }
@ -86,8 +80,9 @@ namespace CodeImp.DoomBuilder.Rendering
#region Buffer objects
public class VertexBuffer
{
public VertexBuffer(int sizeInBytes, Usage usage, Pool pool) { }
public VertexBuffer(int sizeInBytes) { }
public DataStream Lock(LockFlags flags) { return null; }
public DataStream Lock(int offset, int size, LockFlags flags) { return null; }
public void Unlock() { }
@ -99,72 +94,69 @@ namespace CodeImp.DoomBuilder.Rendering
public class IndexBuffer
{
public DataStream Lock(int offset, int size, LockFlags flags) { return null; }
public DataStream Lock(LockFlags flags) { return null; }
public void Unlock() { }
public object Tag { get; set; }
public bool Disposed { get; private set; }
public void Dispose() { Disposed = true; }
}
#endregion
#region Textures
public class BaseTexture
{
public bool Disposed { get; }
public void Dispose() { }
}
public class Texture : BaseTexture
{
public Texture(int width, int height, int levels, Usage usage, Format format, Pool pool) { }
public int Width { get; private set; }
public int Height { get; private set; }
public object Tag { get; set; }
public DataRectangle LockRectangle(int level, LockFlags flags) { return null; }
public void UnlockRectangle(int level) { }
public static Texture FromStream(System.IO.Stream stream) { return null; }
public static Texture FromStream(System.IO.Stream stream, int length, int width, int height, int levels, Usage usage, Format format, Pool pool) { return null; }
}
public class CubeTexture : BaseTexture
{
public CubeTexture(int size, int levels, Usage usage, Format format, Pool pool) { }
public DataRectangle LockRectangle(CubeMapFace face, int level, LockFlags flags) { return null; }
public void UnlockRectangle(CubeMapFace face, int level) { }
}
#endregion
#region Locked buffer writing and reading
public class DataRectangle
{
public DataRectangle(int pitch, DataStream s) { Data = s; Pitch = pitch; }
public DataStream Data { get; private set; }
public int Pitch { get; private set; }
}
public class DataStream : IDisposable
{
public void Seek(long offset, System.IO.SeekOrigin origin) { }
public void Write(ushort v) { }
public void Write(Array data, long offset, long size) { }
public void WriteRange(Array data) { }
public void WriteRange(Array data, long offset, long size) { }
public void WriteRange(IntPtr data, long size) { }
public void Dispose() { }
}
#endregion
public void ReadRange(Array data, long offset, long size) { }
#region Textures
public class BaseTexture
{
public bool Disposed { get; private set; }
public void Dispose() { Disposed = true; }
}
public bool CanRead { get; private set; }
public bool CanWrite { get; private set; }
public long Length { get; private set; }
public IntPtr DataPointer { get; private set; }
public class Texture : BaseTexture
{
public Texture(int width, int height, int levels, Format format) { }
public int Width { get; private set; }
public int Height { get; private set; }
public object Tag { get; set; }
public void SetPixels(System.Drawing.Bitmap bitmap)
{
/*
BitmapData bmpdata = bitmap.LockBits(new Rectangle(0, 0, bitmap.Size.Width, bitmap.Size.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
DataRectangle textureLock = texture.LockRectangle(0, LockFlags.None);
textureLock.Data.WriteRange(bmlock.Scan0, bmlock.Height * bmlock.Stride);
texture.UnlockRectangle(0);
bitmap.UnlockBits(bmpdata);
*/
}
internal Plotter LockPlotter(int visibleWidth, int visibleHeight)
{
//return new Plotter((PixelColor*)plotlocked.Data.DataPointer.ToPointer(), plotlocked.Pitch / sizeof(PixelColor), Height, visibleWidth, visibleHeight);
return null;
}
public void UnlockPlotter() { }
public static Texture FromStream(System.IO.Stream stream) { return null; }
public static Texture FromStream(System.IO.Stream stream, int length, int width, int height, int levels, Format format) { return null; }
}
public class CubeTexture : BaseTexture
{
public CubeTexture(int size, int levels, Format format) { }
public void SetPixels(CubeMapFace face, System.Drawing.Bitmap bitmap) { }
}
#endregion
@ -197,8 +189,6 @@ namespace CodeImp.DoomBuilder.Rendering
public enum SamplerState { AddressU, AddressV, AddressW }
public enum TextureAddress { Wrap, Clamp }
public enum Format { Unknown, A8R8G8B8 }
public enum Usage { None, WriteOnly, Dynamic, RenderTarget }
public enum Pool { Default, Managed, SystemMemory }
public enum LockFlags { None, Discard }
public enum MeshFlags { Use32Bit, IndexBufferManaged, VertexBufferManaged, Managed }
public enum ShaderFlags { None, Debug }

3
Source/Core/Rendering/D3DShader.cs
View file

@ -143,9 +143,6 @@ namespace CodeImp.DoomBuilder.Rendering
fxdata.Dispose();
// Set the technique to use
fx.Technique = manager.ShaderTechnique;
// Return result
return fx;
}

39
Source/Core/Rendering/Renderer2D.cs
View file

@ -67,9 +67,6 @@ namespace CodeImp.DoomBuilder.Rendering
private Texture overlaytex;
private Texture surfacetex;
// Locking data
private DataRectangle plotlocked;
// Rendertarget sizes
private Size windowsize;
private Size structsize;
@ -365,11 +362,11 @@ namespace CodeImp.DoomBuilder.Rendering
windowsize.Height = graphics.RenderTarget.ClientSize.Height;
// Create rendertargets textures
plottertex = new Texture(windowsize.Width, windowsize.Height, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
thingstex = new Texture(windowsize.Width, windowsize.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
backtex = new Texture(windowsize.Width, windowsize.Height, 1, Usage.None, Format.A8R8G8B8, Pool.Managed);
overlaytex = new Texture(windowsize.Width, windowsize.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
surfacetex = new Texture(windowsize.Width, windowsize.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
plottertex = new Texture(windowsize.Width, windowsize.Height, 1, Format.A8R8G8B8);
thingstex = new Texture(windowsize.Width, windowsize.Height, 1, Format.A8R8G8B8);
backtex = new Texture(windowsize.Width, windowsize.Height, 1, Format.A8R8G8B8);
overlaytex = new Texture(windowsize.Width, windowsize.Height, 1, Format.A8R8G8B8);
surfacetex = new Texture(windowsize.Width, windowsize.Height, 1, Format.A8R8G8B8);
// Get the real surface sizes
structsize.Width = plottertex.Width;
@ -391,11 +388,11 @@ namespace CodeImp.DoomBuilder.Rendering
graphics.ClearTexture(General.Colors.Background.WithAlpha(0).ToColorValue(), overlaytex);
// Create vertex buffers
screenverts = new VertexBuffer(4 * sizeof(FlatVertex), Usage.Dynamic | Usage.WriteOnly, Pool.Default);
thingsvertices = new VertexBuffer(THING_BUFFER_SIZE * 12 * sizeof(FlatVertex), Usage.Dynamic | Usage.WriteOnly, Pool.Default);
screenverts = new VertexBuffer(4 * sizeof(FlatVertex));
thingsvertices = new VertexBuffer(THING_BUFFER_SIZE * 12 * sizeof(FlatVertex));
// Make screen vertices
DataStream stream = screenverts.Lock(0, 4 * sizeof(FlatVertex), LockFlags.Discard);
DataStream stream = screenverts.Lock(LockFlags.Discard);
FlatVertex[] verts = CreateScreenVerts(structsize);
stream.WriteRange(verts);
screenverts.Unlock();
@ -636,11 +633,8 @@ namespace CodeImp.DoomBuilder.Rendering
// Rendertargets available?
if(plottertex != null)
{
// Lock structures rendertarget memory
plotlocked = plottertex.LockRectangle(0, LockFlags.None);
// Create structures plotter
plotter = new Plotter((PixelColor*)plotlocked.Data.DataPointer.ToPointer(), plotlocked.Pitch / sizeof(PixelColor), structsize.Height, structsize.Width, structsize.Height);
plotter = plottertex.LockPlotter(structsize.Width, structsize.Height);
// Redraw grid when structures image was cleared
if(clear)
@ -726,8 +720,7 @@ namespace CodeImp.DoomBuilder.Rendering
// Clean up plotter
if(renderlayer == RenderLayers.Plotter)
{
if(plottertex != null) plottertex.UnlockRectangle(0);
if(plotlocked.Data != null) plotlocked.Data.Dispose();
if(plottertex != null) plottertex.UnlockPlotter();
plotter = null;
}
@ -795,11 +788,8 @@ namespace CodeImp.DoomBuilder.Rendering
if(lastgridsize != General.Map.Grid.GridSizeF || lastgridscale != scale ||
lastgridx != offsetx || lastgridy != offsety || drawmapcenter != lastdrawmapcenter)
{
// Lock background rendertarget memory
DataRectangle lockedrect = backtex.LockRectangle(0, LockFlags.None);
// Create a plotter
Plotter gridplotter = new Plotter((PixelColor*)lockedrect.Data.DataPointer.ToPointer(), lockedrect.Pitch / sizeof(PixelColor), backsize.Height, backsize.Width, backsize.Height);
Plotter gridplotter = backtex.LockPlotter(backsize.Width, backsize.Height);
gridplotter.Clear();
if(General.Settings.RenderGrid) //mxd
@ -853,8 +843,7 @@ namespace CodeImp.DoomBuilder.Rendering
}
// Done
backtex.UnlockRectangle(0);
lockedrect.Data.Dispose();
backtex.UnlockPlotter();
lastgridscale = scale;
lastgridsize = General.Map.Grid.GridSizeF;
lastgridx = offsetx;
@ -2008,8 +1997,8 @@ namespace CodeImp.DoomBuilder.Rendering
}
// Write to buffer
VertexBuffer vb = new VertexBuffer(FlatVertex.Stride * verts.Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
DataStream s = vb.Lock(0, FlatVertex.Stride * verts.Length, LockFlags.Discard);
VertexBuffer vb = new VertexBuffer(FlatVertex.Stride * verts.Length);
DataStream s = vb.Lock(LockFlags.Discard);
s.WriteRange(verts);
vb.Unlock();
s.Dispose();

4
Source/Core/Rendering/Renderer3D.cs
View file

@ -720,8 +720,8 @@ namespace CodeImp.DoomBuilder.Rendering
}
}
VertexBuffer vb = new VertexBuffer(WorldVertex.Stride * verts.Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
DataStream s = vb.Lock(0, WorldVertex.Stride * verts.Length, LockFlags.Discard);
VertexBuffer vb = new VertexBuffer(WorldVertex.Stride * verts.Length);
DataStream s = vb.Lock(LockFlags.Discard);
s.WriteRange(verts);
vb.Unlock();
s.Dispose();

5
Source/Core/Rendering/ShaderManager.cs
View file

@ -30,9 +30,6 @@ namespace CodeImp.DoomBuilder.Rendering
#region ================== Variables
// Settings
private readonly string shadertechnique;
// Shaders
private Display2DShader display2dshader;
private Things2DShader things2dshader;
@ -48,7 +45,6 @@ namespace CodeImp.DoomBuilder.Rendering
#region ================== Properties
public string ShaderTechnique { get { return shadertechnique; } }
public Display2DShader Display2D { get { return display2dshader; } }
public Things2DShader Things2D { get { return things2dshader; } }
public World3DShader World3D { get { return world3dshader; } }
@ -64,7 +60,6 @@ namespace CodeImp.DoomBuilder.Rendering
{
// Initialize
this.device = device;
shadertechnique = "SM20"; //mxd
// Load
ReloadResource();

10
Source/Core/Rendering/SurfaceManager.cs
View file

@ -140,10 +140,10 @@ namespace CodeImp.DoomBuilder.Rendering
for(int i = 0; i < set.Value.buffersizes.Count; i++)
{
// Make the new buffer!
VertexBuffer b = new VertexBuffer(FlatVertex.Stride * set.Value.buffersizes[i], Usage.WriteOnly | Usage.Dynamic, Pool.Default);
VertexBuffer b = new VertexBuffer(FlatVertex.Stride * set.Value.buffersizes[i]);
// Start refilling the buffer with sector geometry
DataStream bstream = b.Lock(0, FlatVertex.Stride * set.Value.buffersizes[i], LockFlags.Discard);
DataStream bstream = b.Lock(LockFlags.Discard);
foreach(SurfaceEntry e in set.Value.entries)
{
if(e.bufferindex == i)
@ -280,7 +280,7 @@ namespace CodeImp.DoomBuilder.Rendering
if(!resourcesunloaded)
{
// Make the new buffer!
vb = new VertexBuffer(FlatVertex.Stride * buffernumvertices, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
vb = new VertexBuffer(FlatVertex.Stride * buffernumvertices);
// Add it.
set.buffers.Add(vb);
@ -331,8 +331,8 @@ namespace CodeImp.DoomBuilder.Rendering
if(!resourcesunloaded)
{
// Make the new buffer and lock it
vb = new VertexBuffer(FlatVertex.Stride * buffernumvertices, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
bstream = vb.Lock(0, FlatVertex.Stride * theseentries.Count * verticesperentry, LockFlags.Discard);
vb = new VertexBuffer(FlatVertex.Stride * buffernumvertices);
bstream = vb.Lock(LockFlags.Discard);
}
// Start refilling the buffer with sector geometry

6
Source/Core/Rendering/TextLabel.cs
View file

@ -336,17 +336,17 @@ namespace CodeImp.DoomBuilder.Rendering
img.Save(memstream, ImageFormat.Bmp);
memstream.Seek(0, SeekOrigin.Begin);
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, 1, Usage.None, Format.Unknown, Pool.Managed);
texture = Texture.FromStream(memstream, (int)memstream.Length, img.Size.Width, img.Size.Height, 1, Format.Unknown);
}
//mxd. Create the buffer
if(textbuffer == null || textbuffer.Disposed)
{
textbuffer = new VertexBuffer(4 * FlatVertex.Stride, Usage.Dynamic | Usage.WriteOnly, Pool.Default);
textbuffer = new VertexBuffer(4 * FlatVertex.Stride);
}
//mxd. Lock the buffer
using(DataStream stream = textbuffer.Lock(0, 4 * FlatVertex.Stride, LockFlags.Discard))
using(DataStream stream = textbuffer.Lock(LockFlags.Discard))
{
FlatQuad quad = new FlatQuad(PrimitiveType.TriangleStrip, beginx, beginy, beginx + texturesize.Width, beginy + texturesize.Height);
stream.WriteRange(quad.Vertices);

8
Source/Core/Rendering/VisualVertexHandle.cs
View file

@ -84,8 +84,8 @@ namespace CodeImp.DoomBuilder.Rendering
v2, v3,
v3, v0 };
upper = new VertexBuffer(WorldVertex.Stride * vu.Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
upper.Lock(0, WorldVertex.Stride * vu.Length, LockFlags.None).WriteRange(vu);
upper = new VertexBuffer(WorldVertex.Stride * vu.Length);
upper.Lock(LockFlags.None).WriteRange(vu);
upper.Unlock();
WorldVertex[] vl = new[]{ c, v4,
@ -98,8 +98,8 @@ namespace CodeImp.DoomBuilder.Rendering
v6, v7,
v7, v4 };
lower = new VertexBuffer(WorldVertex.Stride * vl.Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
lower.Lock(0, WorldVertex.Stride * vl.Length, LockFlags.None).WriteRange(vl);
lower = new VertexBuffer(WorldVertex.Stride * vl.Length);
lower.Lock(LockFlags.None).WriteRange(vl);
lower.Unlock();
}

4
Source/Core/VisualModes/VisualSector.cs
View file

@ -138,10 +138,10 @@ namespace CodeImp.DoomBuilder.VisualModes
if(numverts > 0)
{
// Make a new buffer
geobuffer = new VertexBuffer(WorldVertex.Stride * numverts, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
geobuffer = new VertexBuffer(WorldVertex.Stride * numverts);
// Fill the buffer
DataStream bufferstream = geobuffer.Lock(0, WorldVertex.Stride * numverts, LockFlags.Discard);
DataStream bufferstream = geobuffer.Lock(LockFlags.Discard);
foreach(VisualGeometry g in allgeometry)
{
if((g.Vertices != null) && (g.Vertices.Length > 0))

8
Source/Core/VisualModes/VisualThing.cs
View file

@ -526,10 +526,10 @@ namespace CodeImp.DoomBuilder.VisualModes
for(int i = 0; i < vertices.Length; i++)
{
// Make a new buffer
geobuffers[i] = new VertexBuffer(WorldVertex.Stride * vertices[i].Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
geobuffers[i] = new VertexBuffer(WorldVertex.Stride * vertices[i].Length);
// Fill the buffer
DataStream bufferstream = geobuffers[i].Lock(0, WorldVertex.Stride * vertices[i].Length, LockFlags.Discard);
DataStream bufferstream = geobuffers[i].Lock(LockFlags.Discard);
bufferstream.WriteRange(vertices[i]);
geobuffers[i].Unlock();
bufferstream.Dispose();
@ -616,8 +616,8 @@ namespace CodeImp.DoomBuilder.VisualModes
// Create buffer
WorldVertex[] cv = cageverts.ToArray();
cagelength = cv.Length / 2;
cagebuffer = new VertexBuffer(WorldVertex.Stride * cv.Length, Usage.WriteOnly | Usage.Dynamic, Pool.Default);
cagebuffer.Lock(0, WorldVertex.Stride * cv.Length, LockFlags.None).WriteRange(cv);
cagebuffer = new VertexBuffer(WorldVertex.Stride * cv.Length);
cagebuffer.Lock(LockFlags.None).WriteRange(cv);
cagebuffer.Unlock();
// Done