public override void Update(TimeSpan elapsed)
{
if (!manual)
{
sphere = BoundingSphere.CreateFromPoints(
new Vector3[] {
player1Tail.BoundingSphere.Center,
player2Tail.BoundingSphere.Center,
ballTransform.Position
});
//transform.Position.X = ballTransform.Position.X;
transform.Position.Y = sphere.Radius * 2.5f;
}
else
{
float rX = GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.X;
float rY = GamePad.GetState(PlayerIndex.One).ThumbSticks.Right.Y;
transform.Position.Y += -rY;
}
if (transform.Position.Y < 13)
{
transform.Position.Y = 13;
}
}
/// <summary>
/// The main method in charge of processing the content.
/// </summary>
public override ModelContent Process(NodeContent input,
ContentProcessorContext context)
{
// Look up the input vertex positions.
FindVertices(input);
// Chain to the base ModelProcessor class.
ModelContent model = base.Process(input, context);
// You can store any type of object in the model Tag property. This
// sample only uses built-in types such as string, Vector3, BoundingSphere,
// dictionaries, and arrays, which the content pipeline knows how to
// serialize by default. We could also attach custom data types here, but
// then we would have to provide a ContentTypeWriter and ContentTypeReader
// implementation to tell the pipeline how to serialize our custom type.
//
// We are setting our model Tag to a dictionary that maps strings to
// objects, and then storing two different kinds of custom data into that
// dictionary. This is a useful pattern because it allows processors to
// combine many different kinds of information inside the single Tag value.
Dictionary <string, object> tagData = new Dictionary <string, object>();
model.Tag = tagData;
// Store vertex information in the tag data, as an array of Vector3.
tagData.Add("Vertices", vertices.ToArray());
// Also store a custom bounding sphere.
tagData.Add("BoundingSphere", BoundingSphere.CreateFromPoints(vertices));
return(model);
}
public Shape(GraphicsDevice device, Color color, List <Vector2> outline, bool connect)
{
texture = new Texture2D(device, 1, 1);
texture.SetData(new Color[] { color });
vertices = new VertexPositionColor[outline.Count];
indices = new short[vertices.Length * 2];
var min = Vector2.One * float.MaxValue;
var max = Vector2.One * float.MinValue;
var ii = 0;
for (var i = 0; i < vertices.Length; i++)
{
var vertex = outline[i];
vertices[i] = new VertexPositionColor(new Vector3(vertex.X, 0, vertex.Y), color);
indices[ii++] = (short)i;
if (connect)
{
indices[ii++] = (short)((i + 1) % vertices.Length);
}
min.X = Min(min.X, vertex.X);
min.Y = Min(min.Y, vertex.Y);
max.X = Max(max.X, vertex.X);
max.Y = Max(max.Y, vertex.Y);
}
Radius = BoundingSphere.CreateFromPoints(vertices.Select(v => v.Position)).Radius;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="max">Punto máximo de un AABB</param>
/// <param name="min">Punto mínimo de un AABB</param>
/// <param name="mass">Masa</param>
public CollisionBox(Vector3 max, Vector3 min, float mass)
: base(mass)
{
this.HalfSize = (max - min) * 0.5f;
this.m_SPH = BoundingSphere.CreateFromPoints(this.GetCorners());
}
/// <summary>
/// Converts a single piece of input geometry into our custom format.
/// </summary>
void ProcessGeometry(GeometryContent geometry, MyreModelContent model)
{
int triangleCount = geometry.Indices.Count / 3;
int vertexCount = geometry.Vertices.VertexCount;
// Flatten the flexible input vertex channel data into
// a simple GPU style vertex buffer byte array.
var vertexBufferContent = geometry.Vertices.CreateVertexBuffer();
// Convert the input material.
var materials = ProcessMaterial(geometry.Material, geometry.Parent);
var boundingSphere = BoundingSphere.CreateFromPoints(geometry.Vertices.Positions);
// Add the new piece of geometry to our output model.
model.AddMesh(new MyreMeshContent()
{
//Parent = geometry.Parent,
Name = geometry.Parent.Name,
BoundingSphere = boundingSphere,
Materials = materials,
IndexBuffer = geometry.Indices,
VertexBuffer = vertexBufferContent,
VertexCount = vertexCount,
TriangleCount = triangleCount
});
}
private static M.GeometryModelContent BuildModel(List <MeshContent> meshes, Dictionary <GeometryContent, M.MaterialContent> materials)
{
var model = new M.GeometryModelContent();
var meshCounter = 0;
foreach (var mesh in meshes)
{
var meshName = string.IsNullOrWhiteSpace(mesh.Name) ? $"{meshCounter}" : mesh.Name;
meshCounter++;
var geometryCounter = 0;
foreach (var geometry in mesh.Geometry)
{
var geometryName = string.IsNullOrWhiteSpace(geometry.Name) ? $"{geometryCounter}" : geometry.Name;
geometryCounter++;
StripVertexChannels(geometry);
var name = string.Join(".", meshName, geometryName);
var vertexBuffer = geometry.Vertices.CreateVertexBuffer();
var indices = geometry.Indices;
var bounds = BoundingSphere.CreateFromPoints(mesh.Positions);
var geometryData = new M.GeometryDataContent(name, vertexBuffer, indices, bounds);
var material = materials[geometry];
var geometryMesh = new M.GeometryMeshContent(geometryData, material, mesh.AbsoluteTransform);
model.Add(geometryMesh);
}
}
return(model);
}
public override ModelContent Process(NodeContent input, ContentProcessorContext context)
{
// DEBUG
printNodeTree(input, context, "");
// Hack (THERES IS A BUG IN THE XNA 2 BETA VERSION. THIS LINE SHOULD BE REMOVED IN THE FINAL VERSION)
Scale *= 0.1f;
// Process model
ModelContent model = base.Process(input, context);
// Transform all mesh in a absolute coordinate system
//FlattenMesh(skeleton, input, context);
// Now extract the model skeleton and all animations
AnimatedModelData animatedModelData = ExtractSkeletonAndAnimations(input, context);
// Extract all points from the mesh
List <Vector3> vertexList = new List <Vector3>();
GetModelVertices(input, vertexList);
// Generate bounding volumes
BoundingBox modelBoundBox = BoundingBox.CreateFromPoints(vertexList);
BoundingSphere modelBoundSphere = BoundingSphere.CreateFromPoints(vertexList);
Dictionary <string, object> tagDictionary = new Dictionary <string, object>();
tagDictionary.Add("AnimatedModelData", animatedModelData);
tagDictionary.Add("ModelBoudingBox", modelBoundBox);
tagDictionary.Add("ModelBoudingSphere", modelBoundSphere);
model.Tag = tagDictionary;
return(model);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="halfSize">Medias longitudes en los ejes de coordenadas</param>
/// <param name="mass">Masa</param>
public CollisionBox(Vector3 halfSize, float mass)
: base(mass)
{
this.HalfSize = halfSize;
this.m_SPH = BoundingSphere.CreateFromPoints(this.GetCorners());
}
//Generates a mesh from required parameters, as well as specifying a parent bone to be used, used to simplify and clean up code.
public static ModelMesh makeMeshFromPolygonList(List <Polygon> polys, GraphicsDevice graphics, ModelBone parentBone)
{
List <ModelMeshPart> parts = new List <ModelMeshPart>();
ModelBone bone = new ModelBone();
bone.Transform = Matrix.CreateTranslation(0, 0, 0);
bone.ModelTransform = parentBone.ModelTransform;
List <Vector3> points = new List <Vector3>();
foreach (Polygon p in polys)
{
ModelMeshPart part = makePartFromPolygon(p, graphics);
parts.Add(part);
foreach (Vector3 point in p.points)
{
points.Add(point);
}
}
ModelMesh mesh = new ModelMesh(graphics, parts);
bone.AddMesh(mesh);
parentBone.AddChild(bone);
bone.Parent = parentBone;
mesh.ParentBone = bone;
mesh.BoundingSphere = BoundingSphere.CreateFromPoints(points);
return(mesh);
}
protected virtual void ProcessGeometryUsingMaterial(MaterialContent material,
IEnumerable <GeometryContent> geometryCollection,
ContentProcessorContext context)
{
if (material == null)
{
material = new BasicMaterialContent();
}
foreach (var geometry in geometryCollection)
{
ProcessBasicMaterial(material as BasicMaterialContent, geometry);
var vertexBuffer = geometry.Vertices.CreateVertexBuffer();
var primitiveCount = geometry.Vertices.PositionIndices.Count;
var parts = new List <ModelMeshPartContent>
{
new ModelMeshPartContent(vertexBuffer, geometry.Indices, 0, primitiveCount, 0,
primitiveCount / 3)
};
var parent = geometry.Parent;
var bounds = BoundingSphere.CreateFromPoints(geometry.Vertices.Positions);
_meshes.Add(new ModelMeshContent(parent.Name, geometry.Parent, null, bounds, parts));
}
}
public override void Initialize()
{
var model = TryAndGetModelFromOwner();
if (model != null)
{
Vector3[] vertices;
int[] indices;
ModelDataExtractor.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
BoundingSphere _aabb = BoundingSphere.CreateFromPoints(vertices);
if (Mass <= 0)
{
//kinematic
Entity = new Sphere(MathConverter.Convert(Owner.World.Translation),
_aabb.Radius);
}
else
{
//dynamic
Entity = new Sphere(MathConverter.Convert(Owner.World.Translation),
_aabb.Radius, Mass);
}
}
base.Initialize();
}
public override void Initialized()
{
if (Owner.HasComponent <BasicEffectModel>())
{
BasicEffectModel modelComp = Owner.GetComponent <BasicEffectModel>();
Vector3[] vertices;
int[] indices;
ModelDataExtractor.GetVerticesAndIndicesFromModel(modelComp.Model, out vertices, out indices);
AABB = BoundingBox.CreateFromPoints(vertices);
AABS = BoundingSphere.CreateFromPoints(vertices);
AABS.Center = Vector3.Transform(AABS.Center, Owner.World);
AABB.Max = Vector3.Transform(AABB.Max, Owner.World);
AABB.Min = Vector3.Transform(AABB.Min, Owner.World);
ray = new Ray(Owner.World.Translation, new Vector3(-1, 0, 0));
}
else
{
Destroy();
}
base.Initialized();
}
public void CreateFromPointsTest()
{
Assert.Catch <ArgumentNullException>(() => BoundingSphere.CreateFromPoints(null));
var actualPoints = new List <Vector3> ();
Assert.Catch <ArgumentException>(() => BoundingSphere.CreateFromPoints(actualPoints));
actualPoints = new List <Vector3> {
Vector3.Zero
};
var actual = BoundingSphere.CreateFromPoints(actualPoints);
Assert.That(actual, Is.EqualTo(new BoundingSphere(Vector3.Zero, 0)));
actualPoints = new List <Vector3> {
new Vector3(1, 0, 0),
new Vector3(-1, 0, 0),
};
actual = BoundingSphere.CreateFromPoints(actualPoints);
Assert.That(actual, Is.EqualTo(unitSphere));
actualPoints = new List <Vector3> {
new Vector3(0, 1, 0),
new Vector3(0, -1, 0),
};
actual = BoundingSphere.CreateFromPoints(actualPoints);
Assert.That(actual, Is.EqualTo(unitSphere));
actualPoints = new List <Vector3> {
new Vector3(0, 0, 1),
new Vector3(0, 0, -1)
};
actual = BoundingSphere.CreateFromPoints(actualPoints);
Assert.That(actual, Is.EqualTo(unitSphere));
}
private ModelMeshContent ProcessMesh(MeshContent mesh, ModelBoneContent parent, ContentProcessorContext context)
{
var bounds = new BoundingSphere();
var parts = new List <ModelMeshPartContent>();
var vertexBuffer = new VertexBufferContent();
var indexBuffer = new IndexCollection();
var startVertex = 0;
foreach (var geometry in mesh.Geometry)
{
var vertices = geometry.Vertices;
var vertexCount = vertices.VertexCount;
var geomBuffer = geometry.Vertices.CreateVertexBuffer();
vertexBuffer.Write(vertexBuffer.VertexData.Length, 1, geomBuffer.VertexData);
var startIndex = indexBuffer.Count;
indexBuffer.AddRange(geometry.Indices);
var partContent = new ModelMeshPartContent(vertexBuffer, indexBuffer, startVertex, vertexCount, startIndex, geometry.Indices.Count / 3);
partContent.Material = geometry.Material;
parts.Add(partContent);
// Update mesh bounding box
bounds = BoundingSphere.CreateMerged(bounds, BoundingSphere.CreateFromPoints(geometry.Vertices.Positions));
// Geoms are supposed to all have the same decl, so just steal one of these
vertexBuffer.VertexDeclaration = geomBuffer.VertexDeclaration;
startVertex += vertexCount;
}
return(new ModelMeshContent(mesh.Name, mesh, parent, bounds, parts));
}
public BoundingSphere GetBoundingSphere()
{
if (boundingSphere.Radius == 0.0f)
{
boundingSphere = BoundingSphere.CreateFromPoints((IEnumerable <Vector3>)Model.Tag);
}
return(boundingSphere);
}
public unsafe BoundingSphere GetBoundingSphere()
{
fixed(VertexPositionTexture *vertexPtr = &Vertices[0])
{
Vector3 *positionPtr = (Vector3 *)vertexPtr;
return(BoundingSphere.CreateFromPoints(positionPtr, Vertices.Length, VertexPositionTexture.SizeInBytes));
}
}
public void GenerateGeometry(Effect testEffect, IModule module)
{
this.effect = testEffect;
this.module = module;
vertices = new VertexPositionColorTextureNormal[heightMapSize * heightMapSize];
int vertIndex = 0;
for (float i = 0; i < heightMapSize; i++)
{
for (float j = 0; j < heightMapSize; j++)
{
var vert = new VertexPositionColorTextureNormal();
vert.Position = CalculateVertexPosition(i, j);
vert.Texture = new Vector2(i * 2f / heightMapSize, j * 2f / heightMapSize);
vert.Normal = normal;
vert.Color = NodeColor;
vertices[vertIndex] = vert;
vertIndex++;
}
}
GenerateIndices();
if (normal == Vector3.Down || normal == Vector3.Backward || normal == Vector3.Right)
{
indices = indices.Reverse().ToArray();
}
indices = indices.Reverse().ToArray();
Sphereify(sphereSize);
GenerateNormals(ref vertices);
short[] ind = indices;
var p = vertices.Select(x => x.Position).ToList();
var s = BoundingSphere.CreateFromPoints(p);
ProceduralShape spherePatch = new ProceduralShape(vertices, indices);
spherePatch.Translate(positionOffset);
gameObject = GameObjectFactory.CreateRenderableGameObjectFromShape(spherePatch, effect);
SystemCore.GameObjectManager.AddAndInitialiseGameObject(gameObject);
isLeaf = true;
}
/// <summary>
/// Creates a box model.
/// </summary>
/// <param name="width">Width</param>
/// <param name="height">Height</param>
/// <param name="depth">Depth</param>
public Box(float width, float height, float depth)
{
Name = "Box Primitive";
this.width = width;
this.height = height;
this.depth = depth;
RecreateResource();
boundingSphere = BoundingSphere.CreateFromPoints(Vertices);
boundingBox = BoundingBox.CreateFromPoints(Vertices);
} // Box
public TeapotRenderer(RenderContext rc)
{
_worldProvider = new DynamicDataProvider <Matrix4x4>();
_inverseTransposeWorldProvider = new DependantDataProvider <Matrix4x4>(_worldProvider, CalculateInverseTranspose);
_perObjectProviders = new ConstantBufferDataProvider[] { _worldProvider, _inverseTransposeWorldProvider };
_centeredBounds = BoundingSphere.CreateFromPoints(LoadTeapotMesh().Vertices);
InitializeContextObjects(rc);
}
private void GenerateSphereCollider()
{
RenderGeometryComponent geometry = ParentObject.GetComponent <RenderGeometryComponent>();
List <Vector3> verts = geometry.GetVertices();
BoundingSphere sphere = BoundingSphere.CreateFromPoints(verts);
PhysicsEntity = new Sphere(MonoMathHelper.Translate(ParentObject.Transform.AbsoluteTransform.Translation),
sphere.Radius, 1);
PhysicsEntity.Tag = ParentObject;
}
/// <summary>
/// Creates a cylinder model.
/// </summary>
/// <param name="radius">Radius</param>
/// <param name="length">Length</param>
/// <param name="slices">Slices</param>
public Cylinder(float radius, float length, int slices)
{
Name = "Cylinder Primitive";
this.radius = radius;
this.length = length;
this.slices = slices;
RecreateResource();
boundingSphere = BoundingSphere.CreateFromPoints(Vertices);
boundingBox = BoundingBox.CreateFromPoints(Vertices);
} // Cylinder
/// <summary>
/// Creates a BoundingCircle that can contain a specified list of points.
/// </summary>
public static BoundingCircle CreateFromPoints(IEnumerable <Vector2> points)
{
var sphere = BoundingSphere.CreateFromPoints(points.Select(pt => new Vector3(pt, 0)));
var result = new BoundingCircle();
result.Center.X = sphere.Center.X;
result.Center.Y = sphere.Center.Y;
result.Radius = sphere.Radius;
return(result);
}
/// <summary>
/// Creates a sphere model.
/// </summary>
/// <param name="stacks">Stacks</param>
/// <param name="slices">Slices</param>
/// <param name="radius">Radius</param>
public Sphere(int stacks, int slices, float radius)
{
Name = "Sphere Primitive";
this.stacks = stacks;
this.slices = slices;
this.radius = radius;
RecreateResource();
boundingSphere = BoundingSphere.CreateFromPoints(Vertices);
boundingBox = BoundingBox.CreateFromPoints(Vertices);
} // Sphere
/// <summary>
/// Actually builds the text
/// </summary>
/// <returns> The custom mesh that has all of the geometry information</returns>
private void CreateText()
{
customMesh = new CustomMesh();
CreateShape();
foreach (VertexPositionNormalTexture aVertex in basicTextIn3D.Vertices)
{
vertices.Add(aVertex.Position);
}
if (styleToUse == UI3DRenderer.Text3DStyle.Fill)
{
for (int i = 0; i < basicTextIn3D.Vertices.Length; ++i)
{
basicTextIn3D.Vertices[i].Normal = -basicTextIn3D.Vertices[i].Normal;
}
}
foreach (short index in basicTextIn3D.Indices)
{
indices.Add((int)index);
}
customMesh.VertexDeclaration = VertexPositionNormalTexture.VertexDeclaration;
customMesh.VertexBuffer = new VertexBuffer(State.Device, typeof(VertexPositionNormalTexture),
basicTextIn3D.Vertices.Length, BufferUsage.None);
customMesh.VertexBuffer.SetData(basicTextIn3D.Vertices);
customMesh.IndexBuffer = new IndexBuffer(State.Device, typeof(short), basicTextIn3D.Indices.Length,
BufferUsage.None);
customMesh.IndexBuffer.SetData(basicTextIn3D.Indices);
customMesh.NumberOfVertices = basicTextIn3D.Vertices.Length;
customMesh.NumberOfPrimitives = basicTextIn3D.Indices.Length / 3;
customMesh.PrimitiveType = basicTextIn3D.PrimitiveType;
if (vertices.Count == 0)
{
throw new GoblinException("Corrupted model vertices. Failed to calculate MBB.");
}
else
{
boundingBox = BoundingBox.CreateFromPoints(vertices);
boundingSphere = BoundingSphere.CreateFromPoints(vertices);
if (offsetTransform.Equals(Matrix.Identity))
{
offsetTransform.Translation = (boundingBox.Min + boundingBox.Max) / 2;
}
}
triangleCount = indices.Count / 3;
}
public static BoundingSphere CreateBoundingSphere(this Schema2.Mesh mesh)
{
var points = mesh
.Primitives
.Select(item => item.GetVertexAccessor("POSITION"))
.Where(item => item != null)
.SelectMany(item => item.AsVector3Array())
.Select(item => item.ToXna());
return(BoundingSphere.CreateFromPoints(points));
}
} // Plane
/// <summary>
/// Creates a plane model.
/// </summary>
/// <param name="topLeft">Top left vertex's position</param>
/// <param name="bottomLeft">Bottom left vertex's position</param>
/// <param name="topRight">Top right vertex's position</param>
/// <param name="bottomRight">Bottom right vertex's position</param>
public Plane(Vector3 topLeft, Vector3 bottomLeft, Vector3 topRight, Vector3 bottomRight)
{
Name = "Plane Primitive";
this.topLeft = topLeft;
this.bottomLeft = bottomLeft;
this.topRight = topRight;
this.bottomRight = bottomRight;
RecreateResource();
boundingSphere = BoundingSphere.CreateFromPoints(Vertices);
boundingBox = BoundingBox.CreateFromPoints(Vertices);
} // Plane
public BoundingSphere CalculateBoundingSphere()
{
Vector3[] points = new Vector3[curveX.Keys.Count];
for (int i = 0; i < curveX.Keys.Count; i++)
{
points[i] = new Vector3(
curveX.Keys[i].Value,
curveY.Keys[i].Value,
curveZ.Keys[i].Value);
}
return(BoundingSphere.CreateFromPoints(points));
}
void DrawNormalDepth(IPostProcessorContext context)
{
Instrument.Begin(InstrumentDrawNormalDepth);
var viewerCamera = context.ActiveCamera;
//----------------------------------------------------------------
// 内部カメラの準備
internalCamera.View.Position = viewerCamera.View.Position;
internalCamera.View.Direction = viewerCamera.View.Direction;
internalCamera.View.Up = viewerCamera.View.Up;
internalCamera.Projection.Fov = viewerCamera.Projection.Fov;
internalCamera.Projection.AspectRatio = viewerCamera.Projection.AspectRatio;
internalCamera.Projection.NearPlaneDistance = viewerCamera.Projection.NearPlaneDistance;
internalCamera.Projection.FarPlaneDistance = FarPlaneDistance;
internalCamera.Update();
internalCamera.Frustum.GetCorners(frustumCorners);
frustumSphere = BoundingSphere.CreateFromPoints(frustumCorners);
//----------------------------------------------------------------
// エフェクト
normalDepthMapEffect.View = internalCamera.View.Matrix;
normalDepthMapEffect.Projection = internalCamera.Projection.Matrix;
//----------------------------------------------------------------
// 描画
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
GraphicsDevice.SetRenderTarget(normalDepthMap);
GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.White, 1.0f, 0);
// 不透明オブジェクトのみ対象。
for (int i = 0; i < context.OpaqueObjects.Count; i++)
{
var opaque = context.OpaqueObjects[i];
// 専用カメラの視錐台に含まれるもののみを描画。
if (IsVisibleObject(opaque))
{
opaque.Draw(normalDepthMapEffect);
}
}
GraphicsDevice.SetRenderTarget(null);
Instrument.End();
}
public ShadowCaster(
RenderContext rc,
AssetDatabase ad,
VertexPositionNormalTexture[] vertices,
ushort[] indices,
TextureData texture)
{
_meshData = new SimpleMeshDataProvider(vertices, indices);
_textureData = texture;
_centeredBounds = BoundingSphere.CreateFromPoints(vertices);
InitializeContextObjects(ad, rc);
}
/*internal override void CreateRuntimeCollisionData(CollisionType collType)
* {
* // Note: Also update AssetImporterMeshStaticMesh
*
* // Create 2D version of the mesh (individual triangles)
* Vector2[] allVertices2D = new Vector2[objectIndices.Length];
* for (int i = 0; i < objectIndices.Length; i++)
* {
* allVertices2D[i] = new Vector2(
* objectVertices[objectIndices[i]].pos.X,
* objectVertices[objectIndices[i]].pos.Y);
* }
* // Create 3D version of the mesh
* Vector3[] allVertices3D = new Vector3[objectVertices.Length];
* for (int i = 0; i < allVertices3D.Length; i++)
* {
* allVertices3D[i] = new Vector3(
* objectVertices[i].pos.X, objectVertices[i].pos.Y,
* objectVertices[i].pos.Z);
* }
*
* switch (collType)
* {
* case CollisionType.BoundingBox:
* collisionData = CollisionDataBox.FromMesh(allVertices2D, allVertices3D);
* break;
*
* case CollisionType.BoundingEllipse:
* collisionData = CollisionDataEllipse.FromMesh(allVertices2D, allVertices3D);
* break;
*
* case CollisionType.BoundingSphere:
* collisionData = CollisionDataSphere.FromMesh(allVertices2D, allVertices3D);
* break;
*
* case CollisionType.ConvexHull:
* collisionData = CollisionDataConvexHull.FromMesh(allVertices2D, allVertices3D);
* break;
*
* case CollisionType.SkeletonBox:
* collisionData = CollisionDataSkeletonBox.FromMesh(allVertices2D, allVertices3D);
* break;
*
* case CollisionType.Vertices:
* collisionData = CollisionDataVertices.FromMesh(allVertices2D, allVertices3D);
* break;
* }
* }*/
#endregion
#region CreateBoundingSphere
internal override void CreateBoundingSphere()
{
// Create 3D version of the mesh
Vector3[] allVertices3D = new Vector3[objectVertices.Length];
for (int i = 0; i < allVertices3D.Length; i++)
{
allVertices3D[i] = new Vector3(
objectVertices[i].Position.X, objectVertices[i].Position.Y,
objectVertices[i].Position.Z);
}
BoundingSphere = BoundingSphere.CreateFromPoints(allVertices3D);
}