public VertexBufferBuilder(int positionsCount, VertexDescriptor vd)
{
this._vd = vd;
_taken = new bool[positionsCount];
_vertices = new List <VertexCache> [positionsCount];
_vertexBufferData = new MemoryStream(positionsCount * vd.Size);
}
public void Initialize()
{
var positions = new List <Vector3>();
var indices = new List <int>();
_vd = VertexDescriptor.GetDescriptor <VertexP>(); // new VertexDescriptor(new VertexDeclaration(GGraphicDeviceFactory.Device, VertexP.Elements));
_BuildGeoSphere(_subdivitions, 1, positions, indices);
_vertices = new VertexP[positions.Count];
for (int i = 0; i < positions.Count; i++)
{
_vertices[i] = new VertexP(positions[i]);
}
this._indices = new ushort[indices.Count];
for (int i = 0; i < indices.Count; i++)
{
this._indices[i] = (ushort)indices[i];
}
if (_vb != null)
{
_vb.Dispose();
}
_vb = GraphicDeviceFactory.Device.CreateVertexBuffer(data: _vertices);
if (_ib != null)
{
_ib.Dispose();
}
_ib = GraphicDeviceFactory.Device.CreateIndexBuffer(data: this._indices);
}
public Effect(
GraphicsDevice graphicsDevice,
string shaderName,
VertexDescriptor vertexDescriptor)
{
_graphicsDevice = graphicsDevice;
ID = _nextID++;
using (var shaderStream = typeof(Effect).Assembly.GetManifestResourceStream($"OpenSage.Graphics.Shaders.{shaderName}.fxo"))
using (var shaderReader = new BinaryReader(shaderStream))
{
var vertexShaderBytecodeLength = shaderReader.ReadInt32();
var vertexShaderBytecode = shaderReader.ReadBytes(vertexShaderBytecodeLength);
_vertexShader = AddDisposable(new Shader(graphicsDevice, shaderName + "VS", vertexShaderBytecode));
var pixelShaderBytecodeLength = shaderReader.ReadInt32();
var pixelShaderBytecode = shaderReader.ReadBytes(pixelShaderBytecodeLength);
_pixelShader = AddDisposable(new Shader(graphicsDevice, shaderName + "PS", pixelShaderBytecode));
}
_cachedPipelineStates = new Dictionary <EffectPipelineStateHandle, PipelineState>();
_vertexDescriptor = vertexDescriptor;
_parameters = _vertexShader.ResourceBindings
.Concat(_pixelShader.ResourceBindings)
.Select(x => AddDisposable(new EffectParameter(graphicsDevice, x)))
.ToDictionary(x => x.Name);
}
public void SetVertexData <T>(ArraySegment <T> vertexData, VertexDescriptor descriptor, int destinationOffsetInVertices) where T : struct
{
Stride = descriptor.VertexSizeInBytes;
int byteOffset = Unsafe.SizeOf <T>() * destinationOffsetInVertices;
SetData(vertexData, byteOffset);
}
public void SetVertexData(IntPtr vertexData, VertexDescriptor descriptor, int numVertices)
{
Stride = descriptor.VertexSizeInBytes;
int dataSizeInBytes = numVertices * descriptor.VertexSizeInBytes;
SetData(vertexData, dataSizeInBytes);
}
public void VertexDescriptor_Constructor_PopulatesPropertries()
{
int vertex = 10;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex);
Assert.Equal(vertex, vertexDescriptor.Vertex);
}
public void SetVertexData(IntPtr vertexData, VertexDescriptor descriptor, int numVertices, int destinationOffsetInVertices)
{
int dataSizeInBytes = numVertices * descriptor.VertexSizeInBytes;
int destinationOffsetInBytes = destinationOffsetInVertices * descriptor.VertexSizeInBytes;
SetData(vertexData, dataSizeInBytes, destinationOffsetInBytes);
}
private unsafe void ComputeXZRadius(IntPtr vbStream, out Vector3 centerXz, out float radius, out Vector3 center, out int nbZeroDistance)
{
centerXz = new Vector3();
radius = float.MinValue;
nbZeroDistance = 0;
int posOffset = VertexDescriptor.OffsetOf(IASemantic.Position, 0);
int size = VertexDescriptor.Size;
byte *vbPter = (byte *)vbStream + posOffset;
for (int i = 0; i < _vertexCount; i++)
{
centerXz += *(Vector3 *)(vbPter + size * i);
}
centerXz *= 1f / (float)_vertexCount;
center = centerXz;
centerXz.Y = 0;
for (int i = 0; i < _vertexCount; i++)
{
Vector3 point = *(Vector3 *)(vbPter + size * i);
point.Y = 0;
float distance = Vector3.Distance(point, centerXz);
if (distance == 0 || distance.IsZero())
{
nbZeroDistance++;
}
radius = Math.Max(radius, distance);
}
}
private static VertexDescriptor CreateVertexDescriptor()
{
var vertexDescriptor = new VertexDescriptor();
vertexDescriptor.SetAttributeDescriptor(InputClassification.PerVertexData, 0, "POSITION", 0, VertexFormat.Float3, 0, 0);
vertexDescriptor.SetAttributeDescriptor(InputClassification.PerVertexData, 1, "NORMAL", 0, VertexFormat.Float3, 0, 12);
vertexDescriptor.SetAttributeDescriptor(InputClassification.PerVertexData, 2, "TEXCOORD", 0, VertexFormat.Float2, 0, 24);
vertexDescriptor.SetLayoutDescriptor(0, 32);
return(vertexDescriptor);
}
public unsafe bool IsPlane(out Plane plane)
{
plane = new Plane();
if (_faceCount != 2)
{
return(false);
}
var vbStream = _vb.Map(MapType.Read);
var ibStream = _ib.Map(MapType.Read);
Plane *planes = stackalloc Plane[2];
try
{
int posOffset = VertexDescriptor.OffsetOf(IASemantic.Position, 0);
int size = VertexDescriptor.Size;
byte *vbPter = (byte *)vbStream + posOffset;
byte *ibPter = (byte *)ibStream;
for (int iface = 0; iface < _faceCount; iface++)
{
Vector3 p0;
Vector3 p1;
Vector3 p2;
if (_is16BitIndices)
{
p0 = *(Vector3 *)(vbPter + size * ((short *)ibPter)[iface * 3]);
p1 = *(Vector3 *)(vbPter + size * ((short *)ibPter)[iface * 3 + 1]);
p2 = *(Vector3 *)(vbPter + size * ((short *)ibPter)[iface * 3 + 2]);
}
else
{
p0 = *(Vector3 *)(vbPter + size * ((int *)ibPter)[iface * 3]);
p1 = *(Vector3 *)(vbPter + size * ((int *)ibPter)[iface * 3 + 1]);
p2 = *(Vector3 *)(vbPter + size * ((int *)ibPter)[iface * 3 + 2]);
}
planes[iface] = new Plane(p0, p1, p2);
}
}
finally
{
_vb.Unmap();
_ib.Unmap();
}
if (Plane.Equals(planes[0], planes[1]))
{
plane = planes[0];
return(true);
}
return(false);
}
public void VertexDescriptor_AddEdge_FailsByAttemptToAddEdgeWithWrongVertices()
{
int vertex1 = 10;
int vertex2 = 20;
int vertex3 = 30;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex3);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
}
public unsafe bool IsCylindre(out float radius, out float height, out Vector3 center)
{
radius = 0;
height = 0;
center = new Vector3();
if (_vertexCount == 0 || _faceCount <= 12)
{
return(false);
}
var vbStream = _vb.Map(MapType.Read);
int posOffset = VertexDescriptor.OffsetOf(IASemantic.Position, 0);
int size = VertexDescriptor.Size;
float distance;
float maxY = float.MinValue;
float minY = float.MaxValue;
byte *vbPter = (byte *)vbStream + posOffset;
Vector3 xzCenter;
float xzRadius;
int nb;
ComputeXZRadius(vbStream, out xzCenter, out xzRadius, out center, out nb);
xzCenter.Y = 0;
bool result = true;
for (int i = 0; i < _vertexCount; i++)
{
Vector3 point = *(Vector3 *)(vbPter + size * i);
maxY = Math.Max(maxY, point.Y);
minY = Math.Min(minY, point.Y);
point.Y = 0;
distance = Vector3.Distance(point, xzCenter);
if (!distance.IsEqual(xzRadius) && !distance.IsZero())
{
result = false;
break;
}
}
radius = xzRadius;
height = maxY - minY;
_vb.Unmap();
return(result);
}
private void InitializeContextObjects(RenderContext context)
{
s_currentContext = context;
ResourceFactory factory = context.ResourceFactory;
s_vb0 = factory.CreateVertexBuffer(12 * s_cubeVertices.Length, false);
VertexDescriptor desc = new VertexDescriptor(12, 1, 0, IntPtr.Zero);
s_vb0.SetVertexData(s_cubeVertices.Select(vpc => vpc.Position).ToArray(), desc);
s_vb1 = factory.CreateVertexBuffer(16 * s_cubeVertices.Length, false);
VertexDescriptor desc2 = new VertexDescriptor(16, 1, 0, IntPtr.Zero);
s_vb1.SetVertexData(s_cubeVertices.Select(vpc => vpc.Color).ToArray(), desc2);
s_ib = factory.CreateIndexBuffer(sizeof(int) * s_cubeIndices.Length, false);
s_ib.SetIndices(s_cubeIndices);
MaterialVertexInput materialInputs0 = new MaterialVertexInput(
12,
new MaterialVertexInputElement[]
{
new MaterialVertexInputElement("in_position", VertexSemanticType.Position, VertexElementFormat.Float3),
});
MaterialVertexInput materialInputs1 = new MaterialVertexInput(
16,
new MaterialVertexInputElement[]
{
new MaterialVertexInputElement("in_color", VertexSemanticType.Color, VertexElementFormat.Float4)
});
MaterialInputs <MaterialGlobalInputElement> globalInputs = new MaterialInputs <MaterialGlobalInputElement>(
new MaterialGlobalInputElement[]
{
new MaterialGlobalInputElement("ProjectionMatrixBuffer", MaterialInputType.Matrix4x4, "ProjectionMatrix")
});
MaterialInputs <MaterialPerObjectInputElement> perObjectInputs = new MaterialInputs <MaterialPerObjectInputElement>(
new MaterialPerObjectInputElement[]
{
new MaterialPerObjectInputElement("ModelViewMatrixBuffer", MaterialInputType.Matrix4x4, _modelViewProvider.DataSizeInBytes)
});
s_material = factory.CreateMaterial(
context,
VertexShaderSource,
FragmentShaderSource,
materialInputs0,
materialInputs1,
globalInputs,
perObjectInputs,
MaterialTextureInputs.Empty);
}
public Effect GetEffect(string name, VertexDescriptor vertexDescriptor)
{
if (!_effects.TryGetValue(name, out var effect))
{
_effects[name] = effect = AddDisposable(new Effect(
_graphicsDevice,
name,
vertexDescriptor));
}
return(effect);
}
private void InitializeContextObjects(RenderContext context)
{
_currentContext = context;
ResourceFactory factory = context.ResourceFactory;
s_vb = factory.CreateVertexBuffer(VertexPositionNormalTexture.SizeInBytes * _vertices.Length, false);
VertexDescriptor desc = new VertexDescriptor(VertexPositionNormalTexture.SizeInBytes, VertexPositionNormalTexture.ElementCount, 0, IntPtr.Zero);
s_vb.SetVertexData(_vertices, desc);
s_ib = factory.CreateIndexBuffer(sizeof(int) * _indices.Length, false);
s_ib.SetIndices(_indices);
MaterialVertexInput materialInputs = new MaterialVertexInput(
VertexPositionNormalTexture.SizeInBytes,
new MaterialVertexInputElement[]
{
new MaterialVertexInputElement("in_position", VertexSemanticType.Position, VertexElementFormat.Float3),
new MaterialVertexInputElement("in_normal", VertexSemanticType.Normal, VertexElementFormat.Float3),
new MaterialVertexInputElement("in_texCoord", VertexSemanticType.TextureCoordinate, VertexElementFormat.Float2)
});
MaterialInputs <MaterialGlobalInputElement> globalInputs = new MaterialInputs <MaterialGlobalInputElement>(
new MaterialGlobalInputElement[]
{
new MaterialGlobalInputElement("ProjectionMatrixBuffer", MaterialInputType.Matrix4x4, "ProjectionMatrix"),
new MaterialGlobalInputElement("ViewMatrixBuffer", MaterialInputType.Matrix4x4, "ViewMatrix"),
new MaterialGlobalInputElement("LightBuffer", MaterialInputType.Custom, "LightBuffer"),
});
MaterialInputs <MaterialPerObjectInputElement> perObjectInputs = new MaterialInputs <MaterialPerObjectInputElement>(
new MaterialPerObjectInputElement[]
{
new MaterialPerObjectInputElement("WorldMatrixBuffer", MaterialInputType.Matrix4x4, _worldProvider.DataSizeInBytes),
new MaterialPerObjectInputElement("InverseTransposeWorldMatrixBuffer", MaterialInputType.Matrix4x4, _inverseTransposeWorldProvider.DataSizeInBytes),
});
MaterialTextureInputs textureInputs = new MaterialTextureInputs(
new MaterialTextureInputElement[]
{
new TextureDataInputElement("surfaceTexture", _texture)
});
s_material = factory.CreateMaterial(
context,
VertexShaderSource,
FragmentShaderSource,
materialInputs,
globalInputs,
perObjectInputs,
textureInputs);
s_wireframeRasterizerState = factory.CreateRasterizerState(FaceCullingMode.None, TriangleFillMode.Wireframe, true, true);
}
public void VertexDescriptor_AddEdge_AddsDescriptorToEdges()
{
int vertex1 = 10;
int vertex2 = 20;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex1);
Assert.AreEqual(0, vertexDescriptor.Edges.Count());
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
Assert.IsTrue(vertexDescriptor.Edges.Contains(edgeDesciptor));
}
public void VertexDescriptor_RemoveEdge_FailsByAttemptToAddEdgeWithWrongVertices()
{
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(10);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(10, 20, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
Assert.AreEqual(1, vertexDescriptor.Edges.Count());
EdgeDescriptor <int, string> unrelatedEdgeDesciptor = new EdgeDescriptor <int, string>(100, 200, "edge");
vertexDescriptor.AddEdge(unrelatedEdgeDesciptor);
}
public void VertexDescriptor_RemoveEdge_NoExceptionIfListIsEmpty()
{
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(10);
Assert.Empty(vertexDescriptor.Edges);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(20, 30, "edge");
vertexDescriptor.RemoveEdge(edgeDesciptor);
Assert.Empty(vertexDescriptor.Edges);
}
public void VertexDescriptor_AddEdge_FailsByAttemptToAddEdgeWithWrongVertices()
{
int vertex1 = 10;
int vertex2 = 20;
int vertex3 = 30;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex3);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
var exception = Assert.Throws <InvalidOperationException>(() => vertexDescriptor.AddEdge(edgeDesciptor));
Assert.Equal("Vertex '30' does not belong to the current edge that contains '10' and '20'", exception.Message);
}
public void VertexDescriptor_AddEdge_AddsDescriptorToEdges()
{
int vertex1 = 10;
int vertex2 = 20;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex1);
Assert.Empty(vertexDescriptor.Edges);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
Assert.Contains(edgeDesciptor, vertexDescriptor.Edges);
}
public void VertexDescriptor_RemoveEdge_FailsByAttemptToAddEdgeWithWrongVertices()
{
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(10);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(10, 20, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
Assert.Single(vertexDescriptor.Edges);
EdgeDescriptor <int, string> unrelatedEdgeDesciptor = new EdgeDescriptor <int, string>(100, 200, "edge");
var exception = Assert.Throws <InvalidOperationException>(() => vertexDescriptor.AddEdge(unrelatedEdgeDesciptor));
Assert.Equal("Vertex '10' does not belong to the current edge that contains '100' and '200'", exception.Message);
}
public static Mesh CreateMesh <TVert, TInd>(TVert[] vertices, TInd[] indices)
where TVert : struct
where TInd : struct
{
Mesh mesh = new Mesh(VertexDescriptor.GetDescriptor <TVert>());
mesh.Layers = new MeshPart[] { new MeshPart(0, indices.Length / 3, 0, vertices.Length, 0) };
mesh.MaterialSlotNames = new string[] { "Material0" };
mesh.CreateVertexBuffer(vertices);
mesh.CreateIndexBuffer <TInd>(indices);
mesh.ComputeBoundingVolumenes();
return(mesh);
}
private void InitializeContextObjects(RenderContext context)
{
_currentContext = context;
ResourceFactory factory = context.ResourceFactory;
_vb = factory.CreateVertexBuffer(VertexPositionNormalTexture.SizeInBytes * _vertices.Length, false);
VertexDescriptor desc = new VertexDescriptor(
VertexPositionNormalTexture.SizeInBytes,
VertexPositionNormalTexture.ElementCount,
IntPtr.Zero);
_vb.SetVertexData(_vertices, desc);
_ib = factory.CreateIndexBuffer(sizeof(ushort) * _indices.Length, false);
_ib.SetIndices(_indices);
VertexInputDescription materialInputs = new VertexInputDescription(
VertexPositionNormalTexture.SizeInBytes,
new VertexInputElement[]
{
new VertexInputElement("in_position", VertexSemanticType.Position, VertexElementFormat.Float3),
new VertexInputElement("in_normal", VertexSemanticType.Normal, VertexElementFormat.Float3),
new VertexInputElement("in_texCoord", VertexSemanticType.TextureCoordinate, VertexElementFormat.Float2)
});
ShaderResourceDescription[] resources = new[]
{
new ShaderResourceDescription("ProjectionMatrixBuffer", ShaderConstantType.Matrix4x4),
new ShaderResourceDescription("ViewMatrixBuffer", ShaderConstantType.Matrix4x4),
new ShaderResourceDescription("LightBuffer", Unsafe.SizeOf <DirectionalLightBuffer>()),
new ShaderResourceDescription("WorldMatrixBuffer", ShaderConstantType.Matrix4x4),
new ShaderResourceDescription("InverseTransposeWorldMatrixBuffer", ShaderConstantType.Matrix4x4),
new ShaderResourceDescription("surfaceTexture", ShaderResourceType.Texture),
new ShaderResourceDescription("surfaceTexture", ShaderResourceType.Sampler)
};
_material = factory.CreateMaterial(
context,
VertexShaderSource,
FragmentShaderSource,
materialInputs,
resources);
_worldBuffer = factory.CreateConstantBuffer(ShaderConstantType.Matrix4x4);
_inverseTransposeWorldBuffer = factory.CreateConstantBuffer(ShaderConstantType.Matrix4x4);
DeviceTexture2D texture = _texture.CreateDeviceTexture(factory);
_textureBinding = factory.CreateShaderTextureBinding(texture);
s_wireframeRasterizerState = factory.CreateRasterizerState(FaceCullingMode.None, TriangleFillMode.Wireframe, true, true);
}
public void VertexDescriptor_RemoveEdge_RemovesEdgeFromVertex()
{
int vertex1 = 10;
int vertex2 = 20;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex1);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
Assert.Contains(edgeDesciptor, vertexDescriptor.Edges);
vertexDescriptor.RemoveEdge(edgeDesciptor);
Assert.DoesNotContain(edgeDesciptor, vertexDescriptor.Edges);
}
public Mesh(VertexDescriptor vd)
{
if (vd == null)
{
throw new ArgumentNullException("vertex descriptor");
}
this._vd = vd;
var noti = Service.Get <INotificationService>();
if (noti != null)
{
noti.OnObjectCreated(this);
}
}
public void VertexDescriptor_TryFindEdge_ReturnsFalseForWrongVertex()
{
int vertex1 = 10;
int vertex2 = 20;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex1);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
EdgeDescriptor <int, string> foundEdge;
bool result = vertexDescriptor.TryFindEdge(vertex2, vertex1, out foundEdge);
Assert.False(result);
Assert.Equal(default(EdgeDescriptor <int, string>), foundEdge);
}
public void VertexDescriptor_TryFindEdge_ReturnsEdgeByVertex()
{
int vertex1 = 10;
int vertex2 = 20;
VertexDescriptor <int, string> vertexDescriptor = new VertexDescriptor <int, string>(vertex1);
EdgeDescriptor <int, string> edgeDesciptor = new EdgeDescriptor <int, string>(vertex1, vertex2, "edge");
vertexDescriptor.AddEdge(edgeDesciptor);
EdgeDescriptor <int, string> foundEdge;
bool result = vertexDescriptor.TryFindEdge(vertex1, vertex2, out foundEdge);
Assert.True(result);
Assert.Equal(foundEdge, edgeDesciptor);
}
public SceneImportResult LoadSkelletalMesh(string xFile)
{
this.xFile = xFile;
var allocator = new MeshAllocator();
AnimationController aController;
FileStream file = new FileStream(xFile, FileMode.Open, FileAccess.Read);
GFrame frameRoot = (GFrame)Frame.LoadHierarchyFromX(Engine.Graphics, file, MeshFlags.Managed, allocator, null, out aController);
var vd = VertexDescriptor.Get <SkinVertex>();
List <Tuple <Bone, GFrame> > bones = new List <Tuple <Bone, GFrame> >();
Bone root = GetBone(frameRoot, bones);
QuadTreeSceneNode sceneNode = new QuadTreeSceneNode(Path.GetFileNameWithoutExtension(xFile), 10);
foreach (var item in bones)
{
if (item.Item2.MeshContainer != null)
{
var mesh = GetMesh((GMeshContainer)item.Item2.MeshContainer, root, vd);
sceneNode.Add(new SkelletalMeshNode(item.Item2.Name, mesh));
}
}
sceneNode.UpdateLayout(true);
try
{
file.Close();
if (aController != null)
{
aController.Dispose();
}
allocator.DestroyFrame(frameRoot);
root.Dispose();
}
catch (Exception)
{
}
//AnimationCollection animations = new AnimationCollection();
//animations.Load(xFile, model.RootBone);
return(new SceneImportResult {
VisualSceneRoot = sceneNode, BoneRoots = new List <Bone> {
root
}
});
}
public static Mesh CreateCapsule(float height, float radius, int capStacks, int capSlices, int trunkStacks, int trunkSlices)
{
CapsuleBuilder capsule = new CapsuleBuilder(height, radius, capStacks, capSlices, trunkStacks, trunkSlices);
Mesh mesh = new Mesh(VertexDescriptor.GetDescriptor <MeshVertex>());
mesh.Layers = new MeshPart[]
{
new MeshPart(capsule.Top.StartIndex, capsule.Top.PrimitiveCount, capsule.Top.StartVertex, capsule.Top.VertexCount),
new MeshPart(capsule.Cylindre.StartIndex, capsule.Cylindre.PrimitiveCount, capsule.Cylindre.StartVertex, capsule.Cylindre.VertexCount),
new MeshPart(capsule.Bottom.StartIndex, capsule.Bottom.PrimitiveCount, capsule.Bottom.StartVertex, capsule.Bottom.VertexCount)
};
mesh.MaterialSlotNames = new string[] { "Material0" };
mesh.CreateVertexBuffer(capsule.Vertices);
mesh.CreateIndexBuffer(capsule.Indices);
return(mesh);
}
private void InitializeContextObjects(RenderContext context)
{
s_currentContext = context;
ResourceFactory factory = context.ResourceFactory;
s_vb0 = factory.CreateVertexBuffer(12 * s_cubeVertices.Length, false);
VertexDescriptor desc = new VertexDescriptor(12, 1, IntPtr.Zero);
s_vb0.SetVertexData(s_cubeVertices.Select(vpc => vpc.Position).ToArray(), desc);
s_vb1 = factory.CreateVertexBuffer(16 * s_cubeVertices.Length, false);
VertexDescriptor desc2 = new VertexDescriptor(16, 1, IntPtr.Zero);
s_vb1.SetVertexData(s_cubeVertices.Select(vpc => vpc.Color).ToArray(), desc2);
s_ib = factory.CreateIndexBuffer(s_cubeIndices, false);
VertexInputDescription materialInputs0 = new VertexInputDescription(
12,
new VertexInputElement[]
{
new VertexInputElement("in_position", VertexSemanticType.Position, VertexElementFormat.Float3),
});
VertexInputDescription materialInputs1 = new VertexInputDescription(
16,
new VertexInputElement[]
{
new VertexInputElement("in_color", VertexSemanticType.Color, VertexElementFormat.Float4)
});
ShaderResourceDescription[] resources = new[]
{
new ShaderResourceDescription("ProjectionMatrixBuffer", ShaderConstantType.Matrix4x4),
new ShaderResourceDescription("ModelViewMatrixBuffer", ShaderConstantType.Matrix4x4)
};
s_material = factory.CreateMaterial(
context,
VertexShaderSource,
FragmentShaderSource,
materialInputs0,
materialInputs1,
resources);
}
public void Constructor_BindsAttributeInfoForTwoFields_Ok()
{
// Arrange
var gl = Substitute.For<IOpenGL30>();
gl.WhenForAnyArgs(g => g.GenVertexArrays(Arg.Any<int>(), Arg.Any<uint[]>()))
.Do(x => ((uint[])x[1])[0] = 1);
var vertexBuffer = Substitute.For<IVertexBuffer>();
var descriptor = new VertexDescriptor(typeof(TestVertexTwoFields), new[] { new VertexElement("Value", DataType.Float, 1, 0), new VertexElement("ValueInt", DataType.Int, 1, 4) });
// Act
var vertexArray = new VertexArray(gl, new[] { vertexBuffer }, new[] { descriptor });
// Assert
gl.Received().VertexAttribPointer(0, 1, (uint)DataType.Float, GLboolean.False, 8, IntPtr.Zero); // Stride should be size of vertex element.
gl.Received().VertexAttribIPointer(1, 1, (uint)DataType.Int, 8, new IntPtr(4));
}
private MeshSection ReadMeshSection(Stream s)
{
MeshSection r = new MeshSection();
r.Unknown01 = Helpers.ReadInt(s);
r.Unknown02 = Helpers.ReadInt(s);
r.SectionName = SerializeString(s);
r.Unknown03 = Helpers.ReadInt(s);
r.TriangleCount = Helpers.ReadInt(s);
r.StartIndex = Helpers.ReadInt(s);
r.VertexBufferOffset = Helpers.ReadInt(s);
r.VertexCount = Helpers.ReadInt(s);
r.Unknown04 = Helpers.ReadInt(s);
r.Unknown05 = Helpers.ReadInt(s);
r.Unknown06 = Helpers.ReadInt(s);
r.VertexEntries = new List<VertexDescriptor>();
for (int i = 0; i < 16; i++)
{
VertexDescriptor VertexEntry = new VertexDescriptor();
VertexEntry.VertexType = Helpers.ReadShort(s);
VertexEntry.Offset = s.ReadByte();
VertexEntry.Unknown01 = s.ReadByte();
if (VertexEntry.Offset != 0xFF)
r.VertexEntries.Add(VertexEntry);
}
r.VertexStride = Helpers.ReadInt(s);
r.Unknowns2 = new int[19];
for (int i = 0; i < 19; i++)
r.Unknowns2[i] = Helpers.ReadInt(s);
r.SubBoneList = new ushort[0];
return r;
}
