public XnaHardwareVertexBuffer(HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration,
int numVertices, BufferUsage usage, GraphicsDevice dev, bool useSystemMemory,
bool useShadowBuffer)
: base(manager, vertexDeclaration, numVertices, usage, useSystemMemory, useShadowBuffer)
{
_device = dev;
if (!(vertexDeclaration is XnaVertexDeclaration))
{
throw new AxiomException(
"Invalid VertexDeclaration supplied, must be created by HardwareBufferManager.CreateVertexDeclaration()");
}
if (usage == BufferUsage.Dynamic || usage == BufferUsage.DynamicWriteOnly)
{
_buffer = new DynamicVertexBuffer(_device,
((XnaVertexDeclaration)vertexDeclaration).XFGVertexDeclaration,
numVertices, XnaHelper.Convert(usage));
}
else
{
_buffer = new VertexBuffer(_device, ((XnaVertexDeclaration)vertexDeclaration).XFGVertexDeclaration,
numVertices, XnaHelper.Convert(usage));
}
_bufferBytes = new byte[vertexDeclaration.GetVertexSize() * numVertices];
_bufferBytes.Initialize();
}
public XnaHardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration,
int numVertices, BufferUsage usage, GraphicsDevice dev, bool useSystemMemory,
bool useShadowBuffer )
: base( manager, vertexDeclaration, numVertices, usage, useSystemMemory, useShadowBuffer )
{
_device = dev;
if ( !( vertexDeclaration is XnaVertexDeclaration ) )
{
throw new AxiomException(
"Invalid VertexDeclaration supplied, must be created by HardwareBufferManager.CreateVertexDeclaration()" );
}
if ( usage == BufferUsage.Dynamic || usage == BufferUsage.DynamicWriteOnly )
{
_buffer = new DynamicVertexBuffer( _device,
( (XnaVertexDeclaration)vertexDeclaration ).XFGVertexDeclaration,
numVertices, XnaHelper.Convert( usage ) );
}
else
{
_buffer = new VertexBuffer( _device, ( (XnaVertexDeclaration)vertexDeclaration ).XFGVertexDeclaration,
numVertices, XnaHelper.Convert( usage ) );
}
_bufferBytes = new byte[vertexDeclaration.GetVertexSize()*numVertices];
_bufferBytes.Initialize();
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts,
BufferUsage usage, bool useShadowBuffer )
{
Contract.Requires( numVerts > 0 );
#if AXIOM_D3D_MANAGE_BUFFERS
// Override shadow buffer setting; managed buffers are automatically
// backed by system memory
// Don't override shadow buffer if discardable, since then we use
// unmanaged buffers for speed (avoids write-through overhead)
if ( useShadowBuffer && ( usage & BufferUsage.Discardable ) == 0 )
{
useShadowBuffer = false;
// Also drop any WRITE_ONLY so we can read direct
if ( usage == BufferUsage.DynamicWriteOnly )
{
usage = BufferUsage.Dynamic;
}
else if ( usage == BufferUsage.StaticWriteOnly )
{
usage = BufferUsage.Static;
}
}
#endif
var vbuf = new D3D9HardwareVertexBuffer( this, vertexDeclaration, numVerts, usage, false, useShadowBuffer );
lock ( VertexBuffersMutex )
{
vertexBuffers.Add( vbuf );
}
return vbuf;
}
public override HardwareVertexBuffer CreateVertexBuffer(VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer)
{
var buffer = new XnaHardwareVertexBuffer(this, vertexDeclaration, numVerts, usage, _device, false, useShadowBuffer);
lock (VertexBuffersMutex)
vertexBuffers.Add(buffer);
return(buffer);
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer )
{
var vertexBuffer = new GLESHardwareVertexBuffer( this, vertexDeclaration, numVerts, usage, true );
lock ( VertexBuffersMutex )
{
vertexBuffers.Add( vertexBuffer );
}
return vertexBuffer;
}
public void Define( Array controlPointArray, VertexDeclaration declaration, int width, int height,
int uMaxSubdivisionLevel, int vMaxSubdivisionLevel, VisibleSide visibleSide, BufferUsage vbUsage,
BufferUsage ibUsage, bool vbUseShadow, bool ibUseShadow )
{
VertexBufferUsage = vbUsage;
UseVertexShadowBuffer = vbUseShadow;
IndexBufferUsage = ibUsage;
UseIndexShadowBuffer = ibUseShadow;
// Init patch builder
// define the surface
// NB clone the declaration to make it independent
this.vertexDeclaration = (VertexDeclaration)declaration.Clone();
this.patchSurface.DefineSurface( controlPointArray, this.vertexDeclaration, width, height, PatchSurfaceType.Bezier,
uMaxSubdivisionLevel, vMaxSubdivisionLevel, visibleSide );
}
static TerrainPage()
{
terrainVertexDeclaration = HardwareBufferManager.Instance.CreateVertexDeclaration();
// set up the vertex declaration
int vDecOffset = 0;
terrainVertexDeclaration.AddElement(0, vDecOffset, VertexElementType.Float3, VertexElementSemantic.Position);
vDecOffset += VertexElement.GetTypeSize(VertexElementType.Float3);
terrainVertexDeclaration.AddElement(0, vDecOffset, VertexElementType.Float3, VertexElementSemantic.Normal);
vDecOffset += VertexElement.GetTypeSize(VertexElementType.Float3);
terrainVertexDeclaration.AddElement(0, vDecOffset, VertexElementType.Float2, VertexElementSemantic.TexCoords);
vertexSize = terrainVertexDeclaration.GetVertexSize(0) / 4;
}
// ------------------------------------
// ------------------------------------
/// <summary>
/// Creates a new PatchMesh.
/// </summary>
/// <remarks>
/// As defined in <see cref="MeshManager.CreateBezierPatch" />.
/// </remarks>
public PatchMesh(string name, System.Array controlPointBuffer, VertexDeclaration declaration,
int width, int height, int uMaxSubdivisionLevel, int vMaxSubdivisionLevel, VisibleSide visibleSide,
BufferUsage vbUsage, BufferUsage ibUsage, bool vbUseShadow, bool ibUseShadow)
: base(name)
{
vertexBufferUsage = vbUsage;
useVertexShadowBuffer = vbUseShadow;
indexBufferUsage = ibUsage;
useIndexShadowBuffer = ibUseShadow;
// Init patch builder
// define the surface
// NB clone the declaration to make it independent
vertexDeclaration = (VertexDeclaration)declaration.Clone();
patchSurface.DefineSurface(controlPointBuffer, vertexDeclaration, width, height,
PatchSurfaceType.Bezier, uMaxSubdivisionLevel, vMaxSubdivisionLevel, visibleSide);
}
public GLHardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration, int numVertices, BufferUsage usage, bool useShadowBuffer )
: base( manager, vertexDeclaration, numVertices, usage, false, useShadowBuffer )
{
bufferID = 0;
Gl.glGenBuffersARB( 1, out bufferID );
if ( bufferID == 0 )
{
throw new Exception( "Cannot create GL vertex buffer" );
}
Gl.glBindBufferARB( Gl.GL_ARRAY_BUFFER_ARB, bufferID );
// initialize this buffer. we dont have data yet tho
Gl.glBufferDataARB( Gl.GL_ARRAY_BUFFER_ARB, new IntPtr( sizeInBytes ), IntPtr.Zero, GLHelper.ConvertEnum( usage ) ); // TAO 2.0
//Gl.glBufferDataARB( Gl.GL_ARRAY_BUFFER_ARB, sizeInBytes, IntPtr.Zero, GLHelper.ConvertEnum( usage ) );
}
public HardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration, int numVertices,
BufferUsage usage, bool useSystemMemory, bool useShadowBuffer )
: base( usage, useSystemMemory, useShadowBuffer )
{
this.vertexDeclaration = vertexDeclaration;
this.numVertices = numVertices;
this.Manager = manager;
// calculate the size in bytes of this buffer
sizeInBytes = vertexDeclaration.GetVertexSize()*numVertices;
// create a shadow buffer if required
if ( useShadowBuffer )
{
shadowBuffer = new DefaultHardwareVertexBuffer( this.Manager, vertexDeclaration, numVertices, BufferUsage.Dynamic );
}
this.useCount = 0;
}
public GLESHardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration, int numVertices, BufferUsage usage, bool useShadowBuffer )
: base( manager, vertexDeclaration, numVertices, usage, false, useShadowBuffer )
{
if ( !useShadowBuffer )
{
throw new AxiomException( "Only supported with shadowBuffer" );
}
var buffers = new int[ 1 ];
GL.GenBuffers( 1, buffers );
GLESConfig.GlCheckError( this );
this._bufferID = buffers[ 0 ];
if ( this._bufferID == 0 )
{
throw new AxiomException( "Cannot create GL ES vertex buffer" );
}
( Root.Instance.RenderSystem as GLESRenderSystem ).BindGLBuffer( GLenum.ArrayBuffer, this._bufferID );
GL.BufferData( GLenum.ArrayBuffer, new IntPtr( sizeInBytes ), IntPtr.Zero, GLESHardwareBufferManager.GetGLUsage( usage ) );
GLESConfig.GlCheckError( this );
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer = false )
/// <summary>
/// Creates a Bezier patch based on an array of control vertices.
/// </summary>
public PatchMesh CreateBezierPatch( string name, string group, Array controlPointBuffer, VertexDeclaration declaration,
int width, int height, int uMaxSubdivisionLevel, int vMaxSubdivisionLevel, VisibleSide visibleSide,
BufferUsage vbUsage, BufferUsage ibUsage, bool vbUseShadow, bool ibUseShadow )
{
if ( width < 3 || height < 3 )
{
throw new Exception( "Bezier patch requires at least 3x3 control points." );
}
PatchMesh mesh = (PatchMesh)this[ name ];
if ( mesh != null )
{
throw new AxiomException( "A mesh with the name {0} already exists!", name );
}
mesh = new PatchMesh( this, name, nextHandle, group );
mesh.Define( controlPointBuffer, declaration, width, height, uMaxSubdivisionLevel, vMaxSubdivisionLevel, visibleSide, vbUsage, ibUsage, vbUseShadow, ibUseShadow );
mesh.Load();
_add( mesh );
return mesh;
}
/// <summary>
/// Sets up the surface by defining it's control points, type and initial subdivision level.
/// </summary>
/// <remarks>
/// This method initialises the surface by passing it a set of control points. The type of curves to be used
/// are also defined here, although the only supported option currently is a bezier patch. You can also
/// specify a global subdivision level here if you like, although it is recommended that the parameter
/// is left as AUTO_LEVEL, which means the system decides how much subdivision is required (based on the
/// curvature of the surface).
/// </remarks>
/// <param name="controlPoints">
/// A pointer to a buffer containing the vertex data which defines control points
/// of the curves rather than actual vertices. Note that you are expected to provide not
/// just position information, but potentially normals and texture coordinates too. The
/// format of the buffer is defined in the VertexDeclaration parameter.
/// </param>
/// <param name="decl">
/// VertexDeclaration describing the contents of the buffer.
/// Note this declaration must _only_ draw on buffer source 0!
/// </param>
/// <param name="width">Specifies the width of the patch in control points.</param>
/// <param name="height">Specifies the height of the patch in control points.</param>
/// <param name="type">The type of surface.</param>
/// <param name="uMaxSubdivision">
/// If you want to manually set the top level of subdivision,
/// do it here, otherwise let the system decide.
/// </param>
/// <param name="vMaxSubdivision">
/// If you want to manually set the top level of subdivision,
/// do it here, otherwise let the system decide.
/// </param>
/// <param name="side">Determines which side of the patch (or both) triangles are generated for.</param>
public void DefineSurface(System.Array controlPoints, VertexDeclaration decl, int width, int height)
{
DefineSurface(controlPoints, decl, width, height, PatchSurfaceType.Bezier, AUTO_LEVEL, AUTO_LEVEL, VisibleSide.Front);
}
public GLDefaultHardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration, int numVertices, BufferUsage usage, bool useSystemMemory, bool useShadowBuffer ) : base( manager, vertexDeclaration, numVertices, usage, useSystemMemory, useShadowBuffer )
{
}
protected void WriteGeometryVertexDeclaration( BinaryWriter writer, VertexDeclaration vertexDeclaration )
{
var start_offset = writer.Seek( 0, SeekOrigin.Current );
WriteChunk( writer, MeshChunkID.GeometryVertexDeclaration, 0 );
for ( var i = 0; i < vertexDeclaration.ElementCount; ++i )
{
WriteGeometryVertexElement( writer, vertexDeclaration.GetElement( i ) );
}
var end_offset = writer.Seek( 0, SeekOrigin.Current );
writer.Seek( (int)start_offset, SeekOrigin.Begin );
WriteChunk( writer, MeshChunkID.GeometryVertexDeclaration, (int)( end_offset - start_offset ) );
writer.Seek( (int)end_offset, SeekOrigin.Begin );
}
/// <summary>
///
/// </summary>
/// <param name="vertexSize"></param>
/// <param name="numVerts"></param>
/// <param name="usage"></param>
/// <param name="useShadowBuffer"></param>
/// <returns></returns>
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration declaration, int numVerts, BufferUsage usage, bool useShadowBuffer )
{
// always use shadowBuffer
GLESHardwareVertexBuffer buf = new GLESHardwareVertexBuffer( this, declaration, numVerts, usage, true );
lock ( _vertexBufferLock )
{
vertexBuffers.Add( buf );
}
return buf;
}
public override HardwareVertexBuffer CreateVertexBuffer(VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer = false)
public override void DestroyVertexDeclaration( VertexDeclaration decl )
{
_baseInstance.DestroyVertexDeclaration( decl );
}
public DefaultHardwareVertexBuffer( HardwareBufferManagerBase manager, VertexDeclaration vertexDeclaration,
int numVertices, BufferUsage usage )
: base( manager, vertexDeclaration, numVertices, usage, true, false ) // always software, never shadowed
{
_mpData = new byte[ base.sizeInBytes ];
}
protected override void DestroyVertexDeclarationImpl( VertexDeclaration decl )
{
decl.SafeDispose();
}
/// <summary>
/// Creates a Bezier patch based on an array of control vertices.
/// </summary>
/// <param name="name"></param>
/// <param name="controlPointBuffer"></param>
/// <param name="declaration"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="uMaxSubdivisionLevel"></param>
/// <param name="vMaxSubdivisionLevel"></param>
/// <param name="visibleSide"></param>
/// <param name="vbUsage"></param>
/// <param name="ibUsage"></param>
/// <param name="vbUseShadow"></param>
/// <param name="ibUseShadow"></param>
/// <returns></returns>
public PatchMesh CreateBezierPatch(string name, System.Array controlPointBuffer, VertexDeclaration declaration,
int width, int height, int uMaxSubdivisionLevel, int vMaxSubdivisionLevel, VisibleSide visibleSide,
BufferUsage vbUsage, BufferUsage ibUsage, bool vbUseShadow, bool ibUseShadow)
{
PatchMesh mesh = (PatchMesh)GetByName(name);
if(mesh != null) {
throw new AxiomException("A mesh with the name {0} already exists!", name);
}
mesh = new PatchMesh(name, controlPointBuffer, declaration, width, height,
uMaxSubdivisionLevel, vMaxSubdivisionLevel, visibleSide, vbUsage, ibUsage, vbUseShadow, ibUseShadow);
mesh.IsManuallyDefined = true;
base.Load(mesh, 0);
return mesh;
}
// Just override the mandatory create scene method
protected override void CreateScene()
{
// Set ambient light
scene.AmbientLight = new ColorEx(0.2f, 0.2f, 0.2f);
// Create point light
Light light = scene.CreateLight("MainLight");
// Accept default settings: point light, white diffuse, just set position.
// I could attach the light to a SceneNode if I wanted it to move automatically with
// other objects, but I don't.
light.Type = LightType.Directional;
light.Direction = new Vector3(-0.5f, -0.5f, 0);
// Create patch with positions, normals, and 1 set of texcoords
patchDeclaration = HardwareBufferManager.Instance.CreateVertexDeclaration();
patchDeclaration.AddElement(0, 0, VertexElementType.Float3, VertexElementSemantic.Position);
patchDeclaration.AddElement(0, 12, VertexElementType.Float3, VertexElementSemantic.Normal);
patchDeclaration.AddElement(0, 24, VertexElementType.Float2, VertexElementSemantic.TexCoords, 0);
// Patch data
PatchVertex[] patchVertices = new PatchVertex[9];
patchVertices[0].X = -500; patchVertices[0].Y = 200; patchVertices[0].Z = -500;
patchVertices[0].Nx = -0.5f; patchVertices[0].Ny = 0.5f; patchVertices[0].Nz = 0;
patchVertices[0].U = 0; patchVertices[0].V = 0;
patchVertices[1].X = 0; patchVertices[1].Y = 500; patchVertices[1].Z = -750;
patchVertices[1].Nx = 0; patchVertices[1].Ny = 0.5f; patchVertices[1].Nz = 0;
patchVertices[1].U = 0.5f; patchVertices[1].V = 0;
patchVertices[2].X = 500; patchVertices[2].Y = 1000; patchVertices[2].Z = -500;
patchVertices[2].Nx = 0.5f; patchVertices[2].Ny = 0.5f; patchVertices[2].Nz = 0;
patchVertices[2].U = 1; patchVertices[2].V = 0;
patchVertices[3].X = -500; patchVertices[3].Y = 0; patchVertices[3].Z = 0;
patchVertices[3].Nx = -0.5f; patchVertices[3].Ny = 0.5f; patchVertices[3].Nz = 0;
patchVertices[3].U = 0; patchVertices[3].V = 0.5f;
patchVertices[4].X = 0; patchVertices[4].Y = 500; patchVertices[4].Z = 0;
patchVertices[4].Nx = 0; patchVertices[4].Ny = 0.5f; patchVertices[4].Nz = 0;
patchVertices[4].U = 0.5f; patchVertices[4].V = 0.5f;
patchVertices[5].X = 500; patchVertices[5].Y = -50; patchVertices[5].Z = 0;
patchVertices[5].Nx = 0.5f; patchVertices[5].Ny = 0.5f; patchVertices[5].Nz = 0;
patchVertices[5].U = 1; patchVertices[5].V = 0.5f;
patchVertices[6].X = -500; patchVertices[6].Y = 0; patchVertices[6].Z = 500;
patchVertices[6].Nx = -0.5f; patchVertices[6].Ny = 0.5f; patchVertices[6].Nz = 0;
patchVertices[6].U = 0; patchVertices[6].V = 1;
patchVertices[7].X = 0; patchVertices[7].Y = 500; patchVertices[7].Z = 500;
patchVertices[7].Nx = 0; patchVertices[7].Ny = 0.5f; patchVertices[7].Nz = 0;
patchVertices[7].U = 0.5f; patchVertices[7].V = 1;
patchVertices[8].X = 500; patchVertices[8].Y = 200; patchVertices[8].Z = 800;
patchVertices[8].Nx = 0.5f; patchVertices[8].Ny = 0.5f; patchVertices[8].Nz = 0;
patchVertices[8].U = 1; patchVertices[8].V = 1;
patch = MeshManager.Instance.CreateBezierPatch("Bezier1", patchVertices, patchDeclaration, 3, 3, 5, 5, VisibleSide.Both, BufferUsage.StaticWriteOnly, BufferUsage.DynamicWriteOnly, true, true);
// Start patch a 0 detail
patch.SetSubdivision(0);
// Create entity based on patch
patchEntity = scene.CreateEntity("Entity1", "Bezier1");
Material material = (Material)MaterialManager.Instance.Create("TextMat");
material.GetTechnique(0).GetPass(0).CreateTextureUnitState("BumpyMetal.jpg");
patchEntity.MaterialName = "TextMat";
// Attach the entity to the root of the scene
scene.RootSceneNode.AttachObject(patchEntity);
camera.Position = new Vector3(500, 500, 1500);
camera.LookAt(new Vector3(0, 200, -300));
}
public override HardwareVertexBuffer CreateVertexBuffer(VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer)
#endif
{
return(this._baseInstance.CreateVertexBuffer(vertexDeclaration, numVerts, usage, useShadowBuffer));
}
public void InitQuake3Patches(Quake3Level q3lvl, VertexDeclaration decl)
{
int face;
patchVertexCount = 0;
patchIndexCount = 0;
// We're just building the patch here to get a hold on the size of the mesh
// although we'll reuse this information later
face = q3lvl.NumFaces;
while(face-- > 0)
{
InternalBspFace src = q3lvl.Faces[face];
if(src.type == BspFaceType.Patch)
{
// Seems to be some crap in the Q3 level where vertex count = 0 or num control points = 0?
if((src.vertCount == 0) || (src.meshCtrl[0] == 0))
continue;
PatchSurface ps = new PatchSurface();
// Set up control points & format.
// Reuse the vertex declaration.
// Copy control points into a buffer so we can convert their format.
BspVertex[] controlPoints = new BspVertex[src.vertCount];
TextureLightMap texLightMap;
for(int v = 0; v < src.vertCount; v++)
QuakeVertexToBspVertex(q3lvl.Vertices[src.vertStart + v], out controlPoints[v], out texLightMap);
// Define the surface, but don't build it yet (no vertex / index buffer)
ps.DefineSurface(
controlPoints,
decl,
src.meshCtrl[0],
src.meshCtrl[1]
);
// Get stats
patchVertexCount += ps.RequiredVertexCount;
patchIndexCount += ps.RequiredIndexCount;
// Save the surface for later
patches.Add(face, ps);
}
}
}
public override void DestroyVertexDeclaration(VertexDeclaration decl)
{
this._baseInstance.DestroyVertexDeclaration(decl);
}
/// <summary>
/// </summary>
/// <param name="vertexSize"> </param>
/// <param name="numVertices"> </param>
/// <param name="usage"> </param>
public GLDefaultHardwareVertexBuffer(VertexDeclaration declaration, int numVertices, BufferUsage usage)
: base( null, declaration, numVertices, usage, true, false )
{
this._data = new byte[ declaration.GetVertexSize() * numVertices ];
this._dataPtr = BufferBase.Wrap( this._data );
}
protected override void SetupContent()
{
ResourceGroupManager.Instance.InitializeAllResourceGroups();
// setup some basic lighting for our scene
SceneManager.AmbientLight = new ColorEx( 0.5f, 0.5f, 0.5f );
SceneManager.CreateLight( "BezierLight" ).Position = new Vector3( 100, 100, 100 );
// define the control point vertices for our patch
// Patch data
PatchVertex[] patchVertices = new PatchVertex[ 9 ];
patchVertices[ 0 ].X = -500;
patchVertices[ 0 ].Y = 200;
patchVertices[ 0 ].Z = -500;
patchVertices[ 0 ].Nx = -0.5f;
patchVertices[ 0 ].Ny = 0.5f;
patchVertices[ 0 ].Nz = 0;
patchVertices[ 0 ].U = 0;
patchVertices[ 0 ].V = 0;
patchVertices[ 1 ].X = 0;
patchVertices[ 1 ].Y = 500;
patchVertices[ 1 ].Z = -750;
patchVertices[ 1 ].Nx = 0;
patchVertices[ 1 ].Ny = 0.5f;
patchVertices[ 1 ].Nz = 0;
patchVertices[ 1 ].U = 0.5f;
patchVertices[ 1 ].V = 0;
patchVertices[ 2 ].X = 500;
patchVertices[ 2 ].Y = 1000;
patchVertices[ 2 ].Z = -500;
patchVertices[ 2 ].Nx = 0.5f;
patchVertices[ 2 ].Ny = 0.5f;
patchVertices[ 2 ].Nz = 0;
patchVertices[ 2 ].U = 1;
patchVertices[ 2 ].V = 0;
patchVertices[ 3 ].X = -500;
patchVertices[ 3 ].Y = 0;
patchVertices[ 3 ].Z = 0;
patchVertices[ 3 ].Nx = -0.5f;
patchVertices[ 3 ].Ny = 0.5f;
patchVertices[ 3 ].Nz = 0;
patchVertices[ 3 ].U = 0;
patchVertices[ 3 ].V = 0.5f;
patchVertices[ 4 ].X = 0;
patchVertices[ 4 ].Y = 500;
patchVertices[ 4 ].Z = 0;
patchVertices[ 4 ].Nx = 0;
patchVertices[ 4 ].Ny = 0.5f;
patchVertices[ 4 ].Nz = 0;
patchVertices[ 4 ].U = 0.5f;
patchVertices[ 4 ].V = 0.5f;
patchVertices[ 5 ].X = 500;
patchVertices[ 5 ].Y = -50;
patchVertices[ 5 ].Z = 0;
patchVertices[ 5 ].Nx = 0.5f;
patchVertices[ 5 ].Ny = 0.5f;
patchVertices[ 5 ].Nz = 0;
patchVertices[ 5 ].U = 1;
patchVertices[ 5 ].V = 0.5f;
patchVertices[ 6 ].X = -500;
patchVertices[ 6 ].Y = 0;
patchVertices[ 6 ].Z = 500;
patchVertices[ 6 ].Nx = -0.5f;
patchVertices[ 6 ].Ny = 0.5f;
patchVertices[ 6 ].Nz = 0;
patchVertices[ 6 ].U = 0;
patchVertices[ 6 ].V = 1;
patchVertices[ 7 ].X = 0;
patchVertices[ 7 ].Y = 500;
patchVertices[ 7 ].Z = 500;
patchVertices[ 7 ].Nx = 0;
patchVertices[ 7 ].Ny = 0.5f;
patchVertices[ 7 ].Nz = 0;
patchVertices[ 7 ].U = 0.5f;
patchVertices[ 7 ].V = 1;
patchVertices[ 8 ].X = 500;
patchVertices[ 8 ].Y = 200;
patchVertices[ 8 ].Z = 800;
patchVertices[ 8 ].Nx = 0.5f;
patchVertices[ 8 ].Ny = 0.5f;
patchVertices[ 8 ].Nz = 0;
patchVertices[ 8 ].U = 1;
patchVertices[ 8 ].V = 1;
// specify a vertex format declaration for our patch: 3 floats for position, 3 floats for normal, 2 floats for UV
patchDeclaration = HardwareBufferManager.Instance.CreateVertexDeclaration();
patchDeclaration.AddElement( 0, 0, VertexElementType.Float3, VertexElementSemantic.Position );
patchDeclaration.AddElement( 0, 12, VertexElementType.Float3, VertexElementSemantic.Normal );
patchDeclaration.AddElement( 0, 24, VertexElementType.Float2, VertexElementSemantic.TexCoords, 0 );
// create a patch mesh using vertices and declaration
patch = MeshManager.Instance.CreateBezierPatch( "patch", ResourceGroupManager.DefaultResourceGroupName, patchVertices, patchDeclaration, 3, 3, 5, 5, VisibleSide.Both, BufferUsage.StaticWriteOnly, BufferUsage.DynamicWriteOnly, true, true );
// Start patch at 0 detail
patch.Subdivision = 0;
// Create entity based on patch
patchEntity = SceneManager.CreateEntity( "Entity1", "patch" );
Material material = (Material)MaterialManager.Instance.Create( "TextMat", ResourceGroupManager.DefaultResourceGroupName, null );
material.GetTechnique( 0 ).GetPass( 0 ).CreateTextureUnitState( "BumpyMetal.jpg" );
patchEntity.MaterialName = "TextMat";
patchPass = material.GetTechnique( 0 ).GetPass( 0 );
// Attach the entity to the root of the scene
SceneManager.RootSceneNode.AttachObject( patchEntity );
// save the main pass of the material so we can toggle wireframe on it
if ( material != null )
{
patchPass = material.GetTechnique( 0 ).GetPass( 0 );
// use an orbit style camera
CameraManager.setStyle( CameraStyle.Orbit );
CameraManager.SetYawPitchDist( 0, 0, 250 );
TrayManager.ShowCursor();
// create slider to adjust detail and checkbox to toggle wireframe
Slider slider = TrayManager.CreateThickSlider( TrayLocation.TopLeft, "Detail", "Detail", 120, 44, 0, 1, 6 );
CheckBox box = TrayManager.CreateCheckBox( TrayLocation.TopLeft, "Wireframe", "Wireframe", 120 );
slider.SliderMoved += new SliderMovedHandler( slider_SliderMoved );
box.CheckChanged += new CheckChangedHandler( box_CheckChanged );
}
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer )
{
return _baseInstance.CreateVertexBuffer( vertexDeclaration, numVerts, usage, useShadowBuffer );
}
/// <summary>
/// Sets up the surface by defining it's control points, type and initial subdivision level.
/// </summary>
/// <remarks>
/// This method initialises the surface by passing it a set of control points. The type of curves to be used
/// are also defined here, although the only supported option currently is a bezier patch. You can also
/// specify a global subdivision level here if you like, although it is recommended that the parameter
/// is left as AUTO_LEVEL, which means the system decides how much subdivision is required (based on the
/// curvature of the surface).
/// </remarks>
/// <param name="controlPoints">
/// A pointer to a buffer containing the vertex data which defines control points
/// of the curves rather than actual vertices. Note that you are expected to provide not
/// just position information, but potentially normals and texture coordinates too. The
/// format of the buffer is defined in the VertexDeclaration parameter.
/// </param>
/// <param name="decl">
/// VertexDeclaration describing the contents of the buffer.
/// Note this declaration must _only_ draw on buffer source 0!
/// </param>
/// <param name="width">Specifies the width of the patch in control points.</param>
/// <param name="height">Specifies the height of the patch in control points.</param>
/// <param name="type">The type of surface.</param>
/// <param name="uMaxSubdivisionLevel">
/// If you want to manually set the top level of subdivision,
/// do it here, otherwise let the system decide.
/// </param>
/// <param name="vMaxSubdivisionLevel">
/// If you want to manually set the top level of subdivision,
/// do it here, otherwise let the system decide.
/// </param>
/// <param name="side">Determines which side of the patch (or both) triangles are generated for.</param>
public unsafe void DefineSurface(System.Array controlPointBuffer, VertexDeclaration declaration, int width, int height,
PatchSurfaceType type, int uMaxSubdivisionLevel, int vMaxSubdivisionLevel, VisibleSide visibleSide)
{
if (height == 0 || width == 0) {
return; // Do nothing - garbage
}
this.type = type;
this.controlWidth = width;
this.controlHeight = height;
this.controlCount = width * height;
this.controlPointBuffer = controlPointBuffer;
this.declaration = declaration;
// Copy positions into Vector3 vector
controlPoints.Clear();
VertexElement elem = declaration.FindElementBySemantic(VertexElementSemantic.Position);
int vertSize = declaration.GetVertexSize(0);
byte *pVert = (byte*)Marshal.UnsafeAddrOfPinnedArrayElement(controlPointBuffer, 0);
float* pReal = null;
for (int i = 0; i < controlCount; i++) {
pReal = (float*)(pVert + elem.Offset);
controlPoints.Add(new Vector3(pReal[0], pReal[1], pReal[2]));
pVert += vertSize;
}
this.side = visibleSide;
// Determine max level
// Initialise to 100% detail
subdivisionFactor = 1.0f;
if (uMaxSubdivisionLevel == AUTO_LEVEL) {
uLevel = maxULevel = GetAutoULevel();
}
else {
uLevel = maxULevel = uMaxSubdivisionLevel;
}
if (vMaxSubdivisionLevel == AUTO_LEVEL) {
vLevel = maxVLevel = GetAutoVLevel();
}
else {
vLevel = maxVLevel = vMaxSubdivisionLevel;
}
// Derive mesh width / height
meshWidth = (LevelWidth(maxULevel) - 1) * ((controlWidth-1) / 2) + 1;
meshHeight = (LevelWidth(maxVLevel) - 1) * ((controlHeight-1) / 2) + 1;
// Calculate number of required vertices / indexes at max resolution
requiredVertexCount = meshWidth * meshHeight;
int iterations = (side == VisibleSide.Both)? 2 : 1;
requiredIndexCount = (meshWidth-1) * (meshHeight - 1) * 2 * iterations * 3;
// Calculate bounds based on control points
Vector3 min = Vector3.Zero;
Vector3 max = Vector3.Zero;
float maxSqRadius = 0.0f;
bool first = true;
for(int i = 0; i < controlPoints.Count; i++) {
Vector3 vec = controlPoints[i];
if (first) {
min = max = vec;
maxSqRadius = vec.LengthSquared;
first = false;
}
else {
min.Floor(vec);
max.Ceil(vec);
maxSqRadius = MathUtil.Max(vec.LengthSquared, maxSqRadius);
}
}
// set the bounds of the patch
aabb.SetExtents(min, max);
boundingSphereRadius = MathUtil.Sqrt(maxSqRadius);
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer )
{
XnaHardwareVertexBuffer buffer = new XnaHardwareVertexBuffer( this, vertexDeclaration, numVerts, usage, _device, false, useShadowBuffer );
vertexBuffers.Add( buffer );
return buffer;
}
/// <summary>
///
/// </summary>
/// <param name="vertexSize"></param>
/// <param name="numVerts"></param>
/// <param name="usage"></param>
/// <returns></returns>
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration declaration, int numVerts, BufferUsage usage )
{
return CreateVertexBuffer( declaration, numVerts, usage, true );
}
/// <summary>
/// Default constructor. Calls on the current buffer manager to initialize the bindings and declarations.
/// </summary>
public VertexData()
{
vertexDeclaration = HardwareBufferManager.Instance.CreateVertexDeclaration();
vertexBufferBinding = HardwareBufferManager.Instance.CreateVertexBufferBinding();
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage, bool useShadowBuffer )
{
return new GLESDefaultHardwareVertexBuffer( vertexDeclaration, numVerts, usage );
}
public override HardwareVertexBuffer CreateVertexBuffer( VertexDeclaration vertexDeclaration, int numVerts, BufferUsage usage )
{
// call overloaded method with no shadow buffer
return CreateVertexBuffer( vertexDeclaration, numVerts, usage, false );
}
protected void SetPointsImpl(List <Vector3> points, List <ColorEx> colors, List <List <VertexBoneAssignment> > boneAssignments)
{
if (colors != null && points.Count != colors.Count)
{
throw new Exception("Invalid parameters to SetPoints. Point list length does not match colors list length");
}
Vector3 min = Vector3.Zero;
Vector3 max = Vector3.Zero;
// set up vertex data
vertexData = new VertexData();
// set up vertex declaration
VertexDeclaration vertexDeclaration = vertexData.vertexDeclaration;
int currentOffset = 0;
// always need positions
vertexDeclaration.AddElement(0, currentOffset, VertexElementType.Float3, VertexElementSemantic.Position);
currentOffset += VertexElement.GetTypeSize(VertexElementType.Float3);
int colorOffset = currentOffset / sizeof(float);
if (colors != null)
{
vertexDeclaration.AddElement(0, currentOffset, VertexElementType.Color, VertexElementSemantic.Diffuse);
currentOffset += VertexElement.GetTypeSize(VertexElementType.Color);
}
int boneIndexOffset = currentOffset / sizeof(float);
if (boneAssignments != null)
{
vertexDeclaration.AddElement(0, currentOffset, VertexElementType.UByte4, VertexElementSemantic.BlendIndices);
currentOffset += VertexElement.GetTypeSize(VertexElementType.UByte4);
}
int boneWeightOffset = currentOffset / sizeof(float);
if (boneAssignments != null)
{
vertexDeclaration.AddElement(0, currentOffset, VertexElementType.Float4, VertexElementSemantic.BlendWeights);
currentOffset += VertexElement.GetTypeSize(VertexElementType.Float4);
}
int stride = currentOffset / sizeof(float);
vertexData.vertexCount = points.Count;
// allocate vertex buffer
HardwareVertexBuffer vertexBuffer = HardwareBufferManager.Instance.CreateVertexBuffer(vertexDeclaration.GetVertexSize(0), vertexData.vertexCount, BufferUsage.StaticWriteOnly);
// set up the binding, one source only
VertexBufferBinding binding = vertexData.vertexBufferBinding;
binding.SetBinding(0, vertexBuffer);
// Generate vertex data
unsafe {
// lock the vertex buffer
IntPtr data = vertexBuffer.Lock(BufferLocking.Discard);
byte * pData = (byte *)data.ToPointer();
float *pFloat = (float *)pData;
uint * pInt = (uint *)pData;
for (int i = 0; i < points.Count; ++i)
{
Vector3 vec = points[i];
// assign to geometry
pFloat[stride * i] = vec.x;
pFloat[stride * i + 1] = vec.y;
pFloat[stride * i + 2] = vec.z;
if (colors != null)
{
// assign to diffuse
pInt[stride * i + colorOffset] = Root.Instance.RenderSystem.ConvertColor(colors[i]);
}
if (boneAssignments != null)
{
for (int j = 0; j < 4; ++j)
{
pData[4 * (stride * i + boneIndexOffset) + j] = (byte)(boneAssignments[i][j].boneIndex);
pFloat[stride * i + boneWeightOffset + j] = boneAssignments[i][j].weight;
}
}
}
// unlock the buffer
vertexBuffer.Unlock();
} // unsafe
for (int i = 0; i < points.Count; ++i)
{
Vector3 vec = points[i];
// Also update the bounding sphere radius
float len = vec.Length;
if (len > boundingSphereRadius)
{
boundingSphereRadius = len;
}
// Also update the bounding box
if (vec.x < min.x)
{
min.x = vec.x;
}
if (vec.y < min.y)
{
min.y = vec.y;
}
if (vec.z < min.z)
{
min.z = vec.z;
}
if (vec.x > max.x)
{
max.x = vec.x;
}
if (vec.y > max.y)
{
max.y = vec.y;
}
if (vec.z > max.z)
{
max.z = vec.z;
}
}
// Set the SimpleRenderable bounding box
box = new AxisAlignedBox(min, max);
}
