private void DrawAllModels(IEffectMatrices effect) { foreach (var entity in ActiveEntities) { if (_modelMapper.Has(entity)) { var model = _modelMapper.Get(entity).Model; var transform = _transformMapper.Get(entity); if (model.VertexBuffer != null && model.IndexBuffer != null & model.PrimitiveCount != 0) { var sphere = BoundingSphere.CreateFromBoundingBox(model.BoundingBox); if (CameraSystem.ActiveLens.BoundingFrustum.Intersects(sphere.Transform(transform.WorldMatrix))) { effect.World = transform.WorldMatrix; DrawMesh((Effect)effect, model, _graphicsDevice); } } } else if (_primitiveMapper.Has(entity)) { var primitive = _primitiveMapper.Get(entity); var transform = _transformMapper.Get(entity); effect.World = transform.WorldMatrix; Primitives.Instance.Draw((Effect)effect, primitive.Type); } } }
private void UpdateLightMatrixForDirectionalLight(Camera camera, IList <DrawableElement> shadowCasters) { var directionNormalized = Vector3.Normalize(Direction); var lightViewMatrix = Matrix.CreateLookAt(Vector3.Zero, Direction, Vector3.Up); var mergedBox = new BoundingBox(); for (var i = 0; i < shadowCasters.Count; i++) { var drawableElement = shadowCasters[i]; mergedBox = BoundingBox.CreateMerged(mergedBox, drawableElement.BoundingBox); } var sphere = BoundingSphere.CreateFromBoundingBox(mergedBox); var edges = new Vector3[8]; edges[0] = Vector3.Transform(new Vector3(mergedBox.Min.X, mergedBox.Min.Y, mergedBox.Min.Z), lightViewMatrix); edges[1] = Vector3.Transform(new Vector3(mergedBox.Max.X, mergedBox.Min.Y, mergedBox.Min.Z), lightViewMatrix); edges[2] = Vector3.Transform(new Vector3(mergedBox.Min.X, mergedBox.Min.Y, mergedBox.Max.Z), lightViewMatrix); edges[3] = Vector3.Transform(new Vector3(mergedBox.Max.X, mergedBox.Min.Y, mergedBox.Max.Z), lightViewMatrix); edges[4] = Vector3.Transform(new Vector3(mergedBox.Min.X, mergedBox.Max.Y, mergedBox.Min.Z), lightViewMatrix); edges[5] = Vector3.Transform(new Vector3(mergedBox.Max.X, mergedBox.Max.Y, mergedBox.Min.Z), lightViewMatrix); edges[6] = Vector3.Transform(new Vector3(mergedBox.Min.X, mergedBox.Max.Y, mergedBox.Max.Z), lightViewMatrix); edges[7] = Vector3.Transform(new Vector3(mergedBox.Max.X, mergedBox.Max.Y, mergedBox.Max.Z), lightViewMatrix); var boundingBox = BoundingBox.CreateFromPoints(edges); var width = boundingBox.Max.X - boundingBox.Min.X; var height = boundingBox.Max.Y - boundingBox.Min.Y; var cameraPosition = sphere.Center - directionNormalized * sphere.Radius; var cameraPositionTarget = cameraPosition + directionNormalized; LightViewMatrix = Matrix.CreateLookAt(cameraPosition, cameraPositionTarget, Vector3.Up) * Matrix.CreateOrthographic(width, height, 0.1f, sphere.Radius * 2); }
public void AddCircularObstacle(IObject obj) { BoundingSphere bs = BoundingSphere.CreateFromBoundingBox(obj.PhysicObject.BoundingBox.Value); SphericalObstacle so = new SphericalObstacle(bs.Radius, obj.PhysicObject.Position); obstacles.Add(so); }
public void CreateFromBoundingBox_ContainsBox() { var box = new BoundingBox(new Vector3(1, 7, 3), new Vector3(9, 0, 2)); var sphere = BoundingSphere.CreateFromBoundingBox(box); Assert.AreEqual(ContainmentType.Contains, sphere.Contains(box)); }
protected override void UpdateWorldVolume() { this.PositionLeftBottomCorner = (this.WorldMatrix.Translation - this.SizeInMetresHalf); m_worldAABB = MyUtils.GetNewBoundingBox(PositionLeftBottomCorner, SizeInMetres); m_worldVolume = BoundingSphere.CreateFromBoundingBox(m_worldAABB); InvalidateRenderObjects(); }
/// <summary> /// Calculates the object bounds. /// </summary> /// <param name="objectboundingbox">Object bounds to update.</param><param name="objectboundingsphere">Object bounds to update.</param> protected override void CalculateObjectBounds(ref BoundingBox objectboundingbox, ref BoundingSphere objectboundingsphere) { base.CalculateObjectBounds(ref objectboundingbox, ref objectboundingsphere); objectboundingbox = new BoundingBox(new Vector3(-0.5f, -0.5f, -0.5f), new Vector3(0.5f, 0.5f, 0.5f)); objectboundingsphere = BoundingSphere.CreateFromBoundingBox(objectboundingbox); }
void AllocateChildOctree(Octree octree, int x, int y, int z) { if (octree[x, y, z] != null) { return; } // 子がまだ存在しないなら生成。 var child = octreePool.Borrow(); octree[x, y, z] = child; var min = octree.Box.Min; var max = octree.Box.Max; var childMin = new Vector3(); var childMax = new Vector3(); if (x == 0) { childMin.X = min.X; childMax.X = (min.X + max.X) / 2; } else { childMin.X = (min.X + max.X) / 2; childMax.X = max.X; } if (y == 0) { childMin.Y = min.Y; childMax.Y = (min.Y + max.Y) / 2; } else { childMin.Y = (min.Y + max.Y) / 2; childMax.Y = max.Y; } if (z == 0) { childMin.Z = min.Z; childMax.Z = (min.Z + max.Z) / 2; } else { childMin.Z = (min.Z + max.Z) / 2; childMax.Z = max.Z; } child.Box.Min = childMin; child.Box.Max = childMax; child.Sphere = BoundingSphere.CreateFromBoundingBox(child.Box); }
private void GenerateData(NodeContent node) { MeshContent mesh = node as MeshContent; if (mesh != null) { MeshHelper.OptimizeForCache(mesh); // Look up the absolute transform of the mesh. Matrix absoluteTransform = mesh.AbsoluteTransform; int i = 0; // Loop over all the pieces of geometry in the mesh. foreach (GeometryContent geometry in mesh.Geometry) { Vector3 min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue); Vector3 max = new Vector3(float.MinValue, float.MinValue, float.MinValue); // Loop over all the indices in this piece of geometry. // Every group of three indices represents one triangle. List <Vector3> thisVerts = new List <Vector3>(); List <int> ind = new List <int>(); Vector3 vertex = Vector3.Zero; foreach (int index in geometry.Indices) { // Look up the position of this vertex. vertex = Vector3.Transform(geometry.Vertices.Positions[index], absoluteTransform); // Store this data. min = Vector3.Min(min, vertex); max = Vector3.Max(max, vertex); thisVerts.Add(vertex); ind.Add(i++); } if (EnableLogging) { LogWriter.WriteToLog(string.Format("BoundingBox created min = {0}, max = {1}", min, max)); } boxs.Add(new BoundingBox(min, max)); spheres.Add(BoundingSphere.CreateFromBoundingBox(boxs[boxs.Count - 1])); } } // Recursively scan over the children of this node. foreach (NodeContent child in node.Children) { GenerateData(child); } }
public Cube(Vector3 min, Vector3 max, Material material) { m_Min = min; m_Max = max; m_Material = material; m_BoundingBox = new AABB(min, max); var sphere = BoundingSphere.CreateFromBoundingBox(new BoundingBox(min, max)); m_Center = sphere.Center; }
void UpdateLocalVolume() { float halfSize1 = this.Size / 2.0f; float halfSize2 = this.Size2 / 2.0f; float halfSize3 = this.Size3 / 2.0f; this.m_localBoundingBox = new BoundingBox(new Vector3(-halfSize1, -halfSize2, -halfSize3), new Vector3(halfSize1, halfSize2, halfSize3)); float radius = (float)Math.Sqrt(3) * this.Size; BoundingSphere.CreateFromBoundingBox(ref m_localBoundingBox, out m_localVolume); }
public static IMyEntity GetClosestTargetAlongRay(Ray ray, double maxDistance, double deviation, HashSet <IMyEntity> ignoreSet) { if (Math.Abs(deviation) < double.Epsilon) { deviation = 7.5; } Ray directionRay = ray; float baseDistance = 100.0f; float lowestDistance = float.MaxValue; float safetyDistance = (float)(deviation * 1.33); IMyEntity bestTarget = null; HashSet <IMyEntity> foundEntitySet = new HashSet <IMyEntity>(); for (float i = (float)(deviation * 1.33); i < maxDistance; i += (float)((deviation / 2) / baseDistance * i)) { var largeSphere = new BoundingSphereD(directionRay.Position + i * directionRay.Direction, (deviation / 2) / baseDistance * i * 2); foundEntitySet.UnionWith(MyAPIGateway.Entities.GetEntitiesInSphere(ref largeSphere)); } foreach (IMyEntity foundEntity in foundEntitySet) { // Log.Info("foundentityset.count = " + foundEntitySet.Count); var targetBox = BoundingSphere.CreateFromBoundingBox((BoundingBox)foundEntity.GetTopMostParent().WorldAABB); var posDistance = Vector3.Distance(targetBox.Center, ray.Position); if (posDistance >= baseDistance) { targetBox.Radius *= posDistance / baseDistance; } var direction = targetBox.Center - ray.Position; var angle = Math.Abs(Math.Acos(ray.Direction.Dot(direction) / (ray.Direction.Length() * direction.Length()))); // Log.Info("distance wasnt zero for: " + foundEntity.GetType().ToString()); // if ((float)distance < lowestDistance) Log.Info("distance < lowest distance for " + foundEntity.EntityId); // if (foundEntity.GetTopMostParent().GetType().ToString() == "Sandbox.Game.Entities.MyCubeGrid") Log.Info("target is in a cubegrid " + foundEntity.EntityId); // if ((float)distance > safetyDistance) Log.Info("distance > safety distance for " + foundEntity.EntityId); if (((float)angle < lowestDistance) && ((float)posDistance > safetyDistance) && (foundEntity.GetTopMostParent().GetType().ToString() == "Sandbox.Game.Entities.MyCubeGrid")) { if (!ignoreSet.Contains(foundEntity.GetTopMostParent())) { bestTarget = foundEntity; lowestDistance = (float)angle; // Log.Info("we found a fitting target: " + foundEntity.DisplayName); } } } return(bestTarget); }
public QuestItem(Matrix world, Model model, float colliderSize) : base(world, model) { this.colliderSize = colliderSize; angle = 180; position = world.Translation; collider = new BoundingBox(new Vector3(world.Translation.X - colliderSize / 2, world.Translation.Y - colliderSize / 2, world.Translation.Z - colliderSize / 2), new Vector3(world.Translation.X + colliderSize / 2, world.Translation.Y + colliderSize / 2, world.Translation.Z + colliderSize / 2)); world = Matrix.CreateRotationX(MathHelper.ToRadians(-90)) * Matrix.CreateRotationY(angle) * Matrix.CreateTranslation(position); foreach (ModelMesh mesh in model.Meshes) { mesh.BoundingSphere = BoundingSphere.CreateFromBoundingBox(collider); } }
protected override void Init(MyObjectBuilder_DefinitionBase baseBuilder) { base.Init(baseBuilder); Id = baseBuilder.Id; var builder = baseBuilder as MyObjectBuilder_PrefabDefinition; BoundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue); PrefabPath = builder.PrefabPath; if (builder.CubeGrid == null && builder.CubeGrids == null) { return; } // Backwards compatiblity if (builder.CubeGrid != null) { CubeGrids = new MyObjectBuilder_CubeGrid[1] { builder.CubeGrid } } ; else { CubeGrids = builder.CubeGrids; } BoundingBox = BoundingBox.CreateInvalid(); foreach (var grid in CubeGrids) { BoundingBox localBB = grid.CalculateBoundingBox(); Matrix gridTransform = grid.PositionAndOrientation.HasValue ? (Matrix)grid.PositionAndOrientation.Value.GetMatrix() : Matrix.Identity; BoundingBox.Include(localBB.Transform(gridTransform)); } BoundingSphere = BoundingSphere.CreateFromBoundingBox(BoundingBox); foreach (var gridBuilder in CubeGrids) { gridBuilder.CreatePhysics = true; gridBuilder.XMirroxPlane = null; gridBuilder.YMirroxPlane = null; gridBuilder.ZMirroxPlane = null; } }
void UpdateMesh() { var meshPositionWorld = new Vector3 { X = Position.X + 0.5f, Y = Position.Y + 0.5f, Z = Position.Z + 0.5f }; brushMesh.PositionWorld = meshPositionWorld; brushMesh.BoxWorld.Min = meshPositionWorld - new Vector3(0.5f); brushMesh.BoxWorld.Max = meshPositionWorld + new Vector3(0.5f); BoundingSphere.CreateFromBoundingBox(ref brushMesh.BoxWorld, out brushMesh.SphereWorld); brushMesh.VisibleAllFaces = true; }
public void InitLazy(MyObjectBuilder_DefinitionBase baseBuilder) { var builder = baseBuilder as MyObjectBuilder_PrefabDefinition; Debug.Assert(builder.CubeGrid != null || builder.CubeGrids != null, "No cube grids defined in prefab " + PrefabPath); if (builder.CubeGrid == null && builder.CubeGrids == null) { return; } // Backwards compatiblity if (builder.CubeGrid != null) { m_cubeGrids = new MyObjectBuilder_CubeGrid[1] { builder.CubeGrid } } ; else { m_cubeGrids = builder.CubeGrids; } m_boundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue); m_boundingBox = BoundingBox.CreateInvalid(); foreach (var grid in m_cubeGrids) { BoundingBox localBB = grid.CalculateBoundingBox(); Matrix gridTransform = grid.PositionAndOrientation.HasValue ? (Matrix)grid.PositionAndOrientation.Value.GetMatrix() : Matrix.Identity; m_boundingBox.Include(localBB.Transform(gridTransform)); } m_boundingSphere = BoundingSphere.CreateFromBoundingBox(m_boundingBox); foreach (var gridBuilder in m_cubeGrids) { gridBuilder.CreatePhysics = true; gridBuilder.XMirroxPlane = null; gridBuilder.YMirroxPlane = null; gridBuilder.ZMirroxPlane = null; } Initialized = true; }
/// <summary> /// Once all verticies in this object are set, call ready() to prepare this entity for drawing. /// </summary> public void Ready() { vertexBuffer = new VertexBuffer(GraphicOptions.graphics.GraphicsDevice, vertices.Count * VertexPositionNormalTexture.SizeInBytes, BufferUsage.WriteOnly); vertexBuffer.SetData <VertexPositionNormalTexture>(vertices.ToArray()); vertDeclaration = new VertexDeclaration(GraphicOptions.graphics.GraphicsDevice, VertexPositionNormalTexture.VertexElements); List <Vector3> points = new List <Vector3>(); foreach (VertexPositionNormalTexture vertex in vertices) { points.Add(vertex.Position); } this.boundingBox = BoundingBox.CreateFromPoints(points); this.BoundingSphere = BoundingSphere.CreateFromBoundingBox(boundingBox); }
public static void CalculateBounding(NodeContent node, ref BoundingBox box, ref BoundingSphere sphere) { if (node is MeshContent) { MeshContent mc = node as MeshContent; Vector3[] pts = new Vector3[mc.Positions.Count]; Fill(pts, mc.Positions); Matrix mat = mc.AbsoluteTransform; Vector3.Transform(pts, ref mat, pts); BoundingBox b2 = BoundingBox.CreateFromPoints(pts); box = BoundingBox.CreateMerged(box, b2); sphere = BoundingSphere.CreateFromBoundingBox(box); } foreach (NodeContent cld in node.Children) { CalculateBounding(cld, ref box, ref sphere); } }
public QuestGiver(Model model, Matrix world, QuestGiver questsGiverNeedToStart) : base(world, model) { questsList = new List <Quest>(); questCompleted = new List <Quest>(); this.questsGiverNeedToStart = questsGiverNeedToStart; position = world.Translation; position = position + new Vector3(0, -1f, 0); angle = 180; collider = new BoundingBox(new Vector3(world.Translation.X - colliderSize / 2, world.Translation.Y - colliderSize / 2, world.Translation.Z - colliderSize / 2), new Vector3(world.Translation.X + colliderSize / 2, world.Translation.Y + colliderSize / 2, world.Translation.Z + colliderSize / 2)); world = Matrix.CreateRotationX(MathHelper.ToRadians(-90)) * Matrix.CreateRotationY(angle) * Matrix.CreateTranslation(position); foreach (ModelMesh mesh in model.Meshes) { mesh.BoundingSphere = BoundingSphere.CreateFromBoundingBox(collider); } }
float GetStableShadowVolumeSize(Vector3D[] verticesPos, float shadowmapResolution) { BoundingSphere boundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue); BoundingBox boundingBox = BoundingBox.CreateInvalid(); foreach (var pos in verticesPos) { boundingBox.Min = Vector3.Min(boundingBox.Min, pos); boundingBox.Max = Vector3.Max(boundingBox.Max, pos); } boundingSphere = BoundingSphere.CreateFromBoundingBox(boundingBox); float baseSize = boundingSphere.Radius * 2; baseSize *= 1 + 1.0f / shadowmapResolution; return(baseSize); }
public void Render2DOverlay(PerspectiveCamera viewPoint, GBuffer gBuffer) { this.Effect.World = Matrix.Identity; this.Effect.View = Matrix.Identity; this.Effect.Projection = Matrix.Identity; this.Effect.DepthMap = gBuffer.DepthTarget; this.Effect.CameraPosition = viewPoint.Position; this.Effect.InverseViewProjection = viewPoint.InverseViewProjection; this.Device.PostProcessState(); foreach ((var entity, var component, var info, var property, var attribute) in this.EnumerateAttributes <BoundaryAttribute>()) { this.Effect.Color = info.Color2D; this.Effect.VisibleTint = info.VisibileIconTint; this.Effect.ClippedTint = info.ClippedIconTint; var boundary = property.GetGetMethod().Invoke(component, null); switch (attribute.Type) { case BoundaryType.Frustum: var frustum = (BoundingFrustum)boundary; if (viewPoint.Frustum.Intersects(frustum)) { this.Effect.WorldPosition = BoundingSphere.CreateFromFrustum(frustum).Center; this.Effect.Apply(ColorEffectTechniques.ColorPointDepthTest); this.Quad.RenderOutline(frustum, viewPoint); } break; case BoundaryType.BoundingBox: var boundingBox = (BoundingBox)boundary; if (viewPoint.Frustum.Intersects(boundingBox)) { this.Effect.WorldPosition = BoundingSphere.CreateFromBoundingBox(boundingBox).Center; this.Effect.Apply(ColorEffectTechniques.ColorPointDepthTest); this.Quad.RenderOutline(boundingBox, viewPoint); } break; } } }
//public Animal(Model model, String ModelName, ContentManager contentManager, Matrix world, float colliderSize, Camera cam) : base(world, model) //{ // this.cam = cam; // ifColisionTerrain = false; // position = world.Translation; // angle = 180; // collider = new BoundingBox(new Vector3(world.Translation.X - colliderSize / 2, world.Translation.Y - colliderSize / 2, world.Translation.Z - colliderSize / 2), // new Vector3(world.Translation.X + colliderSize / 2, world.Translation.Y + colliderSize / 2, world.Translation.Z + colliderSize / 2)); // this.colliderSize = colliderSize; // speedFactor = 100; // animationOffset = (float)rand.NextDouble() * 10; //} //ten kontruktor jest ok public Animal(Wolf wolf, Model model, Matrix world, float colliderSize, int meat, string kindOfAnimal) : base(world, model) { this.kindOfAnimal = kindOfAnimal; this.wolf = wolf; this.meat = meat; ifColisionTerrain = false; position = world.Translation; position = position + new Vector3(-8, -2.0f, -22); angle = 108; collider = new BoundingBox(new Vector3(world.Translation.X - colliderSize / 2, world.Translation.Y - colliderSize / 2, world.Translation.Z - colliderSize / 2), new Vector3(world.Translation.X + colliderSize / 2, world.Translation.Y + colliderSize / 2, world.Translation.Z + colliderSize / 2)); foreach (ModelMesh mesh in model.Meshes) { mesh.BoundingSphere = BoundingSphere.CreateFromBoundingBox(collider); } this.colliderSize = colliderSize; speedFactor = 6; }
/// <summary> /// Initialize this octree node. /// </summary> void InitOctreeBox(BoundingBox boundingBox) { // set bounding box and sphere LastBoundingBox = boundingBox; LastBoundingSphere = BoundingSphere.CreateFromBoundingBox(LastBoundingBox); // if not root, remove transformations if (!IsOctreeRoot) { Transformations = null; } // calculate half length _boxHalfLength = (boundingBox.Max - boundingBox.Min).Length() * 0.5f; // create the octree branches (subdivisions). if (_divisionsLeft > 0) { // create matrix of child trees and their bounding boxes _childOctrees = new OctreeCullingNode[2, 2, 2]; _childBoundingBoxes = new BoundingBox[2, 2, 2]; // get min, max, and step Vector3 min = boundingBox.Min; Vector3 max = boundingBox.Max; Vector3 step = (max - min) * 0.5f; // init bounding boxes Vector3 center = (LastBoundingBox.Max - LastBoundingBox.Min); for (int x = 0; x < 2; ++x) { for (int y = 0; y < 2; ++y) { for (int z = 0; z < 2; ++z) { Vector3 currMin = min + step * new Vector3(x, y, z); Vector3 currMax = currMin + step; _childBoundingBoxes[x, y, z] = new BoundingBox(currMin, currMax); } } } } }
protected override void Init(MyObjectBuilder_DefinitionBase baseBuilder) { base.Init(baseBuilder); Id = baseBuilder.Id; var builder = baseBuilder as MyObjectBuilder_PrefabDefinition; BoundingSphere = new BoundingSphere(Vector3.Zero, float.MinValue); PrefabPath = builder.PrefabPath; if (builder.CubeGrid == null && builder.CubeGrids == null) { return; } // Backwards compatiblity if (builder.CubeGrid != null) CubeGrids = new MyObjectBuilder_CubeGrid[1] { builder.CubeGrid }; else CubeGrids = builder.CubeGrids; BoundingBox = BoundingBox.CreateInvalid(); foreach (var grid in CubeGrids) { BoundingBox localBB = grid.CalculateBoundingBox(); Matrix gridTransform = grid.PositionAndOrientation.HasValue ? (Matrix)grid.PositionAndOrientation.Value.GetMatrix() : Matrix.Identity; BoundingBox.Include(localBB.Transform(gridTransform)); } BoundingSphere = BoundingSphere.CreateFromBoundingBox(BoundingBox); foreach (var gridBuilder in CubeGrids) { gridBuilder.CreatePhysics = true; gridBuilder.XMirroxPlane = null; gridBuilder.YMirroxPlane = null; gridBuilder.ZMirroxPlane = null; } }
public void Add(SceneNode node) { Vector3 center; node.BoxWorld.GetCenter(out center); var rootPositionGrid = new IntVector3 { X = (int)Math.Floor(center.X / RegionSize.X), Y = (int)Math.Floor(center.Y / RegionSize.Y), Z = (int)Math.Floor(center.Z / RegionSize.Z) }; Octree root; if (!rootsByPositionGrid.TryGetValue(rootPositionGrid, out root)) { root = octreePool.Borrow(); var min = new Vector3 { X = rootPositionGrid.X * RegionSize.X, Y = rootPositionGrid.Y * RegionSize.Y, Z = rootPositionGrid.Z * RegionSize.Z }; var box = new BoundingBox { Min = min, Max = min + RegionSize }; root.Box = box; root.Sphere = BoundingSphere.CreateFromBoundingBox(root.Box); rootsByPositionGrid[rootPositionGrid] = root; } Add(node, root); }
/// <summary> /// Propagate our global transform to the sub meshes, recomputing their bounding boxes /// </summary> private void UpdateSubMeshes() { Helpers.TransformBoundingBox(ref _localBoundingBox, ref _transform, out _globalBoundingBox); if (_model != null) { for (int i = 0; i < _model.Bones.Count; i++) { _transforms[i] = _model.Bones[i].Transform * _transform; } for (int i = 0; i < _subMeshes.Count; i++) { SubMesh subMesh = _subMeshes[i]; //compute the global transform for this submesh subMesh.GlobalTransform = _transforms[_model.Meshes[subMesh._modelIndex].ParentBone.Index]; MeshMetadata.SubMeshMetadata metadata = subMesh._metadata; BoundingBox source = metadata.BoundingBox; //compute the global bounding box Helpers.TransformBoundingBox(ref source, ref _transform, out subMesh.GlobalBoundingBox); subMesh.GlobalBoundingSphere = BoundingSphere.CreateFromBoundingBox(subMesh.GlobalBoundingBox); } } }
/// <summary> /// Create a bounding box for each model mesh /// </summary> private static BoundingBox BuildBoundingBox(ModelMesh mesh, ref BoundingSphere sphere) { // Create initial variables to hold min and max xyz values for the mesh Vector3 meshMax = new Vector3(float.MinValue); Vector3 meshMin = new Vector3(float.MaxValue); Vector3[] vertexPositions = null; foreach (ModelMeshPart part in mesh.MeshParts) { // The stride is how big, in bytes, one vertex is in the vertex buffer // We have to use this as we do not know the make up of the vertex int stride = part.VertexBuffer.VertexDeclaration.VertexStride; VertexPositionNormalTexture[] vertexData = new VertexPositionNormalTexture[part.NumVertices]; vertexPositions = new Vector3[part.NumVertices]; part.VertexBuffer.GetData(part.VertexOffset * stride, vertexData, 0, part.NumVertices, stride); // Find minimum and maximum xyz values for this mesh part Vector3 vertPosition = new Vector3(); for (int i = 0; i < vertexData.Length; i++) { vertPosition = vertexData[i].Position; vertexPositions[i] = vertexData[i].Position; // update our values from this vertex meshMin = Vector3.Min(meshMin, vertPosition); meshMax = Vector3.Max(meshMax, vertPosition); } } // Create the bounding box BoundingBox box = new BoundingBox(meshMin, meshMax); sphere = BoundingSphere.CreateFromBoundingBox(box); return(box); }
/// <summary> /// Create the BoundingBox and BoundingSphere for this patch. /// </summary> private void SetBoundingVolumes(float terrainScale, float heightScale, Vector3 terrainPosition) { int left = (int)mapOffset.X * TerrainPatch.patchSize; int right = left + TerrainPatch.patchSize; int top = (int)mapOffset.Y * TerrainPatch.patchSize; int bottom = top + TerrainPatch.patchSize; float minY = 1000000; float maxY = -1000000; for (int index = 0; index < meshes[0].vertices.Length; index++) { float height = meshes[0].vertices[index].VertexHeight; minY = (minY > height) ? height : minY; maxY = (maxY < height) ? height : maxY; } // Adjust bounding box extents bboxMin = new Vector3(left, minY * heightScale, top); bboxMax = new Vector3(right, maxY * heightScale, bottom); Vector3 scale = new Vector3(terrainScale); scale.Z = -scale.Z; // Transform bounding box to fit the actual terrain Matrix bboxTransform = Matrix.CreateScale(scale) * Matrix.CreateTranslation(terrainPosition); bboxMin = Vector3.Transform(bboxMin, bboxTransform); bboxMax = Vector3.Transform(bboxMax, bboxTransform); // Calculate the center point center = (bboxMin + bboxMax) / 2; boundingBox = new BoundingBox(bboxMin, bboxMax); boundingSphere = BoundingSphere.CreateFromBoundingBox(boundingBox); }
void CréerHitboxCaméra() { BoundingSphere temp = new BoundingSphere(); bool firstTime = true; int soldatsComptées = 0;; for (int i = 0; i < Armés.GetLength(0); i++) { for (int j = 0; j < Armés.GetLength(1); j++) { if (soldatsComptées <= NbVivants) { if (Armés[i, j] != null) { if (Armés[i, j].EstVivant) { if (EstDansLimiteTerrain(Armés[i, j])) { if (firstTime) { temp = BoundingSphere.CreateFromBoundingBox(Armés[i, j].HitBoxGénérale); firstTime = false; soldatsComptées++; } temp = BoundingSphere.CreateMerged(temp, BoundingSphere.CreateFromBoundingBox(Armés[i, j].HitBoxGénérale)); soldatsComptées++; } } } } } } Caméra.DonnerBoundingSphere(BoundingSphere.CreateMerged(temp, Flag.ViewFlag)); }
private static void SetupReading( int lodIndex, ref Vector3I minInLod, ref Vector3I maxInLod, out float lodVoxelSizeHalf, out BoundingBox queryBox, out BoundingSphere querySphere) { ProfilerShort.Begin("SetupReading"); lodVoxelSizeHalf = MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF * (1 << lodIndex); Vector3 localMin, localMax; { Vector3D localPositionD; var min = minInLod << lodIndex; var max = maxInLod << lodIndex; MyVoxelCoordSystems.VoxelCoordToLocalPosition(ref min, out localPositionD); localMin = localPositionD; MyVoxelCoordSystems.VoxelCoordToLocalPosition(ref max, out localPositionD); localMax = localPositionD; localMin -= lodVoxelSizeHalf; localMax += lodVoxelSizeHalf; } queryBox = new BoundingBox(localMin, localMax); BoundingSphere.CreateFromBoundingBox(ref queryBox, out querySphere); ProfilerShort.End(); }
public void Load() { CHeightmap heightmap = null; // for each heightmap component, create Model instance to enable Draw calls when rendering foreach (var renderable in Game1.Inst.Scene.GetComponents <C3DRenderable>()) { if (renderable.Value.GetType() != typeof(CHeightmap)) { continue; } heightmap = (CHeightmap)renderable.Value; int key = renderable.Key; /* use each color channel for different data, e.g. * R for height, * G for texture/material/terrain type, * B for fixed spawned models/entities (houses, trees etc.), * A for additional data */ List <ModelMesh> meshes = new List <ModelMesh>(); var bones = new List <ModelBone>(); var indices = new Dictionary <int, int[]>(); var vertices = new Dictionary <int, VertexPositionNormalColor[]>(); CreateIndicesChunk(heightmap, ref indices, 0); CalculateHeightData(heightmap, key); CreateVerticesChunks(heightmap, ref vertices, 0, 0); //basicEffect.Texture = heightmap.Image; basicEffect.DiffuseColor = new Vector3(1, 1, 1); basicEffect.SpecularPower = 100; basicEffect.SpecularColor = new Vector3(0.25f); basicEffect.EnableDefaultLighting(); basicEffect.LightingEnabled = true; basicEffect.AmbientLightColor = Game1.Inst.Scene.LightConfig.AmbientColor; basicEffect.DirectionalLight0.SpecularColor = Game1.Inst.Scene.LightConfig.SpecularColor; basicEffect.DirectionalLight0.Direction = Game1.Inst.Scene.LightConfig.Direction; basicEffect.DirectionalLight0.DiffuseColor = Game1.Inst.Scene.LightConfig.DiffuseColor; basicEffect.DirectionalLight0.Enabled = true; basicEffect.PreferPerPixelLighting = true; for (int j = 0; j < vertices.Values.Count; j++) { var vert = vertices[j]; var ind = indices[j]; CalculateNormals(ref vert, ref ind); /* * for(int i = 0; i < vertices[j].Length; i++) * vertices[j][i].Color = Color.ForestGreen; */ vertices[j] = vert; indices[j] = ind; var modelpart = CreateModelPart(vert, ind); List <ModelMeshPart> meshParts = new List <ModelMeshPart>(); meshParts.Add(modelpart); ModelMesh modelMesh = new ModelMesh(mGraphicsDevice, meshParts); modelMesh.BoundingSphere = new BoundingSphere(); ModelBone modelBone = new ModelBone(); modelBone.AddMesh(modelMesh); modelBone.Transform = Matrix.CreateTranslation(new Vector3(0, 0, 0)); // changing object world (frame) / origo modelMesh.ParentBone = modelBone; bones.Add(modelBone); meshes.Add(modelMesh); modelMesh.BoundingSphere = BoundingSphere.CreateFromBoundingBox(GenericUtil.BuildBoundingBoxForVertex(vert, Matrix.Identity)); modelpart.Effect = basicEffect; } ModelMeshPart ground = buildGround(heightmap, 20); List <ModelMeshPart> groundMeshParts = new List <ModelMeshPart>(); groundMeshParts.Add(ground); ModelMesh groundMesh = new ModelMesh(mGraphicsDevice, groundMeshParts); groundMesh.BoundingSphere = new BoundingSphere(); ModelBone groundBone = new ModelBone(); groundBone.AddMesh(groundMesh); groundBone.Transform = Matrix.CreateTranslation(new Vector3(0, 0, 0)); groundMesh.ParentBone = groundBone; groundMesh.Name = "FrontFace"; bones.Add(groundBone); meshes.Add(groundMesh); ground.Effect = basicEffect; heightmap.model = new Model(mGraphicsDevice, bones, meshes); heightmap.model.Tag = "Map"; } }
public void Load() { // for each heightmap component, create Model instance to enable Draw calls when rendering foreach (var renderable in Game1.Inst.Scene.GetComponents <C3DRenderable>()) { if (renderable.Value.GetType() != typeof(CHeightmap)) { continue; } CHeightmap heightmap = (CHeightmap)renderable.Value; /* use each color channel for different data, e.g. * R for height, * G for texture/material/terrain type, * B for fixed spawned models/entities (houses, trees etc.), * A for additional data */ List <ModelMesh> meshes = new List <ModelMesh>(); var bones = new List <ModelBone>(); var indices = new Dictionary <int, int[]>(); var vertices = new Dictionary <int, VertexPositionNormalColor[]>(); CreateIndicesChunk(heightmap, ref indices, 0); CalculateHeightData(heightmap); CreateVerticesChunks(heightmap, ref vertices, 0, 0); for (int j = 0; j < vertices.Values.Count; j++) { var vert = vertices[j]; var ind = indices[j]; CalculateNormals(ref vert, ref ind); vertices[j] = vert; indices[j] = ind; var modelpart = CreateModelPart(vert, ind); List <ModelMeshPart> meshParts = new List <ModelMeshPart>(); meshParts.Add(modelpart); ModelMesh modelMesh = new ModelMesh(mGraphicsDevice, meshParts); modelMesh.BoundingSphere = new BoundingSphere(); ModelBone modelBone = new ModelBone(); modelBone.AddMesh(modelMesh); modelBone.Transform = Matrix.CreateTranslation(new Vector3(0, 0, 0)); // changing object world (frame) / origo modelMesh.ParentBone = modelBone; bones.Add(modelBone); meshes.Add(modelMesh); modelMesh.BoundingSphere = BoundingSphere.CreateFromBoundingBox(GenericUtil.BuildBoundingBoxForVertex(vert, Matrix.Identity)); modelpart.Effect = basicEffect; } ModelMeshPart ground = buildGround(heightmap, 20); List <ModelMeshPart> groundMeshParts = new List <ModelMeshPart>(); groundMeshParts.Add(ground); ModelMesh groundMesh = new ModelMesh(mGraphicsDevice, groundMeshParts); groundMesh.BoundingSphere = new BoundingSphere(); ModelBone groundBone = new ModelBone(); groundBone.AddMesh(groundMesh); groundBone.Transform = Matrix.CreateTranslation(new Vector3(0, 0, 0)); groundMesh.ParentBone = groundBone; groundMesh.Name = "FrontFace"; bones.Add(groundBone); meshes.Add(groundMesh); ground.Effect = basicEffect; heightmap.model = new Model(mGraphicsDevice, bones, meshes); heightmap.model.Tag = "Map"; } }