private void DisposeWave()
{
lock (mutex)
{
if (dataStream != null)
{
dataStream.Dispose();
dataStream = null;
}
if (audioBuffer != null)
{
audioBuffer.Dispose();
audioBuffer = null;
}
if (sourceVoice != null)
{
if (currentStream != null)
{
sourceVoice.BufferEnd -= bufferEndCallback;
}
sourceVoice.Stop();
sourceVoice.FlushSourceBuffers();
sourceVoice.Dispose();
sourceVoice = null;
}
current = null;
currentStream = null;
}
}
static public dynamic vertexdata(LispList args, LispEnvironment env)
{
using (var stream = new MemoryStream())
{
int elementCount = 0;
foreach (LispElement arg in args)
{
dynamic vertices = arg.Eval(env);
if (vertices is LispList)
{
foreach (var vertex in vertices)
{
writeVertexToStream(vertex, stream);
elementCount++;
}
}
else
{
writeVertexToStream(vertices, stream);
elementCount++;
}
}
var dataStream = new SlimDX.DataStream(stream.Length, false, true);
stream.WriteTo(dataStream);
dataStream.Position = 0;
return(dataStream);
}
}
static public dynamic indexdata(LispList args, LispEnvironment env)
{
using (var stream = new MemoryStream())
{
foreach (LispElement arg in args)
{
dynamic indexes = arg.Eval(env);
if (indexes is LispList)
{
foreach (var curIndexes in indexes)
{
stream.Write(curIndexes, 0, curIndexes.Length);
}
}
else
{
stream.Write(indexes, 0, indexes.Length);
}
}
var dataStream = new SlimDX.DataStream(stream.Length, false, true);
stream.WriteTo(dataStream);
dataStream.Position = 0;
return(dataStream);
}
}
public Model Load(string file, Device device)
{
XmlDocument document = new XmlDocument();
document.Load(file);
XmlNamespaceManager ns = new XmlNamespaceManager(document.NameTable);
ns.AddNamespace("c", "http://www.collada.org/2005/11/COLLADASchema");
// Read vertex positions
var positionsNode = document.SelectSingleNode("/c:COLLADA/c:library_geometries/c:geometry/c:mesh/c:source/c:float_array", ns);
var indicesNode = document.SelectSingleNode("/c:COLLADA/c:library_geometries/c:geometry/c:mesh/c:triangles/c:p", ns);
var positions = ParseVector3s(positionsNode.InnerText).ToArray();
var indices = ParseInts(indicesNode.InnerText).ToArray();
// Mixing concerns here, but oh well
var positionsBuffer = new SlimDX.DataStream(positions, true, false);
var indicesBuffer = new SlimDX.DataStream(indices, true, false);
var model = new Model()
{
VertexBuffer = new Buffer(device, positionsBuffer, positions.Length * Vector3.SizeInBytes, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None),
IndexBuffer = new Buffer(device, indicesBuffer, indices.Length * sizeof(int), ResourceUsage.Default, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None),
IndexCount = indices.Length,
VertexPositions = positions,
Indices = indices
};
return(model);
}
protected override BulletMesh CreateMesh(Device device)
{
int totalTriangles = this.indices.Length / 3;
int totalVerts = this.vertices.Length;
Mesh m = new Mesh(device, totalTriangles, totalVerts, MeshFlags.Use32Bit | MeshFlags.SystemMemory, VertexFormat.Position | VertexFormat.Normal);
SlimDX.DataStream data = m.LockVertexBuffer(LockFlags.None);
for (int i = 0; i < this.vertices.Length; i++)
{
data.Write(this.vertices[i].X);
data.Write(this.vertices[i].Y);
data.Write(this.vertices[i].Z);
data.Write(0.0f);
data.Write(0.0f);
data.Write(0.0f);
//data.Write(this.texcoords[i]);
}
m.UnlockVertexBuffer();
data = m.LockIndexBuffer(LockFlags.None);
for (int i = 0; i < this.indices.Length; i++)
{
data.Write(this.indices[i]);
}
m.UnlockIndexBuffer();
m.ComputeNormals();
return(new BulletMesh(m));
}
public void Setup(Device device,
byte[] vertexShaderData,
byte[] pixelShaderData,
InputElement[] inputElements)
{
if (inputElements == null)
{
throw new ArgumentNullException("inputElements");
}
if (vertexShaderData != null)
{
using (var dataStream = new DataStream(vertexShaderData, true, false))
{
var byteCode = new ShaderBytecode(dataStream);
var shader = new VertexShader(device, byteCode);
var inputLayout = new InputLayout(device,
byteCode,
inputElements);
this.VertexShader = shader;
this.InputLayout = inputLayout;
}
}
if (pixelShaderData != null)
{
using (var dataStream = new DataStream(pixelShaderData, true, false))
{
var byteCode = new ShaderBytecode(dataStream);
var shader = new PixelShader(device, byteCode);
this.PixelShader = shader;
}
}
}
public Model Load(string file, Device device)
{
XmlDocument document = new XmlDocument();
document.Load(file);
XmlNamespaceManager ns = new XmlNamespaceManager(document.NameTable);
ns.AddNamespace("c", "http://www.collada.org/2005/11/COLLADASchema");
// Read vertex positions
var positionsNode = document.SelectSingleNode("/c:COLLADA/c:library_geometries/c:geometry/c:mesh/c:source/c:float_array", ns);
var indicesNode = document.SelectSingleNode("/c:COLLADA/c:library_geometries/c:geometry/c:mesh/c:triangles/c:p", ns);
var positions = ParseVector3s(positionsNode.InnerText).ToArray();
var indices = ParseInts(indicesNode.InnerText).ToArray();
// Mixing concerns here, but oh well
var positionsBuffer = new SlimDX.DataStream(positions, true, false);
var indicesBuffer = new SlimDX.DataStream(indices, true, false);
var model = new Model()
{
VertexBuffer = new Buffer(device, positionsBuffer, positions.Length * Vector3.SizeInBytes, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None),
IndexBuffer = new Buffer(device, indicesBuffer, indices.Length * sizeof(int), ResourceUsage.Default, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None),
IndexCount = indices.Length,
VertexPositions = positions,
Indices = indices
};
return model;
}
public void Load(string filename, System.Threading.CancellationToken token)
{
bitmap = new Bitmap(filename);
Description = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = SlimDX.DXGI.Format.B8G8R8A8_UNorm,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
Width = bitmap.Width,
Height = bitmap.Height,
SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0)
};
token.ThrowIfCancellationRequested();
bitmapData = bitmap.LockBits(
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
ImageLockMode.ReadOnly,
PixelFormat.Format32bppPArgb);
ds = new SlimDX.DataStream(bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, true, false);
var dr = new SlimDX.DataRectangle(bitmapData.Stride, ds);
token.ThrowIfCancellationRequested();
tex = new Texture2D(Device, Description, dr);
SRV = new ShaderResourceView(Device, tex);
}
private SlimDX.Direct2D.Bitmap loadBitmap(Bitmap drawingBitmap)
{
SlimDX.Direct2D.Bitmap result = null;
if (drawingBitmap == null)
{
return(null);
}
if (gr.Contains(drawingBitmap))
{
return(gb[gr.IndexOf(drawingBitmap)]);
}
else
{
gr.Add(drawingBitmap);
}
//Lock the gdi resource
BitmapData drawingBitmapData = drawingBitmap.LockBits(
new Rectangle(0, 0, drawingBitmap.Width, drawingBitmap.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppPArgb);
//Prepare loading the image from gdi resource
SlimDX.DataStream dataStream = new SlimDX.DataStream(drawingBitmapData.Scan0, drawingBitmapData.Stride * drawingBitmapData.Height, true, false);
SlimDX.Direct2D.BitmapProperties properties = new SlimDX.Direct2D.BitmapProperties();
properties.PixelFormat = new SlimDX.Direct2D.PixelFormat(SlimDX.DXGI.Format.B8G8R8A8_UNorm, SlimDX.Direct2D.AlphaMode.Premultiplied);
//Load the image from the gdi resource
result = new SlimDX.Direct2D.Bitmap(renderTarget, new Size(drawingBitmap.Width, drawingBitmap.Height), dataStream, drawingBitmapData.Stride, properties);
//Unlock the gdi resource
drawingBitmap.UnlockBits(drawingBitmapData);
gb.Add(result);
return(result);
}
/// <summary>
/// コンスタントバッファコンスタントバッファ更新
/// </summary>
/// <param name="inst"></param>
public void UpdateConstantBuffer()
{
byte[] data = cbInst_.Buffer;
SlimDX.DataStream s = new SlimDX.DataStream(data, true, true);
SlimDX.DataBox box = new SlimDX.DataBox(0, 0, s);
GraphicsCore.D3D11ImmediateContext.UpdateSubresource(box, constantBuffer_, 0);
s.Close();
}
public unsafe Stream GetStream(int length)
{
var capacity = VVVV.Utils.Streams.StreamUtils.NextHigher(length);
var memory = FUnmanagedMemoryPool.GetMemory(capacity);
var stream = new SlimDX.DataStream(memory, length, true, true);
return(stream);
}
public string Disassemble()
{
SlimDX.Direct3D9.ShaderBytecode code = new SlimDX.Direct3D9.ShaderBytecode(RawData);
SlimDX.DataStream s = code.Disassemble();
byte[] buffer = new byte[s.Length];
s.Read(buffer, 0, buffer.Length);
return(ASCIIEncoding.ASCII.GetString(buffer));
}
Mesh CreateShape(CollisionShape shape)
{
uint[] indices;
BulletSharp.Vector3[] vertices = CreateShape(shape, out indices);
int vertexCount = vertices.Length / 2;
int indexCount = (indices != null) ? indices.Length : vertexCount;
bool index32 = indexCount > 65536;
Mesh mesh = new Mesh(device, indexCount / 3, vertexCount,
MeshFlags.SystemMemory | (index32 ? MeshFlags.Use32Bit : 0), VertexFormat.Position | VertexFormat.Normal);
DataStream vertexBuffer = mesh.LockVertexBuffer(LockFlags.Discard);
vertexBuffer.WriteRange(vertices);
mesh.UnlockVertexBuffer();
DataStream indexBuffer = mesh.LockIndexBuffer(LockFlags.Discard);
if (index32)
{
if (indices == null)
{
indices = new uint[indexCount];
uint i = 0;
while (i < indexCount)
{
indices[i] = i;
i++;
}
}
indexBuffer.WriteRange(indices);
}
else
{
ushort[] indices_s;
if (indices == null)
{
indices_s = new ushort[indexCount];
ushort i = 0;
while (i < indexCount)
{
indices_s[i] = i;
i++;
}
}
else
{
indices_s = CompactIndexBuffer(indices);
}
indexBuffer.WriteRange(indices_s);
}
mesh.UnlockIndexBuffer();
shapes.Add(shape, mesh);
return(mesh);
}
public void WriteTo(SlimDX.DataStream stream)
{
stream.Write(X);
stream.Write(Y);
stream.Write(Z);
stream.Write(NX);
stream.Write(NY);
stream.Write(NZ);
}
public void Load(string filename, System.Threading.CancellationToken token)
{
int stride;
var imgF = new ImagingFactory();
using (var decoder = new SharpDX.WIC.BitmapDecoder(imgF, filename, SharpDX.IO.NativeFileAccess.Read, DecodeOptions.CacheOnLoad))
using (var frame = decoder.GetFrame(0))
{
var format = PixelToTextureFormat(frame.PixelFormat);
bool knownFormat = format != Format.Unknown;
var w = frame.Size.Width;
var h = frame.Size.Height;
stride = PixelFormat.GetStride(knownFormat ? frame.PixelFormat:PixelFormat.Format32bppRGBA, w);
//stride = PixelFormat.GetStride(PixelFormat.Format32bppBGRA, w);
FLength = stride * h;
Description = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = knownFormat?format:Format.R8G8B8A8_UNorm,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
Usage = ResourceUsage.Default,
Width = w,
Height = h,
SampleDescription = new SampleDescription(1, 0)
};
token.ThrowIfCancellationRequested();
ptr = mp.UnmanagedPool.GetMemory(FLength);
//if (frame.PixelFormat != PixelFormat.Format32bppBGRA)
if (!knownFormat)
{
using (var converter = new FormatConverter(imgF))
{
converter.Initialize(frame, PixelFormat.Format32bppRGBA);
converter.CopyPixels(stride, ptr, FLength);
}
}
else
{
frame.CopyPixels(stride, ptr, FLength);
}
}
token.ThrowIfCancellationRequested();
ds = new SlimDX.DataStream(ptr, FLength, true, false);
var dr = new SlimDX.DataRectangle(stride, ds);
token.ThrowIfCancellationRequested();
tex = new Texture2D(Device, Description, dr);
token.ThrowIfCancellationRequested();
SRV = new ShaderResourceView(Device, tex);
}
/// <summary>
/// Converts mesh to DX-buffers.
/// </summary>
private static void MeshToBuffers(Device device,
Mesh mesh,
out SlimDX.Direct3D11.Buffer vertices,
out SlimDX.Direct3D11.Buffer indices)
{
SlimDX.DataStream dsVertices = new SlimDX.DataStream(mesh.Vertices.Length * 6 * sizeof(float), true, true);
SlimDX.DataStream dsIndices = new SlimDX.DataStream(mesh.Indices.Length * 3 * sizeof(int), true, true);
vertices = null;
indices = null;
try
{
foreach (Vertex v in mesh.Vertices)
{
v.WriteTo(dsVertices);
}
dsVertices.Position = 0;
BufferDescription bdVertices = new BufferDescription();
bdVertices.BindFlags = BindFlags.VertexBuffer;
bdVertices.CpuAccessFlags = CpuAccessFlags.None;
bdVertices.OptionFlags = ResourceOptionFlags.None;
bdVertices.SizeInBytes = mesh.Vertices.Length * 6 * sizeof(float);
bdVertices.Usage = ResourceUsage.Default;
vertices = new SlimDX.Direct3D11.Buffer(device, dsVertices, bdVertices);
dsIndices.WriteRange(mesh.Indices);
dsIndices.Position = 0;
BufferDescription bdIndices = new BufferDescription();
bdIndices.BindFlags = BindFlags.IndexBuffer;
bdIndices.CpuAccessFlags = CpuAccessFlags.None;
bdIndices.OptionFlags = ResourceOptionFlags.None;
bdIndices.SizeInBytes = mesh.Indices.Length * 3 * sizeof(int);
bdIndices.Usage = ResourceUsage.Default;
indices = new SlimDX.Direct3D11.Buffer(device, dsIndices, bdIndices);
}
catch (Exception)
{
if (vertices != null)
{
vertices.Dispose();
vertices = null;
}
if (indices != null)
{
indices.Dispose();
indices = null;
}
throw;
}
finally
{
dsVertices.Dispose();
dsIndices.Dispose();
}
}
public void RenderSoftBodyTextured(SoftBody softBody)
{
if (!(softBody.UserObject is Array))
{
return;
}
object[] userObjArr = softBody.UserObject as object[];
FloatArray vertexBuffer = userObjArr[0] as FloatArray;
IntArray indexBuffer = userObjArr[1] as IntArray;
int vertexCount = (vertexBuffer.Count / 8);
if (vertexCount > 0)
{
int faceCount = indexBuffer.Count / 2;
bool index32 = vertexCount > 65536;
Mesh mesh = new Mesh(device, faceCount, vertexCount,
MeshFlags.SystemMemory | (index32 ? MeshFlags.Use32Bit : 0),
VertexFormat.Position | VertexFormat.Normal | VertexFormat.Texture1);
DataStream indices = mesh.LockIndexBuffer(LockFlags.Discard);
if (index32)
{
foreach (int i in indexBuffer)
{
indices.Write(i);
}
}
else
{
foreach (int i in indexBuffer)
{
indices.Write((short)i);
}
}
mesh.UnlockIndexBuffer();
DataStream verts = mesh.LockVertexBuffer(LockFlags.Discard);
foreach (float f in vertexBuffer)
{
verts.Write(f);
}
mesh.UnlockVertexBuffer();
mesh.ComputeNormals();
mesh.DrawSubset(0);
mesh.Dispose();
}
}
internal IndexBuffer(SlimDX.Direct3D11.Device device, IEnumerable<int> indices)
{
#if ASSERT
if (device == null)
{
throw new ArgumentNullException("device");
}
if (indices == null)
{
throw new ArgumentNullException("indices");
}
if (indices.Count() == 0)
{
throw new ArgumentOutOfRangeException("indices");
}
#endif
indexCount = indices.Count();
resourceOwner = true;
var indexSize = Marshal.SizeOf(typeof(UInt32));
var bufferSize = indexCount * indexSize;
using (var dataStream = new SlimDX.DataStream(bufferSize, true, true))
{
foreach (var index in indices)
{
dataStream.Write(Convert.ToUInt32(index));
}
dataStream.Position = 0;
indexBuffer = new SlimDX.Direct3D11.Buffer(device, dataStream, bufferSize, SlimDX.Direct3D11.ResourceUsage.Default, SlimDX.Direct3D11.BindFlags.IndexBuffer, SlimDX.Direct3D11.CpuAccessFlags.None, SlimDX.Direct3D11.ResourceOptionFlags.None, 0);
}
}
protected override DX11VertexGeometry GetGeom(DX11RenderContext device, int slice)
{
if (d2dFactory == null)
{
d2dFactory = new D2DFactory();
dwFactory = new DWriteFactory(SharpDX.DirectWrite.FactoryType.Shared);
}
TextFormat fmt = new TextFormat(dwFactory, this.FFontInput[slice].Name, FFontSize[slice]);
TextLayout tl = new TextLayout(dwFactory, FText[slice], fmt, 0.0f, 32.0f);
tl.WordWrapping = WordWrapping.NoWrap;
tl.TextAlignment = FHAlignment[slice];
tl.ParagraphAlignment = FVAlignment[slice];
OutlineRenderer renderer = new OutlineRenderer(d2dFactory);
Extruder ex = new Extruder(d2dFactory);
tl.Draw(renderer, 0.0f, 0.0f);
var outlinedGeometry = renderer.GetGeometry();
ex.GetVertices(outlinedGeometry, vertexList, this.FExtrude[slice]);
outlinedGeometry.Dispose();
Vector3 min = new Vector3(float.MaxValue);
Vector3 max = new Vector3(float.MinValue);
for (int i = 0; i < vertexList.Count; i++)
{
Pos3Norm3VertexSDX pn = vertexList[i];
min.X = pn.Position.X < min.X ? pn.Position.X : min.X;
min.Y = pn.Position.Y < min.Y ? pn.Position.Y : min.Y;
min.Z = pn.Position.Z < min.Z ? pn.Position.Z : min.Z;
max.X = pn.Position.X > max.X ? pn.Position.X : max.X;
max.Y = pn.Position.Y > max.Y ? pn.Position.Y : max.Y;
max.Z = pn.Position.Z > max.Z ? pn.Position.Z : max.Z;
}
SlimDX.DataStream ds = new SlimDX.DataStream(vertexList.Count * Pos3Norm3VertexSDX.VertexSize, true, true);
ds.Position = 0;
for (int i = 0; i < vertexList.Count; i++)
{
ds.Write(vertexList[i]);
}
ds.Position = 0;
var vbuffer = new SlimDX.Direct3D11.Buffer(device.Device, ds, new SlimDX.Direct3D11.BufferDescription()
{
BindFlags = SlimDX.Direct3D11.BindFlags.VertexBuffer,
CpuAccessFlags = SlimDX.Direct3D11.CpuAccessFlags.None,
OptionFlags = SlimDX.Direct3D11.ResourceOptionFlags.None,
SizeInBytes = (int)ds.Length,
Usage = SlimDX.Direct3D11.ResourceUsage.Default
});
ds.Dispose();
DX11VertexGeometry vg = new DX11VertexGeometry(device);
vg.InputLayout = Pos3Norm3VertexSDX.Layout;
vg.Topology = SlimDX.Direct3D11.PrimitiveTopology.TriangleList;
vg.VertexBuffer = vbuffer;
vg.VertexSize = Pos3Norm3VertexSDX.VertexSize;
vg.VerticesCount = vertexList.Count;
vg.HasBoundingBox = true;
vg.BoundingBox = new SlimDX.BoundingBox(new SlimDX.Vector3(min.X, min.Y, min.Z), new SlimDX.Vector3(max.X, max.Y, max.Z));
renderer.Dispose();
fmt.Dispose();
tl.Dispose();
return(vg);
}
public void UpdateResource(IPluginOut ForPin, Device OnDevice)
{
List <Mesh> soft = new List <Mesh>();
if (this.FMesh != null)
{
this.FMesh.Dispose();
this.FMesh = null;
}
if (this.FBodies.SliceCount > 0)
{
int cnt = this.FBodies.SliceCount;
for (int i = 0; i < cnt; i++)
{
SoftBody body = this.FBodies[i];
SoftBodyCustomData sc = (SoftBodyCustomData)body.UserObject;
AlignedFaceArray faces = body.Faces;
if (FValid[i])
{
if (body.Faces.Count > 0)
{
#region Build from Faces
VertexFormat decl;
if (sc.HasUV)
{
decl = VertexFormat.Position | VertexFormat.Normal | VertexFormat.Texture1;
}
else
{
decl = VertexFormat.Position | VertexFormat.Normal;
}
Mesh mesh = new Mesh(OnDevice, faces.Count, faces.Count * 3, MeshFlags.SystemMemory | MeshFlags.Use32Bit, decl);
SlimDX.DataStream verts = mesh.LockVertexBuffer(LockFlags.None);
SlimDX.DataStream indices = mesh.LockIndexBuffer(LockFlags.None);
int j;
int uvcnt = 0;
for (j = 0; j < faces.Count; j++)
{
NodePtrArray nodes = faces[j].N;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
indices.Write(j * 3);
indices.Write(j * 3 + 1);
indices.Write(j * 3 + 2);
}
mesh.UnlockVertexBuffer();
mesh.UnlockIndexBuffer();
//mesh.ComputeNormals();
soft.Add(mesh);
#endregion
}
else
{
#region Build from tetras
int tetraCount = body.Tetras.Count;
int vertexCount = tetraCount * 12;
VertexFormat decl;
if (sc.HasUV)
{
decl = VertexFormat.Position | VertexFormat.Normal | VertexFormat.Texture1;
}
else
{
decl = VertexFormat.Position | VertexFormat.Normal;
}
Mesh mesh = new Mesh(OnDevice, tetraCount * 4, vertexCount, MeshFlags.SystemMemory | MeshFlags.Use32Bit, decl);
SlimDX.DataStream indices = mesh.LockIndexBuffer(LockFlags.Discard);
for (int idx = 0; idx < vertexCount; idx++)
{
indices.Write(idx);
}
mesh.UnlockIndexBuffer();
SlimDX.DataStream verts = mesh.LockVertexBuffer(LockFlags.None);
foreach (Tetra t in body.Tetras)
{
NodePtrArray nodes = t.Nodes;
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
verts.Write(nodes[3].X);
verts.Write(nodes[3].Normal);
//verts.Position += 12;
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
verts.Write(nodes[3].X);
verts.Write(nodes[3].Normal);
//verts.Position += 12;
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
verts.Write(nodes[3].X);
verts.Write(nodes[3].Normal);
//verts.Position += 12;
}
mesh.UnlockVertexBuffer();
mesh.UnlockIndexBuffer();
//mesh.ComputeNormals();
soft.Add(mesh);
#endregion
}
}
}
Mesh merge = null;
if (OnDevice is DeviceEx)
{
merge = Mesh.Concatenate(OnDevice, soft.ToArray(), MeshFlags.Use32Bit);
}
else
{
merge = Mesh.Concatenate(OnDevice, soft.ToArray(), MeshFlags.Use32Bit | MeshFlags.Managed);
}
this.FMesh = merge;
foreach (Mesh m in soft)
{
m.Dispose();
}
}
}
internal override void WriteVertex(SlimDX.DataStream stream, ref Tessellator.VS_IN vsin)
{
stream.Write(vsin.Vertex);
stream.Write(vsin.Color);
}
public void Play(IPlayable wave)
{
lock (mutex)
{
if (wave == current)
{
if (isPaused)
{
sourceVoice.Start();
isPaused = false;
return;
}
}
DisposeWave();
xaudio.CommitChanges();
isPaused = false;
current = wave;
currentStream = wave as IPlayableStream;
if (decodeThread != null)
{
System.Threading.Monitor.Pulse(mutex);
decodeThread = null;
}
if (currentStream == null)
{
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
dataStream = new SlimDX.DataStream(wave.WaveData, true, false);
audioBuffer = new SlimDX.XAudio2.AudioBuffer();
audioBuffer.AudioData = dataStream;
audioBuffer.AudioBytes = wave.WaveData.Length;
audioBuffer.Flags = BufferFlags.EndOfStream;
sourceVoice.SubmitSourceBuffer(audioBuffer);
sourceVoice.Start();
}
else
{
streamLength = currentStream.StreamLength;
streamBuffered = 0;
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
sourceVoice.BufferEnd += bufferEndCallback;
// Fill buffers initially
bool isDone = false;
for (var i = 0; i < NumStreamingBuffers; i++)
{
isDone = FillBuffer(i, currentStream);
if (isDone)
{
break;
}
}
sourceVoice.Start();
if (!isDone)
{
System.Threading.ParameterizedThreadStart threadProc = DecoderThread;
decodeThread = new System.Threading.Thread(threadProc);
decodeThread.Name = "Vorbis Decoder Thread";
decodeThread.Start(currentStream);
}
}
}
}
private void DisposeWave()
{
lock (mutex)
{
if (dataStream != null)
{
dataStream.Dispose();
dataStream = null;
}
if (audioBuffer != null)
{
audioBuffer.Dispose();
audioBuffer = null;
}
if (sourceVoice != null)
{
if (currentStream != null)
{
sourceVoice.BufferEnd -= bufferEndCallback;
}
sourceVoice.Stop();
sourceVoice.FlushSourceBuffers();
sourceVoice.Dispose();
sourceVoice = null;
}
current = null;
currentStream = null;
}
}
public override IDisposable Load(Type resourceType, string identifier)
{
using (var assimpContext = new Assimp.AssimpContext())
{
var scene = assimpContext.ImportFile(identifier);
var meshes = new List<Graphics.Mesh>();
foreach (var mesh in scene.Meshes)
{
var bytesPerVertex = 12;
if (mesh.HasNormals)
{
bytesPerVertex += 12;
}
if (mesh.HasTextureCoords(0))
{
bytesPerVertex += 8;
}
var vertexCount = mesh.VertexCount;
var meshSizeInBytes = vertexCount * bytesPerVertex;
using (var stream = new SlimDX.DataStream(meshSizeInBytes, true, true))
{
for (var i = 0; i < vertexCount; ++i)
{
stream.Write(mesh.Vertices[i]);
if (mesh.HasNormals)
{
stream.Write(mesh.Normals[i]);
}
if (mesh.HasTextureCoords(0))
{
stream.Write(mesh.TextureCoordinateChannels[0][i].X);
stream.Write(mesh.TextureCoordinateChannels[0][i].Y);
}
}
var vertexBuffer = new Graphics.VertexBuffer(device.Handle, stream, bytesPerVertex, vertexCount, SlimDX.Direct3D11.PrimitiveTopology.TriangleList);
var indices = mesh.GetIndices();
if (indices != null && indices.Count() > 0)
{
var indexBuffer = new Graphics.IndexBuffer(device.Handle, indices);
return new Graphics.Mesh(vertexBuffer, indexBuffer);
}
var result = new Graphics.Mesh(vertexBuffer);
if (resourceType.Equals(typeof(Graphics.Mesh)))
{
return result;
}
else
{
meshes.Add(result);
}
}
}
if (meshes.Count > 0)
{
return new Graphics.MeshGroup(meshes);
}
else
{
throw new KeyNotFoundException("Failed to load mesh: " + identifier);
}
}
}
public TextRenderer(Device device)
{
using (var factory = new SlimDX.DXGI.Factory1())
{
using (var adapter = factory.GetAdapter1(0))
{
this.device = new SlimDX.Direct3D10_1.Device1(
adapter,
SlimDX.Direct3D10.DriverType.Hardware,
SlimDX.Direct3D10.DeviceCreationFlags.BgraSupport,
SlimDX.Direct3D10_1.FeatureLevel.Level_10_0
);
// Create the DirectX11 texture2D. This texture will be shared with the DirectX10
// device. The DirectX10 device will be used to render text onto this texture. DirectX11
// will then draw this texture (blended) onto the screen.
// The KeyedMutex flag is required in order to share this resource.
textureD3D11 = new SlimDX.Direct3D11.Texture2D(device.Handle, new SlimDX.Direct3D11.Texture2DDescription
{
Width = device.Form.Width,
Height = device.Form.Height,
MipLevels = 1,
ArraySize = 1,
Format = SlimDX.DXGI.Format.B8G8R8A8_UNorm,
SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0),
Usage = SlimDX.Direct3D11.ResourceUsage.Default,
BindFlags = SlimDX.Direct3D11.BindFlags.RenderTarget | SlimDX.Direct3D11.BindFlags.ShaderResource,
CpuAccessFlags = SlimDX.Direct3D11.CpuAccessFlags.None,
OptionFlags = SlimDX.Direct3D11.ResourceOptionFlags.KeyedMutex
});
// A DirectX10 Texture2D sharing the DirectX11 Texture2D
var sharedResource = new SlimDX.DXGI.Resource(textureD3D11);
var textureD3D10 = this.device.OpenSharedResource<SlimDX.Direct3D10.Texture2D>(sharedResource.SharedHandle);
// The KeyedMutex is used just prior to writing to textureD3D11 or textureD3D10.
// This is how DirectX knows which DirectX (10 or 11) is supposed to be writing
// to the shared texture. The keyedMutex is just defined here, they will be used
// a bit later.
mutex10 = new SlimDX.DXGI.KeyedMutex(textureD3D10);
mutex11 = new SlimDX.DXGI.KeyedMutex(textureD3D11);
// Direct2D Factory
SlimDX.Direct2D.Factory d2Factory = new SlimDX.Direct2D.Factory(
SlimDX.Direct2D.FactoryType.SingleThreaded,
SlimDX.Direct2D.DebugLevel.Information
);
// Direct Write factory
SlimDX.DirectWrite.Factory dwFactory = new SlimDX.DirectWrite.Factory(
SlimDX.DirectWrite.FactoryType.Isolated
);
// The textFormat we will use to draw text with
textFormat = new SlimDX.DirectWrite.TextFormat(
dwFactory,
"Arial",
SlimDX.DirectWrite.FontWeight.Normal,
SlimDX.DirectWrite.FontStyle.Normal,
SlimDX.DirectWrite.FontStretch.Normal,
24,
"en-US"
);
textFormat.TextAlignment = SlimDX.DirectWrite.TextAlignment.Center;
textFormat.ParagraphAlignment = SlimDX.DirectWrite.ParagraphAlignment.Center;
// Query for a IDXGISurface.
// DirectWrite and DirectX10 can interoperate thru DXGI.
var surface = textureD3D10.AsSurface();
var rtp = new SlimDX.Direct2D.RenderTargetProperties();
rtp.MinimumFeatureLevel = SlimDX.Direct2D.FeatureLevel.Direct3D10;
rtp.Type = SlimDX.Direct2D.RenderTargetType.Hardware;
rtp.Usage = SlimDX.Direct2D.RenderTargetUsage.None;
rtp.PixelFormat = new SlimDX.Direct2D.PixelFormat(SlimDX.DXGI.Format.Unknown, SlimDX.Direct2D.AlphaMode.Premultiplied);
dwRenderTarget = SlimDX.Direct2D.RenderTarget.FromDXGI(d2Factory, surface, rtp);
// Brush used to DrawText
brushSolidWhite = new SlimDX.Direct2D.SolidColorBrush(
dwRenderTarget,
new SlimDX.Color4(1, 1, 1, 1)
);
// Think of the shared textureD3D10 as an overlay.
// The overlay needs to show the text but let the underlying triangle (or whatever)
// show thru, which is accomplished by blending.
var bsd = new SlimDX.Direct3D11.BlendStateDescription();
bsd.RenderTargets[0].BlendEnable = true;
bsd.RenderTargets[0].SourceBlend = SlimDX.Direct3D11.BlendOption.SourceAlpha;
bsd.RenderTargets[0].DestinationBlend = SlimDX.Direct3D11.BlendOption.InverseSourceAlpha;
bsd.RenderTargets[0].BlendOperation = SlimDX.Direct3D11.BlendOperation.Add;
bsd.RenderTargets[0].SourceBlendAlpha = SlimDX.Direct3D11.BlendOption.One;
bsd.RenderTargets[0].DestinationBlendAlpha = SlimDX.Direct3D11.BlendOption.Zero;
bsd.RenderTargets[0].BlendOperationAlpha = SlimDX.Direct3D11.BlendOperation.Add;
bsd.RenderTargets[0].RenderTargetWriteMask = SlimDX.Direct3D11.ColorWriteMaskFlags.All;
BlendState_Transparent = SlimDX.Direct3D11.BlendState.FromDescription(device.Handle, bsd);
// Load Effect. This includes both the vertex and pixel shaders.
// Also can include more than one technique.
var shaderByteCode = SlimDX.D3DCompiler.ShaderBytecode.CompileFromFile(
"texteffect.fx",
"fx_5_0",
SlimDX.D3DCompiler.ShaderFlags.EnableStrictness,
SlimDX.D3DCompiler.EffectFlags.None);
effect = new SlimDX.Direct3D11.Effect(device.Handle, shaderByteCode);
// create triangle vertex data, making sure to rewind the stream afterward
var verticesTriangle = new SlimDX.DataStream(30 * 3, true, true);
verticesTriangle.Write(new SlimDX.Vector3(0.0f, 0.5f, 0.5f));
verticesTriangle.Write(new SlimDX.Color4(1.0f, 0.0f, 0.0f, 1.0f));
verticesTriangle.Write(new SlimDX.Vector3(0.5f, -0.5f, 0.5f));
verticesTriangle.Write(new SlimDX.Color4(0.0f, 1.0f, 0.0f, 1.0f));
verticesTriangle.Write(new SlimDX.Vector3(-0.5f, -0.5f, 0.5f));
verticesTriangle.Write(new SlimDX.Color4(0.0f, 0.0f, 1.0f, 1.0f));
verticesTriangle.Position = 0;
// create the triangle vertex layout and buffer
var inputElements = new SlimDX.Direct3D11.InputElement[] {
new SlimDX.Direct3D11.InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 0, 0),
new SlimDX.Direct3D11.InputElement("COLOR",0,SlimDX.DXGI.Format.R32G32B32A32_Float,16,0)
};
var layoutColor = new SlimDX.Direct3D11.InputLayout(device.Handle, effect.GetTechniqueByName("Color").GetPassByIndex(0).Description.Signature, inputElements);
var vertexBufferColor = new SlimDX.Direct3D11.Buffer(device.Handle, verticesTriangle, (int)verticesTriangle.Length, SlimDX.Direct3D11.ResourceUsage.Default, SlimDX.Direct3D11.BindFlags.VertexBuffer, SlimDX.Direct3D11.CpuAccessFlags.None, SlimDX.Direct3D11.ResourceOptionFlags.None, 0);
verticesTriangle.Close();
// create text vertex data, making sure to rewind the stream afterward
// Top Left of screen is -1, +1
// Bottom Right of screen is +1, -1
var verticesText = new SlimDX.DataStream(30 * 4, true, true);
verticesText.Write(new SlimDX.Vector3(-1, 1, 0));
verticesText.Write(new SlimDX.Vector2(0, 0f));
verticesText.Write(new SlimDX.Vector3(1, 1, 0));
verticesText.Write(new SlimDX.Vector2(1, 0));
verticesText.Write(new SlimDX.Vector3(-1, -1, 0));
verticesText.Write(new SlimDX.Vector2(0, 1));
verticesText.Write(new SlimDX.Vector3(1, -1, 0));
verticesText.Write(new SlimDX.Vector2(1, 1));
verticesText.Position = 0;
// create the text vertex layout and buffer
layoutText = new SlimDX.Direct3D11.InputLayout(device.Handle, effect.GetTechniqueByName("Text").GetPassByIndex(0).Description.Signature, inputElements);
vertexBufferText = new SlimDX.Direct3D11.Buffer(device.Handle, verticesText, (int)verticesText.Length, SlimDX.Direct3D11.ResourceUsage.Default, SlimDX.Direct3D11.BindFlags.VertexBuffer, SlimDX.Direct3D11.CpuAccessFlags.None, SlimDX.Direct3D11.ResourceOptionFlags.None, 0);
verticesText.Close();
}
}
}
public static DX11Texture2D CreateImmutable(DX11RenderContext context, int width, int height, SlimDX.DXGI.Format format, int pitch, SlimDX.DataStream initialData)
{
Texture2DDescription desc = new Texture2DDescription()
{
ArraySize = 1,
BindFlags = BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
Format = format,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Immutable,
Width = width
};
SlimDX.DataRectangle dataRectangle = new SlimDX.DataRectangle(pitch, initialData);
Texture2D texture = new Texture2D(context.Device, desc, dataRectangle);
try
{
ShaderResourceView shaderView = new ShaderResourceView(context.Device, texture);
return(TakeOwnership(context, texture, shaderView));
}
catch
{
texture.Dispose(); //Avoid partial leak in case of failure, that should be really rare but could happen
throw;
}
}
public static DX11Texture2D CreateImmutable(DX11RenderContext context, int width, int height, SlimDX.DXGI.Format format, int pitch, IntPtr initialData)
{
var dataStream = new SlimDX.DataStream(initialData, pitch * height, true, false);
return(CreateImmutable(context, width, height, format, pitch, dataStream));
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
for (int i = 0; i < this.FOutput.SliceCount; i++)
{
if (this.FOutput[i].Contains(context))
{
this.FOutput[i].Dispose(context);
}
}
if (this.FBodies.SliceCount > 0)
{
int cnt = this.FBodies.SliceCount;
for (int i = 0; i < cnt; i++)
{
SoftBody body = this.FBodies[i];
SoftBodyCustomData sc = (SoftBodyCustomData)body.UserObject;
AlignedFaceArray faces = body.Faces;
if (FValid[i])
{
if (body.Faces.Count > 0)
{
#region Build from Faces
DX11IndexedGeometry geom = new DX11IndexedGeometry(context);
geom.VerticesCount = faces.Count * 3;
if (sc.HasUV)
{
geom.InputLayout = Pos3Norm3Tex2Vertex.Layout;
geom.VertexSize = Pos3Norm3Tex2Vertex.VertexSize;
}
else
{
geom.InputLayout = Pos3Norm3Vertex.Layout;
geom.VertexSize = Pos3Norm3Vertex.VertexSize;
}
//Mesh mesh = new Mesh(OnDevice, faces.Count, faces.Count * 3, MeshFlags.SystemMemory | MeshFlags.Use32Bit, decl);
SlimDX.DataStream verts = new SlimDX.DataStream(geom.VerticesCount * geom.VertexSize * 3, false, true);
SlimDX.DataStream indices = new SlimDX.DataStream(faces.Count * sizeof(int) * 3, false, true);
int j;
int uvcnt = 0;
for (j = 0; j < faces.Count; j++)
{
NodePtrArray nodes = faces[j].N;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
indices.Write(j * 3);
indices.Write(j * 3 + 1);
indices.Write(j * 3 + 2);
}
geom.VertexBuffer = BufferHelper.CreateVertexBuffer(context, verts, false, true);
geom.HasBoundingBox = false;
DX11IndexBuffer ibo = new DX11IndexBuffer(context, indices, false, true);
geom.IndexBuffer = ibo;
this.FOutput[i][context] = geom;
#endregion
}
}
}
}
}
protected override DX11VertexGeometry GetGeom(DX11RenderContext device, int slice)
{
if (d2dFactory == null)
{
d2dFactory = new D2DFactory();
dwFactory = new DWriteFactory(SharpDX.DirectWrite.FactoryType.Shared);
}
TextFormat fmt = new TextFormat(dwFactory, this.FFontInput[slice].Name, FFontSize[slice]);
TextLayout tl = new TextLayout(dwFactory, FText[slice], fmt, 0.0f, 32.0f);
tl.WordWrapping = WordWrapping.NoWrap;
tl.TextAlignment = FHAlignment[slice];
tl.ParagraphAlignment = FVAlignment[slice];
OutlineRenderer renderer = new OutlineRenderer(d2dFactory);
Extruder ex = new Extruder(d2dFactory);
tl.Draw(renderer, 0.0f, 0.0f);
var result = ex.GetVertices(renderer.GetGeometry(), this.FExtrude[slice]);
Vector3 min = new Vector3(float.MaxValue);
Vector3 max = new Vector3(float.MinValue);
result.ForEach(pn =>
{
min.X = pn.Position.X < min.X ? pn.Position.X : min.X;
min.Y = pn.Position.Y < min.Y ? pn.Position.Y : min.Y;
min.Z = pn.Position.Z < min.Z ? pn.Position.Z : min.Z;
max.X = pn.Position.X > max.X ? pn.Position.X : max.X;
max.Y = pn.Position.Y > max.Y ? pn.Position.Y : max.Y;
max.Z = pn.Position.Z > max.Z ? pn.Position.Z : max.Z;
});
SlimDX.DataStream ds = new SlimDX.DataStream(result.Count * Pos3Norm3VertexSDX.VertexSize, true, true);
ds.Position = 0;
ds.WriteRange(result.ToArray());
ds.Position = 0;
var vbuffer = new SlimDX.Direct3D11.Buffer(device.Device, ds, new SlimDX.Direct3D11.BufferDescription()
{
BindFlags = SlimDX.Direct3D11.BindFlags.VertexBuffer,
CpuAccessFlags = SlimDX.Direct3D11.CpuAccessFlags.None,
OptionFlags = SlimDX.Direct3D11.ResourceOptionFlags.None,
SizeInBytes = (int)ds.Length,
Usage = SlimDX.Direct3D11.ResourceUsage.Default
});
ds.Dispose();
DX11VertexGeometry vg = new DX11VertexGeometry(device);
vg.InputLayout = Pos3Norm3VertexSDX.Layout;
vg.Topology = SlimDX.Direct3D11.PrimitiveTopology.TriangleList;
vg.VertexBuffer = vbuffer;
vg.VertexSize = Pos3Norm3VertexSDX.VertexSize;
vg.VerticesCount = result.Count;
vg.HasBoundingBox = true;
vg.BoundingBox = new SlimDX.BoundingBox(new SlimDX.Vector3(min.X, min.Y, min.Z), new SlimDX.Vector3(max.X, max.Y, max.Z));
return vg;
}
protected override BulletMesh CreateMesh(Device device)
{
if (this.ms == null)
{
byte[] terr = new byte[this.w * this.l * 4];
ms = new MemoryStream(terr);
BinaryWriter writer = new BinaryWriter(ms);
for (int i = 0; i < this.w * this.l; i++)
{
writer.Write(this.h[i]);
}
writer.Flush();
}
ms.Position = 0;
BinaryReader reader = new BinaryReader(ms);
int totalTriangles = (this.w - 1) * (this.l - 1) * 2;
int totalVerts = this.w * this.l;
Mesh m = new Mesh(device, totalTriangles, totalVerts, MeshFlags.Use32Bit | MeshFlags.SystemMemory, VertexFormat.Position | VertexFormat.Normal);
SlimDX.DataStream data = m.LockVertexBuffer(LockFlags.None);
float center = (maxh + minh) / 2.0f;
center = -center;
for (int i = 0; i < this.w; i++)
{
for (int j = 0; j < this.l; j++)
{
float height = reader.ReadSingle();
data.Write((j - (this.l - 1) * 0.5f));
data.Write(height + center);
data.Write((i - (this.w - 1) * 0.5f));
data.Write(0.0f);
data.Write(0.0f);
data.Write(0.0f);
}
}
m.UnlockVertexBuffer();
data = m.LockIndexBuffer(LockFlags.None);
for (int i = 0; i < this.w - 1; i++)
{
for (int j = 0; j < this.l - 1; j++)
{
data.Write(j * this.w + i);
data.Write(j * this.w + i + 1);
data.Write((j + 1) * this.w + i + 1);
data.Write(j * this.w + i);
data.Write((j + 1) * this.w + i + 1);
data.Write((j + 1) * this.w + i);
}
}
m.UnlockIndexBuffer();
m.ComputeNormals();
return(new BulletMesh(m));
}
private SlimDX.Direct2D.Bitmap loadBitmap(Bitmap drawingBitmap)
{
SlimDX.Direct2D.Bitmap result = null;
if (drawingBitmap == null)
return null;
if (gr.Contains(drawingBitmap))
return gb[gr.IndexOf(drawingBitmap)];
else
gr.Add(drawingBitmap);
//Lock the gdi resource
BitmapData drawingBitmapData = drawingBitmap.LockBits(
new Rectangle(0, 0, drawingBitmap.Width, drawingBitmap.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppPArgb);
//Prepare loading the image from gdi resource
SlimDX.DataStream dataStream = new SlimDX.DataStream(drawingBitmapData.Scan0, drawingBitmapData.Stride * drawingBitmapData.Height, true, false);
SlimDX.Direct2D.BitmapProperties properties = new SlimDX.Direct2D.BitmapProperties();
properties.PixelFormat = new SlimDX.Direct2D.PixelFormat(SlimDX.DXGI.Format.B8G8R8A8_UNorm, SlimDX.Direct2D.AlphaMode.Premultiplied);
//Load the image from the gdi resource
result = new SlimDX.Direct2D.Bitmap(renderTarget, new Size(drawingBitmap.Width, drawingBitmap.Height), dataStream, drawingBitmapData.Stride, properties);
//Unlock the gdi resource
drawingBitmap.UnlockBits(drawingBitmapData);
gb.Add(result);
return result;
}
public void Update(IPluginIO pin, DX11RenderContext context)
{
for (int i = 0; i < this.FOutput.SliceCount; i++)
{
if (this.FOutput[i].Contains(context)) { this.FOutput[i].Dispose(context); }
}
if (this.FBodies.SliceCount > 0)
{
int cnt = this.FBodies.SliceCount;
for (int i = 0; i < cnt; i++)
{
SoftBody body = this.FBodies[i];
SoftBodyCustomData sc = (SoftBodyCustomData)body.UserObject;
AlignedFaceArray faces = body.Faces;
if (FValid[i])
{
if (body.Faces.Count > 0)
{
#region Build from Faces
DX11IndexedGeometry geom = new DX11IndexedGeometry(context);
geom.VerticesCount = faces.Count*3;
if (sc.HasUV)
{
geom.InputLayout = Pos3Norm3Tex2Vertex.Layout;
geom.VertexSize = Pos3Norm3Tex2Vertex.VertexSize;
}
else
{
geom.InputLayout = Pos3Norm3Vertex.Layout;
geom.VertexSize = Pos3Norm3Vertex.VertexSize;
}
//Mesh mesh = new Mesh(OnDevice, faces.Count, faces.Count * 3, MeshFlags.SystemMemory | MeshFlags.Use32Bit, decl);
SlimDX.DataStream verts = new SlimDX.DataStream(geom.VerticesCount * geom.VertexSize*3, false, true);
SlimDX.DataStream indices = new SlimDX.DataStream(faces.Count * sizeof(int)*3, false, true);
int j;
int uvcnt = 0;
for (j = 0; j < faces.Count; j++)
{
NodePtrArray nodes = faces[j].N;
verts.Write(nodes[0].X);
verts.Write(nodes[0].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[1].X);
verts.Write(nodes[1].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
verts.Write(nodes[2].X);
verts.Write(nodes[2].Normal);
//verts.Position += 12;
if (sc.HasUV)
{
verts.Write(sc.UV[uvcnt]);
uvcnt++;
verts.Write(sc.UV[uvcnt]);
uvcnt++;
}
indices.Write(j * 3);
indices.Write(j * 3 + 1);
indices.Write(j * 3 + 2);
}
geom.VertexBuffer = BufferHelper.CreateVertexBuffer(context, verts, false, true);
geom.HasBoundingBox = false;
DX11IndexBuffer ibo = new DX11IndexBuffer(context, indices,false,true);
geom.IndexBuffer = ibo;
this.FOutput[i][context] = geom;
#endregion
}
}
}
}
}
public static SlimDX.Direct3D11.Buffer CreateVertexBuffer(
SlimDX.Direct3D11.Device graphicsDevice,
System.Array vertices
)
{
using (SlimDX.DataStream vertexStream
= new SlimDX.DataStream(vertices, true, true))
{
return new SlimDX.Direct3D11.Buffer(
graphicsDevice,
vertexStream,
new BufferDescription
{
SizeInBytes = (int)vertexStream.Length,
BindFlags = BindFlags.VertexBuffer,
}
);
}
}
public void Play(IPlayable wave)
{
lock (mutex)
{
if (wave == current)
{
if (isPaused)
{
sourceVoice.Start();
isPaused = false;
return;
}
}
DisposeWave();
xaudio.CommitChanges();
isPaused = false;
current = wave;
currentStream = wave as IPlayableStream;
if (decodeThread != null)
{
System.Threading.Monitor.Pulse(mutex);
decodeThread = null;
}
if (currentStream == null)
{
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
dataStream = new SlimDX.DataStream(wave.WaveData, true, false);
audioBuffer = new SlimDX.XAudio2.AudioBuffer();
audioBuffer.AudioData = dataStream;
audioBuffer.AudioBytes = wave.WaveData.Length;
audioBuffer.Flags = BufferFlags.EndOfStream;
sourceVoice.SubmitSourceBuffer(audioBuffer);
sourceVoice.Start();
}
else
{
streamLength = currentStream.StreamLength;
streamBuffered = 0;
sourceVoice = new SourceVoice(xaudio, wave.WaveFormat);
sourceVoice.BufferEnd += bufferEndCallback;
// Fill buffers initially
bool isDone = false;
for (var i = 0; i < NumStreamingBuffers; i++)
{
isDone = FillBuffer(i, currentStream);
if (isDone)
{
break;
}
}
sourceVoice.Start();
if (!isDone)
{
System.Threading.ParameterizedThreadStart threadProc = DecoderThread;
decodeThread = new System.Threading.Thread(threadProc);
decodeThread.Name = "Vorbis Decoder Thread";
decodeThread.Start(currentStream);
}
}
}
}
void SetupDataAndInfo()
{
int PageTableSizeLog2 = MathExtensions.Log2(info.PageTableSize);
tabledata = new SlimDX.DataBox[PageTableSizeLog2+1];
regions = new D3D10.ResourceRegion[PageTableSizeLog2+1];
data = new SimpleImage[PageTableSizeLog2+1];
for( int i = 0; i < PageTableSizeLog2+1; ++i )
{
int size = info.PageTableSize >> i;
SlimDX.DataStream stream = new SlimDX.DataStream( size * size * VirtualTexture.ChannelCount, false, true );
tabledata[i] = new SlimDX.DataBox( size * VirtualTexture.ChannelCount, size * size * VirtualTexture.ChannelCount, stream );
D3D10.ResourceRegion region = new D3D10.ResourceRegion();
region.Left = 0; region.Right = size;
region.Top = 0; region.Bottom = size;
region.Front = 0; region.Back = 1;
regions[i] = region;
data[i] = new SimpleImage( size, size, VirtualTexture.ChannelCount );
}
}
public int Direct3D9Device_EndScene(IntPtr devicePtr)
{
try
{
_D3D9Device = SlimDX.Direct3D9.Device.FromPointer(devicePtr);
if (_renderTarget == null)
{
// Create offscreen surface to use as copy of render target data
using (SwapChain sc = _D3D9Device.GetSwapChain(0))
{
// TODO: pass in a width and height
_renderTarget = Surface.CreateOffscreenPlain(_D3D9Device, sc.PresentParameters.BackBufferWidth, sc.PresentParameters.BackBufferHeight, sc.PresentParameters.BackBufferFormat, Pool.SystemMemory);
_targetNoMultiSample = Surface.CreateRenderTarget(_D3D9Device, sc.PresentParameters.BackBufferWidth, sc.PresentParameters.BackBufferHeight, sc.PresentParameters.BackBufferFormat, MultisampleType.None, 0, false);
_bufferFormat = sc.PresentParameters.BackBufferFormat;
_Rect = new Rectangle(0, 0, sc.PresentParameters.BackBufferWidth, sc.PresentParameters.BackBufferHeight);
}
}
// Lets mess with the scene now ;)
using (Surface backBuffer = _D3D9Device.GetBackBuffer(0, 0))
{
_D3D9Device.StretchRectangle(backBuffer, _Rect, _targetNoMultiSample, _Rect, TextureFilter.Linear);
_D3D9Device.GetRenderTargetData(_targetNoMultiSample, _renderTarget);
SlimDX.DataRectangle dataRect = _renderTarget.LockRectangle(LockFlags.None);
SlimDX.DataStream dataStream = dataRect.Data;
int height = _renderTarget.Description.Height;
int width = _renderTarget.Description.Width;
int k = height - 1;
int iSrcPitch = dataRect.Pitch;
IntPtr data = dataStream.DataPointer;
unsafe
{
byte *pSrcRow = (byte *)data.ToPointer();
for (int i = 0; i < height; i++)
{
if (k < 0)
{
break;
}
for (int j = 0; j < width; j++)
{
// toon shade the game pixels here..
pSrcRow[i * iSrcPitch + j * 4] = _map[(int)pSrcRow[i * iSrcPitch + j * 4]];
pSrcRow[i * iSrcPitch + j * 4 + 1] = _map[(int)pSrcRow[i * iSrcPitch + j * 4 + 1]];
pSrcRow[i * iSrcPitch + j * 4 + 2] = _map[(int)pSrcRow[i * iSrcPitch + j * 4 + 2]];
}
}
}
_renderTarget.UnlockRectangle();
_D3D9Device.UpdateSurface(_renderTarget, _targetNoMultiSample);
_D3D9Device.StretchRectangle(_targetNoMultiSample, backBuffer, TextureFilter.Linear);
}
}
catch (Exception ex)
{
// TODO: something useful
System.IO.File.AppendAllText("C:\\tmp\\_hook.txt", ex.Message + ex.StackTrace);
}
return(0);
}
