/// <summary> /// Get the bounding sphere of the model /// </summary> public BoundingBox GetBoundingBox(Model model, Matrix location, float scale) { BoundingSphere sphere = new BoundingSphere(); //Get the bounding Sphere of the tank foreach (ModelMesh mesh in model.Meshes) { if (sphere.Radius == 0) { sphere = mesh.BoundingSphere; } else { sphere = BoundingSphere.CreateMerged(sphere, mesh.BoundingSphere); } } // world. Vector3 Position = new Vector3(location.M41, location.M42, location.M43); sphere.Center = Position; sphere.Radius = scale; BoundingBox box = BoundingBox.CreateFromSphere(sphere); return(box); }
public void initialise() { foreach (ModelMesh mesh in _carModel.Meshes) { _boundingSphere = BoundingSphere.CreateMerged(_boundingSphere, mesh.BoundingSphere); } _physicsManager = new PhysicsManager(); _position = new Vector3((150 * 2), 0, (200 * 2)); _rotation = Quaternion.CreateFromAxisAngle(new Vector3(0, -1, 0), MathHelper.PiOver2); _we = 0; _tractionForce = 0; _dragForce = 0; _cDrag = 0; _rollingForce = 0; _steeringAngle = 0; _steeringRadius = 0; _throttlePosition = 0; _brakingPosition = 0; _velocity = Vector3.Zero; _force = Vector3.Zero; _engineState = ON; _currentGear = "Neutral"; _currentRPM = 1000; }
public BoundingSphere MergeModelSpheres(Model model, TransformComponent transform) { var sphere = new BoundingSphere(); foreach (var mesh in model.Meshes) { if (sphere.Radius == 0) { sphere = mesh.BoundingSphere; } else { sphere = BoundingSphere. CreateMerged(sphere, mesh.BoundingSphere); } } sphere.Center = transform.Position; if (transform.Scale.X > transform.Scale.Y && transform.Scale.X > transform.Scale.Z) { sphere.Radius *= transform.Scale.X; } else if (transform.Scale.Y > transform.Scale.X && transform.Scale.Y > transform.Scale.Z) { sphere.Radius *= transform.Scale.Y; } else { sphere.Radius *= transform.Scale.Z; } return(sphere); }
public void LoadContent(Wind _wind) { effect = GameStateManager.Instance.Content.Load <Effect>("Effects/shader"); model = GameStateManager.Instance.Content.Load <Model>("Models/BeachBall"); ballTexture = GameStateManager.Instance.Content.Load <Texture2D>("Textures/BeachBallTexture"); ballShadow = GameStateManager.Instance.Content.Load <Texture2D>("Images/BallShadow"); //BoundingSphere erstellen boundingSphere = new BoundingSphere(); foreach (ModelMesh mesh in model.Meshes) { if (boundingSphere.Radius == 0) { boundingSphere = mesh.BoundingSphere; } else { boundingSphere = BoundingSphere.CreateMerged(boundingSphere, mesh.BoundingSphere); } } boundingSphere.Radius *= 1.0f; originalRadius = boundingSphere.Radius; boundingSphere.Center = position; wind = _wind; Initialize(); }
public static BoundingSphere MergeWith( this BoundingSphere first, BoundingSphere second ) { return(BoundingSphere.CreateMerged(first, second)); }
protected override void LoadContent() { ContentData.viewPort = GraphicsDevice.Viewport; spriteBatch = new SpriteBatch(GraphicsDevice); contentData.gameFont = Content.Load <SpriteFont>("interface"); contentData.menuFont = Content.Load <SpriteFont>("menu"); contentData.menuHelpFont = Content.Load <SpriteFont>("menuHelp"); spriteBatch = new SpriteBatch(GraphicsDevice); contentData.logo = Content.Load <Texture2D>("logo"); contentData.menu = Content.Load <Song>("Battlestar Galactica Opening"); contentData.inGame = Content.Load <Song>("All Along The Watchtower"); // Projectiles and fx contentData.explosion = Content.Load <Texture2D>("explosion_animation"); contentData.laser = Content.Load <Texture2D>("laser"); contentData.energyCells = Content.Load <Texture2D>("energy_cells"); contentData.gameOver = Content.Load <Texture2D>("game_over"); // Scrolling background contentData.space = Content.Load <Texture2D>("space"); contentData.spaceDust = Content.Load <Texture2D>("space_dust"); // 3d models contentData.viperMarkII = Content.Load <Model>("Viper_Mk_II"); BoundingSphere boundingSphere = new BoundingSphere(); foreach (var mesh in contentData.viperMarkII.Meshes) { foreach (BasicEffect fx in mesh.Effects) { fx.EnableDefaultLighting(); fx.SpecularColor = Color.White.ToVector3(); fx.DiffuseColor = Color.Gray.ToVector3(); fx.AmbientLightColor = Color.White.ToVector3(); } boundingSphere = BoundingSphere.CreateMerged(boundingSphere, mesh.BoundingSphere); } ContentData.viperMarkIIBoundingRadius = boundingSphere.Radius; contentData.raider = Content.Load <Model>("Cylon_Raider"); boundingSphere = new BoundingSphere(); foreach (var mesh in contentData.raider.Meshes) { foreach (BasicEffect fx in mesh.Effects) { fx.EnableDefaultLighting(); fx.SpecularColor = Color.Gray.ToVector3(); fx.DiffuseColor = Color.Gray.ToVector3(); fx.AmbientLightColor = Color.White.ToVector3(); } boundingSphere = BoundingSphere.CreateMerged(boundingSphere, mesh.BoundingSphere); } ContentData.raiderBoundingRadius = boundingSphere.Radius; // Initialize menu background music MediaPlayer.Volume = 1.0f; MediaPlayer.Play(contentData.menu); }
/// <summary> /// Load your graphics content. /// </summary> protected override void LoadContent() { spriteBatch = new SpriteBatch(graphics.GraphicsDevice); spriteFont = Content.Load <SpriteFont>("gameFont"); string[] modelNames = new[] { @"Tank", @"75Cathedral-model", @"Jane_solid_3ds", @"Primitives\Cube", @"Primitives\Cylinder", @"Primitives\Plane", @"Primitives\Sphere", @"Primitives\Teapot", @"Primitives\Torus", @"Primitives\Combined", }; _models = new Model[modelNames.Length]; _modelBoundingSpheres = new BoundingSphere[modelNames.Length]; for (int i = 0; i < modelNames.Length; ++i) { _models[i] = Content.Load <Model>(modelNames[i]); BoundingSphere boundingSphere = new BoundingSphere(); foreach (ModelMesh mesh in _models[i].Meshes) { boundingSphere = BoundingSphere.CreateMerged(boundingSphere, mesh.BoundingSphere); } _modelBoundingSpheres[i] = boundingSphere; } }
private void SetBoundingBox() { BoundingSphere mergedSphere = new BoundingSphere(); BoundingSphere[] boundingSpheres; int index = 0; int meshCount = model.Meshes.Count; boundingSpheres = new BoundingSphere[meshCount]; foreach (ModelMesh mesh in model.Meshes) { boundingSpheres[index++] = mesh.BoundingSphere; } mergedSphere = boundingSpheres[0]; if ((meshCount) > 1) { index = 1; do { mergedSphere = BoundingSphere.CreateMerged(mergedSphere, boundingSpheres[index]); index++; } while (index < meshCount); } mergedSphere.Center = position; }
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)); }
protected BoundingSphere MergedBoundingSphere(Model model) { BoundingSphere mergedSphere = new BoundingSphere(); BoundingSphere[] boundingSpheres; int index = 0; int meshCount = model.Meshes.Count; boundingSpheres = new BoundingSphere[meshCount]; foreach (ModelMesh mesh in model.Meshes) { boundingSpheres[index++] = mesh.BoundingSphere; } mergedSphere = boundingSpheres[0]; if ((model.Meshes.Count) > 1) { index = 1; do { mergedSphere = BoundingSphere.CreateMerged(mergedSphere, boundingSpheres[index]); index++; } while (index < model.Meshes.Count); } mergedSphere.Center.Y = 0; return(mergedSphere); }
protected override void LoadContent() { contentManager = new ContentManager(Game.Services, "Content/meshes"); model = contentManager.Load <Model>(modelName); bones = new Matrix[model.Bones.Count]; foreach (ModelMesh mesh in model.Meshes) { ModelBounds = BoundingSphere.CreateMerged(ModelBounds, mesh.BoundingSphere); } if (enableCelShading) { //Cel Shading celLightingEffect = contentManager.Load <Effect>("Cel"); GetEffectParameters(); if (textureName == null) { textureName = "2031"; } modelTexture = contentManager.Load <Texture2D>(textureName); //Calculate the projection properties first on any //load callback. That way if the window gets resized, //the perspective matrix is updated accordingly float aspectRatio = (float)GraphicsDevice.Viewport.Width / (float)GraphicsDevice.Viewport.Height; float fov = MathHelper.PiOver4 * aspectRatio * 3 / 4; projection = hostScreen.ProjectionMatrix; } base.LoadContent(); }
private BoundingSphere CalculateBounds(SceneTemplate scene) { var instance = scene.CreateInstance(); instance.SetPoseTransforms(); var bounds = default(BoundingSphere); foreach (var d in instance.DrawableReferences) { var b = _Meshes[d.MeshIndex].BoundingSphere; if (d.Transform is Transforms.RigidTransform statXform) { b = b.Transform(statXform.WorldMatrix.ToXna()); } if (d.Transform is Transforms.SkinnedTransform skinXform) { // this is a bit agressive and probably over-reaching, but with skins you never know the actual bounds // unless you calculate the bounds frame by frame. var bb = b; foreach (var xb in skinXform.SkinMatrices.Select(item => bb.Transform(item.ToXna()))) { b = BoundingSphere.CreateMerged(b, xb); } } bounds = bounds.Radius == 0 ? b : BoundingSphere.CreateMerged(bounds, b); } return(bounds); }
/// <summary> /// Obtiene el índice de crecimiento al añadir los volúmenes especificados /// </summary> /// <param name="sphere1">Esfera primera</param> /// <param name="sphere2">Esfera segunda</param> /// <returns>Devuelve el índice de crecimiento al añadir los volúmenes especificados</returns> private float GetGrowth(BoundingSphere sphere1, BoundingSphere sphere2) { BoundingSphere newSphere = BoundingSphere.CreateMerged(sphere1, sphere2); // Se devuelve un valor proporcional al cambio en el área de superficie de la esfera return((newSphere.Radius * newSphere.Radius) - (sphere1.Radius * sphere1.Radius)); }
/// <summary> /// Construye la jerarquía del nodo actual /// </summary> /// <param name="northWest">Nodo al noroeste</param> /// <param name="northEast">Nodo al noreste</param> /// <param name="southWest">Nodo al suroeste</param> /// <param name="southEast">Nodo al sureste</param> public virtual void Build(SceneryNode northWest, SceneryNode northEast, SceneryNode southWest, SceneryNode southEast) { northWest.Parent = this; northEast.Parent = this; southWest.Parent = this; southEast.Parent = this; Childs.Clear(); Childs.Add(NodeHeads.NorthWest, northWest); Childs.Add(NodeHeads.NorthEast, northEast); Childs.Add(NodeHeads.SouthWest, southWest); Childs.Add(NodeHeads.SouthEast, southEast); BoundingBox northAABB = BoundingBox.CreateMerged(northWest.m_AABB, northEast.m_AABB); BoundingBox southAABB = BoundingBox.CreateMerged(southWest.m_AABB, southEast.m_AABB); m_AABB = BoundingBox.CreateMerged(northAABB, southAABB); BoundingSphere northSPH = BoundingSphere.CreateMerged(northWest.m_SPH, northEast.m_SPH); BoundingSphere southSPH = BoundingSphere.CreateMerged(southWest.m_SPH, southEast.m_SPH); m_SPH = BoundingSphere.CreateMerged(northSPH, southSPH); NodeCenter = Vector3.Divide(m_AABB.Max + m_AABB.Min, 2.0f); }
public void LoadContent(ContentManager Content) { // Load the assets for the Earth. model = Content.Load <Model>(@"Models\earth"); effect = Content.Load <Effect>(@"Effects\earth"); dayTexture = Content.Load <Texture2D>(@"Textures\earth_day_color_spec"); nightTexture = Content.Load <Texture2D>(@"Textures\earth_night_color"); cloudTexture = Content.Load <Texture2D>(@"Textures\earth_clouds_alpha"); normalMapTexture = Content.Load <Texture2D>(@"Textures\earth_nrm"); // Setup material settings for the Earth. ambient = new Vector4(0.3f, 0.3f, 0.3f, 1.0f); diffuse = new Vector4(0.7f, 0.7f, 0.7f, 1.0f); specular = new Vector4(0.7f, 0.7f, 0.7f, 1.0f); shininess = 20.0f; cloudStrength = 1.15f; // Calculate the bounding sphere of the Earth model and bind the // custom Earth effect file to the model. foreach (ModelMesh mesh in model.Meshes) { bounds = BoundingSphere.CreateMerged(bounds, mesh.BoundingSphere); foreach (ModelMeshPart part in mesh.MeshParts) { part.Effect = effect; } } }
public Hazard(Vector3 position, float speed, bool alive, bool barrelRollin, float rollRandomMod) { this.position = position; this.world = Matrix.CreateTranslation(position); this.speed = speed; this.alive = alive; this.yaw = 0; this.pitch = 0; this.roll = 0; this.barrelRollin = barrelRollin; this.rollRandomMod = rollRandomMod; this.explosionSize = 0.5f; this.observers = new List <Observer>(); this.scoreObserver = new ScoreObserver(); AddObserver(scoreObserver); velocity = Vector3.Forward; defaultSpeed = new Vector3(0, 0, speed); foreach (ModelMesh mesh in HazardForm.Model.Meshes) { boundingSphere = BoundingSphere.CreateMerged(this.boundingSphere, mesh.BoundingSphere); } boundingSphere.Radius *= HazardForm.scale; }
public Teleporter(Model model, BasicEffect effect, List <BoundingBox> boundingBoxes, float offset) { this.model = model; this.effect = effect; this.boundingBoxes = boundingBoxes; this.offset = offset; isOnPlayer = true; position = Vector3.Zero; transforms = new Matrix[model.Bones.Count]; model.CopyAbsoluteBoneTransformsTo(transforms); sphere = model.Meshes[0].BoundingSphere; sphere.Radius -= 0.22f; sphere.Center.Y += sphereCenterOffset; if (model.Meshes.Count > 1) { foreach (ModelMesh mesh in model.Meshes) { sphere = BoundingSphere.CreateMerged(sphere, mesh.BoundingSphere); } } sphere = sphere.Transform(scaleMatrix); }
/// <summary> /// Initializes a new instance of the <see cref="CustomModel"/> class. /// </summary> /// <param name="factory">The factory.</param> /// <param name="loader">The loader.</param> public CustomModel(GraphicFactory factory, ObjectInformation[] loader) : base(factory, loader[0].modelName, false) { System.Diagnostics.Debug.Assert(loader != null); System.Diagnostics.Debug.Assert(loader.Count() != 0); BatchInformations = new BatchInformation[1][]; BatchInformations[0] = new BatchInformation[loader.Count()]; TextureInformations = new TextureInformation[1][]; TextureInformations[0] = new TextureInformation[loader.Count()]; BoundingSphere bs = new BoundingSphere(); for (int i = 0; i < loader.Count(); i++) { BatchInformations[0][i] = loader[i].batchInformation; TextureInformations[0][i] = loader[i].textureInformation; float radius; Vector3 center; ModelBuilderHelper.ExtractModelRadiusAndCenter(BatchInformations[0][i], out radius, out center); bs = BoundingSphere.CreateMerged(bs, new BoundingSphere(center, radius)); } modelRadius = bs.Radius; }
/// <summary> /// Calculated a single bounding sphere for this model, call whenever the model changes. /// </summary> private void CalculateBoundingSphere() { foreach (ModelMesh mesh in model.Meshes) { BoundingSphere meshBoundingSphere = mesh.BoundingSphere; BoundingSphere.CreateMerged(ref bounds, ref meshBoundingSphere, out bounds); } }
public void CreateMerged_Contains() { var a = new BoundingSphere(Vector3.Zero, 5); var b = new BoundingSphere(new Vector3(1, 0, 0), 2); var m = BoundingSphere.CreateMerged(a, b); Assert.AreEqual(a, m); }
protected void initBoundingSphere() { foreach (ModelMesh mesh in model.Meshes) { boundingSphere = BoundingSphere.CreateMerged(boundingSphere, mesh.BoundingSphere); } boundingSphere = boundingSphere.Transform(world); }
public void CreateMerged_Intersect() { var a = new BoundingSphere(Vector3.Zero, 5); var b = new BoundingSphere(new Vector3(6, 0, 0), 5); var m = BoundingSphere.CreateMerged(a, b); Assert.AreEqual(ContainmentType.Contains, m.Contains(a)); Assert.AreEqual(ContainmentType.Contains, m.Contains(b)); }
public override void LoadContent() { model = XNAGame.Instance.Content.Load <Model>(modelName); worldTransform = Matrix.CreateWorld(Position, Look, Up); foreach (ModelMesh mesh in model.Meshes) { BoundingSphere = BoundingSphere.CreateMerged(BoundingSphere, mesh.BoundingSphere); } }
public void CreateMerged_Contains2() { var a = new BoundingSphere(new Vector3(1, 0, 0), 2); var b = new BoundingSphere(Vector3.Zero, 5); var m = BoundingSphere.CreateMerged(a, b); Assert.AreEqual(ContainmentType.Contains, b.Contains(a)); Assert.AreEqual(ContainmentType.Intersects, a.Contains(b)); Assert.AreEqual(b, m); }
static public BoundingSphere GetSceneSphere(this Model model) { BoundingSphere sceneSphere = new BoundingSphere(); foreach (ModelMesh mesh in model.Meshes) { BoundingSphere boundingSphere = mesh.BoundingSphere; sceneSphere = BoundingSphere.CreateMerged(sceneSphere, boundingSphere); } return(sceneSphere); }
private Model model; // Variável para carregar o modelo 3d da nave /// <summary> /// Construtor que inicializa o modelo da nave /// </summary> /// <param name="content"></param> /// <param name="path"></param> public NaveModel(ContentManager content, string path) { //Load do modelo da nave model = content.Load <Model>(path); //Criação de Bounding Sphere para a Nave foreach (ModelMesh mesh in this.model.Meshes) { boundingSphere = BoundingSphere.CreateMerged(this.boundingSphere, mesh.BoundingSphere); } }
/// <summary> /// Calculate bounding sphere and return results. /// This also set internal caching. /// </summary> /// <returns>Bounding sphere of the node and its children.</returns> public virtual BoundingSphere UpdateBoundingSphere() { // count event Utils.CountAndAlert.Count(Utils.CountAndAlert.PredefAlertTypes.HeavyUpdate); // if empty skip if (Empty) { _boundingSphereDirty = false; LastBoundingSphere = EmptyBoundingSphere; return(EmptyBoundingSphere); } // make sure transformations are up-to-date DoTransformationsUpdateIfNeeded(); // bounding sphere to return BoundingSphere ret = new BoundingSphere(); // calculate all child nodes bounding spheres foreach (Node child in _childNodes) { // skip invisible nodes if (!child.Visible) { continue; } // get bounding sphere BoundingSphere currSphere = child.GetBoundingSphere(); ret = BoundingSphere.CreateMerged(ret, currSphere); } // apply all entities directly under this node foreach (IEntity entity in _childEntities) { // skip invisible entities if (!entity.Visible) { continue; } // get entity bounding sphere BoundingSphere currSphere = entity.GetBoundingSphere(this, ref _localTransform, ref _worldTransform); ret = BoundingSphere.CreateMerged(ret, currSphere); } // put into cache _boundingSphereDirty = false; LastBoundingSphere = ret; // return final bounding sphere return(ret); }
protected BoundingSphere CalcBoundingSphere() { BoundingSphere sphere = new BoundingSphere(); for (int iMesh = 0; iMesh < listMeshRenderObj.Count; iMesh++) { MeshRenderObj meshRenderObj = listMeshRenderObj[iMesh] as MeshRenderObj; sphere = BoundingSphere.CreateMerged(sphere, meshRenderObj.BoundingSphere); } return(sphere); }
/// <summary> /// Loads the model. /// </summary> /// <param name="factory">The factory.</param> /// <param name="BatchInformations">The batch informations.</param> /// <param name="TextureInformations">The texture informations.</param> protected override void LoadModel(GraphicFactory factory, out BatchInformation[][] BatchInformations, out TextureInformation[][] TextureInformations) { skinnedModel = factory.GetAnimatedModel(Name); ModelBuilderHelper.Extract(factory, out BatchInformations, out TextureInformations, skinnedModel.Model, _diffuseName, _bumpName, _specularName, _glowName, isInternal); BoundingSphere sphere = new BoundingSphere(); foreach (var item in skinnedModel.Model.Meshes) { sphere = BoundingSphere.CreateMerged(sphere, item.BoundingSphere); } modelRadius = sphere.Radius; }
public virtual void UpdateBoundingVolume() { if (Model != null) { BoundingSphere = new BoundingSphere(); foreach (var mesh in Model.Meshes) { BoundingSphere = BoundingSphere.CreateMerged(mesh.BoundingSphere.Transform(mesh.ParentBone.Transform), BoundingSphere); } BoundingSphere = BoundingSphere.Transform(Matrix.CreateScale(Scale) * Matrix.CreateTranslation(Position)); } }
public virtual void UpdateBoundingVolume() { if (Model != null) { BoundingSphere = new BoundingSphere(); foreach (var mesh in Model.Meshes) { BoundingSphere = BoundingSphere.CreateMerged(mesh.BoundingSphere.Transform(mesh.ParentBone.Transform), BoundingSphere); } BoundingSphere = BoundingSphere.Transform(Matrix.CreateScale(Scale) * Matrix.CreateTranslation(Position)); } }
protected override void LoadContent() { if (asset != null) this.model = Game.Content.Load<Model>("Models/"+asset); Matrix[] transforms = new Matrix[this.model.Bones.Count]; this.model.CopyAbsoluteBoneTransformsTo(transforms); BoundingBox = new BoundingBox(); BoundingSphere = new BoundingSphere(); for (int m = 0; m < this.model.Meshes.Count; m++) { ModelMesh mm = this.model.Meshes[m]; BoundingBox partBox = new BoundingBox(); for (int p = 0; p < mm.MeshParts.Count; p++) { ModelMeshPart part = mm.MeshParts[p]; Vector3[] vertices = part.GetVertexElement(VertexElementUsage.Position); partBox = BoundingBox.CreateFromPoints(vertices); } partBox.Min = Vector3.Transform(partBox.Min, transforms[mm.ParentBone.Index]); partBox.Max = Vector3.Transform(partBox.Max, transforms[mm.ParentBone.Index]); BoundingBox = partBox; BoundingSphere = BoundingSphere.CreateMerged(BoundingSphere, mm.BoundingSphere); } base.LoadContent(); }