/// <summary> /// Extends the box to contain the supplied box. /// </summary> public static Box3 ExtendBy(this Box3 thisBox, Box3 box) { if (box.Minimum.X < thisBox.Minimum.X) { thisBox.Minimum.X = box.Minimum.X; } if (box.Maximum.X > thisBox.Maximum.X) { thisBox.Maximum.X = box.Maximum.X; } if (box.Minimum.Y < thisBox.Minimum.Y) { thisBox.Minimum.Y = box.Minimum.Y; } if (box.Maximum.Y > thisBox.Maximum.Y) { thisBox.Maximum.Y = box.Maximum.Y; } if (box.Minimum.Z < thisBox.Minimum.Z) { thisBox.Minimum.Z = box.Minimum.Z; } if (box.Maximum.Z > thisBox.Maximum.Z) { thisBox.Maximum.Z = box.Maximum.Z; } return(thisBox); }
private void UpdateGridLines(BoundingBox bb) { GridWidth = bb.Width + 16; GridLength = bb.Height + 16; RaisePropertyChanged("GridWidth"); RaisePropertyChanged("GridLength"); }
/// <summary> /// Extends the box to contain the supplied value. /// </summary> public static Box3 ExtendBy(this Box3 thisBox, Vector3 point) { if (point.X < thisBox.Minimum.X) { thisBox.Minimum.X = point.X; } if (point.X > thisBox.Maximum.X) { thisBox.Maximum.X = point.X; } if (point.Y < thisBox.Minimum.Y) { thisBox.Minimum.Y = point.Y; } if (point.Y > thisBox.Maximum.Y) { thisBox.Maximum.Y = point.Y; } if (point.Z < thisBox.Minimum.Z) { thisBox.Minimum.Z = point.Z; } if (point.Z > thisBox.Maximum.Z) { thisBox.Maximum.Z = point.Z; } return(thisBox); }
private BoundingBox GetBoundingBox(Scene scene) { SharpDX.BoundingBox box = new SharpDX.BoundingBox(); if (scene.HasMeshes) { foreach (Mesh mesh in scene.Meshes) { SharpDX.BoundingBox meshBox = GetBoundingBox(mesh); box.Minimum.X = Math.Min(box.Minimum.X, meshBox.Minimum.X); box.Minimum.Y = Math.Min(box.Minimum.Y, meshBox.Minimum.Y); box.Minimum.Z = Math.Min(box.Minimum.Z, meshBox.Minimum.Z); box.Maximum.X = Math.Max(box.Maximum.X, meshBox.Maximum.X); box.Maximum.Y = Math.Max(box.Maximum.Y, meshBox.Maximum.Y); box.Maximum.Z = Math.Max(box.Maximum.Z, meshBox.Maximum.Z); } } BoundingBox newBox = new BoundingBox(); newBox.Center.X = (box.Minimum.X + box.Maximum.X) / 2.0f; newBox.Center.Y = (box.Minimum.Y + box.Maximum.Y) / 2.0f; newBox.Center.Z = (box.Minimum.Z + box.Maximum.Z) / 2.0f; newBox.Extents.X = Math.Abs(box.Maximum.X - newBox.Center.X); newBox.Extents.Y = Math.Abs(box.Maximum.Y - newBox.Center.Y); newBox.Extents.Z = Math.Abs(box.Maximum.Z - newBox.Center.Z); return(newBox); }
private void ClampBoundingBox(ref BoundingBox bb) { bb.Minimum.X = Math.Max(bb.Minimum.X, -MAX_GRID_LENGTH); bb.Minimum.Y = Math.Max(bb.Minimum.Y, -MAX_GRID_LENGTH); bb.Minimum.Z = Math.Max(bb.Minimum.Z, -MAX_GRID_LENGTH); bb.Maximum.X = Math.Min(bb.Maximum.X, MAX_GRID_LENGTH); bb.Maximum.Y = Math.Min(bb.Maximum.Y, MAX_GRID_LENGTH); bb.Maximum.Z = Math.Min(bb.Maximum.Z, MAX_GRID_LENGTH); }
public bool Contains(BoundingBox box) { var min = box.Minimum.ToSharpDX() / FRUSTUM_DIVISOR; var max = box.Maximum.ToSharpDX() / FRUSTUM_DIVISOR; var sharpBox = new SharpDX.BoundingBox(min, max); var contains = _frustum.Contains(ref sharpBox); return(contains == ContainmentType.Contains || contains == ContainmentType.Intersects); }
/// <summary> /// Extends the box to contain the supplied value. /// </summary> public static Box3 ExtendZBy(this Box3 thisBox, float z) { if (z < thisBox.Minimum.Z) { thisBox.Minimum.Z = z; } if (z > thisBox.Maximum.Z) { thisBox.Maximum.Z = z; } return(thisBox); }
/// <summary> /// Extends the box to contain the supplied value. /// </summary> public static Box3 ExtendXBy(this Box3 thisBox, float x) { if (x < thisBox.Minimum.X) { thisBox.Minimum.X = x; } if (x > thisBox.Maximum.X) { thisBox.Maximum.X = x; } return(thisBox); }
/// <summary> /// Extends the box to contain the supplied value. /// </summary> public static Box3 ExtendYBy(this Box3 thisBox, float y) { if (y < thisBox.Minimum.Y) { thisBox.Minimum.Y = y; } if (y > thisBox.Maximum.Y) { thisBox.Maximum.Y = y; } return(thisBox); }
public GTADetection(Entity e, DetectionType type) { Type = type; Pos = new GTAVector(e.Position); Distance = Game.Player.Character.Position.DistanceTo(e.Position); BBox = GTAData.ComputeBoundingBox(e, e.Position); Handle = e.Handle; Rot = new GTAVector(e.Rotation); cls = DetectionClass.Unknown; Vector3 gmin; Vector3 gmax; e.Model.GetDimensions(out gmin, out gmax); BBox3D = new SharpDX.BoundingBox((SharpDX.Vector3) new GTAVector(gmin), (SharpDX.Vector3) new GTAVector(gmax)); }
public bool InitializeGraphics(IRenderManager manager, Device device) { // Compute the bounding box extents. SharpDX.BoundingBox box = new SharpDX.BoundingBox(this.BoundMin.ToVector3(), this.BoundMax.ToVector3()); // Allocate the vertex array. this.vertices = new D3DColoredVertex[8]; // Calculate the half-widths of the box. float halfWidth = box.Width / 2.0f; float halfHeight = box.Height / 2.0f; float halfDepth = box.Depth / 2.0f; // Build the vertex array from the bounding box info. this.vertices[0].Position = new Vector3(box.Center.X - halfWidth, box.Center.Y - halfHeight, box.Center.Z + halfDepth); this.vertices[1].Position = new Vector3(box.Center.X + halfWidth, box.Center.Y - halfHeight, box.Center.Z + halfDepth); this.vertices[2].Position = new Vector3(box.Center.X + halfWidth, box.Center.Y - halfHeight, box.Center.Z - halfDepth); this.vertices[3].Position = new Vector3(box.Center.X - halfWidth, box.Center.Y - halfHeight, box.Center.Z - halfDepth); this.vertices[4].Position = new Vector3(box.Center.X - halfWidth, box.Center.Y + halfHeight, box.Center.Z + halfDepth); this.vertices[5].Position = new Vector3(box.Center.X + halfWidth, box.Center.Y + halfHeight, box.Center.Z + halfDepth); this.vertices[6].Position = new Vector3(box.Center.X + halfWidth, box.Center.Y + halfHeight, box.Center.Z - halfDepth); this.vertices[7].Position = new Vector3(box.Center.X - halfWidth, box.Center.Y + halfHeight, box.Center.Z - halfDepth); // Setup the vertex buffer using the vertex data stream. BufferDescription desc = new BufferDescription(); desc.BindFlags = BindFlags.VertexBuffer; desc.CpuAccessFlags = CpuAccessFlags.Read | CpuAccessFlags.Write; desc.StructureByteStride = 28; desc.Usage = ResourceUsage.Default; this.vertexBuffer = SharpDX.Direct3D11.Buffer.Create <D3DColoredVertex>(device, BindFlags.VertexBuffer, this.vertices); // Setup the index buffer using the indice data. desc = new BufferDescription(); desc.BindFlags = BindFlags.IndexBuffer; desc.CpuAccessFlags = CpuAccessFlags.Read | CpuAccessFlags.Write; desc.StructureByteStride = 4; desc.Usage = ResourceUsage.Default; this.indexBuffer = SharpDX.Direct3D11.Buffer.Create <int>(device, BindFlags.IndexBuffer, this.BoxIndices); // Get the wireframe shader. this.shader = manager.GetBuiltInShader(BuiltInShaderType.Wireframe); return(true); }
private SharpDX.BoundingBox GetBoundingBox(Mesh sceneMesh) { SharpDX.BoundingBox box = new SharpDX.BoundingBox(); if (sceneMesh.HasVertices) { foreach (Vector3D v in sceneMesh.Vertices) { box.Minimum.X = Math.Min(v.X, box.Minimum.X); box.Minimum.Y = Math.Min(v.Y, box.Minimum.Y); box.Minimum.Z = Math.Min(v.Z, box.Minimum.Z); box.Maximum.X = Math.Max(v.X, box.Maximum.X); box.Maximum.Y = Math.Max(v.Y, box.Maximum.Y); box.Maximum.Z = Math.Max(v.Z, box.Maximum.Z); } } return(box); }
public void SetRenderMeshes(params Mesh[] meshes) { Models.Children.Clear(); bool firstMesh = true; BoundingBox bb = new BoundingBox(); _centerOfMass = new Point3D(); _centerOfGeometry = new Point3D(); foreach (var mesh in meshes) { var bakedMesh = ResourceCache.GetModel(mesh); Models.Children.Add(bakedMesh.Mesh); _centerOfMass = Point3D.Add(_centerOfMass, bakedMesh.CenterOfMass.ToVector3D()); if (firstMesh) { bb = bakedMesh.BoundingBox; firstMesh = false; } else { bb = BoundingBox.Merge(bb, bakedMesh.BoundingBox); } //bb = BoundingBox.Merge(bb, mesh.BoundingBox.ToSharpDxBoundingBox()); } if (meshes.Length > 0) { _centerOfMass.X /= meshes.Length; _centerOfMass.Y /= meshes.Length; _centerOfMass.Z /= meshes.Length; } ClampBoundingBox(ref bb); _modelBoundingBox = bb; _centerOfGeometry = _modelBoundingBox.Center.ToPoint3D(); ReferenceScale = CalculateReferenceScale(_modelBoundingBox); //UpdateGridLines(bb); RaisePropertyChanged("Models"); RefocusCenter(); RaisePropertyChanged("ReferenceScale"); }
public bool DrawFrame(IRenderManager manager, Device device) { // Compute the bounding box extents. SharpDX.BoundingBox box = new SharpDX.BoundingBox(this.BoundMin.ToVector3(), this.BoundMax.ToVector3()); // Compute the transformation matrix that will be used to transform the box vertices. Matrix transMatrix = Matrix.Scaling(box.Width, box.Height, box.Depth); transMatrix.Row4 = new Vector4(box.Center, transMatrix.Row4.W); // Loop and transform the vertices. for (int i = 0; i < this.vertices.Length; i++) { // Transform the current vertex. //this.vertices[i].Position = Vector4.Transform(this.BoxVertices[i], transMatrix).ToVector3(); this.vertices[i].Color = this.Color; } // Update the vertex buffer. device.ImmediateContext.UpdateSubresource(this.vertices, this.vertexBuffer); // Set the primitive type to line list. device.ImmediateContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.LineList; // Set the vertex and index buffers. device.ImmediateContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(this.vertexBuffer, 28, 0)); device.ImmediateContext.InputAssembler.SetIndexBuffer(this.indexBuffer, SharpDX.DXGI.Format.R32_UInt, 0); // Setup the wireframe shader. this.shader.DrawFrame(manager, device); // Draw the cube. device.ImmediateContext.DrawIndexed(24, 0, 0); return(true); }
public AxisAlignedBoundingBox(Vector3 min, Vector3 max) { this.sbb = new SharpDX.BoundingBox(min, max); }
private double CalculateReferenceScale(BoundingBox bb) { return(Math.Max(bb.Size.Length(), 0.001)); }
/// <summary> /// Determines if there is an intersection between the current object and a <see cref="SharpDX.BoundingBox"/>. /// </summary> /// <param name="box">The box to test.</param> /// <returns>Whether the two objects intersected.</returns> public bool Intersects(ref BoundingBox box) { return(Collision.BoxIntersectsSphere(ref box, ref this)); }
public static GTABoundingBox2 ComputeBoundingBox(Entity e, Vector3 offset, float scale = 0.5f) { var m = e.Model; var rv = new GTABoundingBox2 { Min = new GTAVector2(float.PositiveInfinity, float.PositiveInfinity), Max = new GTAVector2(float.NegativeInfinity, float.NegativeInfinity) }; Vector3 gmin; Vector3 gmax; m.GetDimensions(out gmin, out gmax); var bbox = new SharpDX.BoundingBox((SharpDX.Vector3) new GTAVector(gmin), (SharpDX.Vector3) new GTAVector(gmax)); //Console.WriteLine(bbox.GetCorners()[0]); /* * for (int i = 0; i < bbox.GetCorners().Length; ++i) { * for (int j = 0; j < bbox.GetCorners().Length; ++j) { * if (j == i) continue; * var c1 = bbox.GetCorners()[i]; * var c2 = bbox.GetCorners()[j]; * HashFunctions.Draw3DLine(e.GetOffsetInWorldCoords(new Vector3(c1.X, c1.Y, c1.Z)), e.GetOffsetInWorldCoords(new Vector3(c2.X, c2.Y, c2.Z)), 0,0); * } * } */ /* * for (int i = 0; i < bbox.GetCorners().Length; ++i) * { * var corner = bbox.GetCorners()[i]; * var cornerinworld = e.GetOffsetInWorldCoords(new Vector3(corner.X, corner.Y, corner.Z)); * * * }*/ //UI.Notify(e.HeightAboveGround.ToString()); var sp = HashFunctions.Convert3dTo2d(e.GetOffsetInWorldCoords(e.Position)); foreach (var corner in bbox.GetCorners()) { var c = new Vector3(corner.X, corner.Y, corner.Z); c = e.GetOffsetInWorldCoords(c); var s = HashFunctions.Convert3dTo2d(c); if (s.X == -1f || s.Y == -1f) { rv.Min.X = float.PositiveInfinity; rv.Max.X = float.NegativeInfinity; rv.Min.Y = float.PositiveInfinity; rv.Max.Y = float.NegativeInfinity; return(rv); } /* * if(s.X == -1) { * if (sp.X < 0.5) s.X = 0f; * if (sp.X >= 0.5) s.X = 1f; * } * if(s.Y == -1) { * if (sp.Y < 0.5) s.Y = 0f; * if (sp.Y >= 0.5) s.Y = 1f; * } */ rv.Min.X = Math.Min(rv.Min.X, s.X); rv.Min.Y = Math.Min(rv.Min.Y, s.Y); rv.Max.X = Math.Max(rv.Max.X, s.X); rv.Max.Y = Math.Max(rv.Max.Y, s.Y); } // int width = 1280; // int height = 960; // int x = (int)(rv.Min.X * width); // int y = (int)(rv.Min.Y * height); // int x2 = (int)(rv.Max.X * width); // int y2 = (int)(rv.Max.Y * height); // float w = rv.Max.X - rv.Min.X; // float h = rv.Max.Y - rv.Min.Y; // HashFunctions.DrawRect(rv.Min.X + w/2, rv.Min.Y + h/2, rv.Max.X - rv.Min.X, rv.Max.Y - rv.Min.Y, 255, 255, 255, 100); // new UIRectangle(new Point((int)(rv.Min.X * 1920), (int)(rv.Min.Y * 1080)), rv.) return(rv); }
/// <summary> /// Determines whether the current objects contains a <see cref="SharpDX.BoundingBox"/>. /// </summary> /// <param name="box">The box to test.</param> /// <returns>The type of containment the two objects have.</returns> public ContainmentType Contains(ref BoundingBox box) { return(Collision.SphereContainsBox(ref this, ref box)); }
public AxisAlignedBoundingBox(SharpDX.BoundingBox bb) { this.sbb = bb; }
public static GTABoundingBox2 ComputeBoundingBox(Entity e, Vector3 offset, float scale = 0.5f) { var m = e.Model; var rv = new GTABoundingBox2 { Min = new GTAVector2(float.PositiveInfinity, float.PositiveInfinity), Max = new GTAVector2(float.NegativeInfinity, float.NegativeInfinity) }; Vector3 gmin; Vector3 gmax; m.GetDimensions(out gmin, out gmax); var bbox = new SharpDX.BoundingBox((SharpDX.Vector3) new GTAVector(gmin), (SharpDX.Vector3) new GTAVector(gmax)); //Console.WriteLine(bbox.GetCorners()[0]); /* * for (int i = 0; i < bbox.GetCorners().Length; ++i) { * for (int j = 0; j < bbox.GetCorners().Length; ++j) { * if (j == i) continue; * var c1 = bbox.GetCorners()[i]; * var c2 = bbox.GetCorners()[j]; * HashFunctions.Draw3DLine(e.GetOffsetInWorldCoords(new Vector3(c1.X, c1.Y, c1.Z)), e.GetOffsetInWorldCoords(new Vector3(c2.X, c2.Y, c2.Z)), 0,0); * } * } */ /* * for (int i = 0; i < bbox.GetCorners().Length; ++i) * { * var corner = bbox.GetCorners()[i]; * var cornerinworld = e.GetOffsetInWorldCoords(new Vector3(corner.X, corner.Y, corner.Z)); * * * }*/ //UI.Notify(e.HeightAboveGround.ToString()); var sp = HashFunctions.Convert3dTo2d(e.GetOffsetInWorldCoords(e.Position)); foreach (var corner in bbox.GetCorners()) { var c = new Vector3(corner.X, corner.Y, corner.Z); c = e.GetOffsetInWorldCoords(c); var s = HashFunctions.Convert3dTo2d(c); if (s.X == -1f || s.Y == -1f) { rv.Min.X = float.PositiveInfinity; rv.Max.X = float.NegativeInfinity; rv.Min.Y = float.PositiveInfinity; rv.Max.Y = float.NegativeInfinity; return(rv); } /* * if(s.X == -1) { * if (sp.X < 0.5) s.X = 0f; * if (sp.X >= 0.5) s.X = 1f; * } * if(s.Y == -1) { * if (sp.Y < 0.5) s.Y = 0f; * if (sp.Y >= 0.5) s.Y = 1f; * } */ rv.Min.X = Math.Min(rv.Min.X, s.X); rv.Min.Y = Math.Min(rv.Min.Y, s.Y); rv.Max.X = Math.Max(rv.Max.X, s.X); rv.Max.Y = Math.Max(rv.Max.Y, s.Y); } float w = rv.Max.X - rv.Min.X; float h = rv.Max.Y - rv.Min.Y; // just for debug purposes, show visible and not visible entities in other color // if (CheckVisible(e)) // { // HashFunctions.DrawRect(rv.Min.X + w / 2, rv.Min.Y + h / 2, rv.Max.X - rv.Min.X, rv.Max.Y - rv.Min.Y, // Color.White, 100); // } // else // { // HashFunctions.DrawRect(rv.Min.X + w / 2, rv.Min.Y + h / 2, rv.Max.X - rv.Min.X, rv.Max.Y - rv.Min.Y, // Color.Red, 100); // } // HashFunctions.DrawRect(rv.Min.X + w/2, rv.Min.Y + h/2, rv.Max.X - rv.Min.X, rv.Max.Y - rv.Min.Y, 255, 255, 255, 100); return(rv); }
/// <summary> /// Determines if there is an intersection between the current object and a <see cref="SharpDX.BoundingBox"/>. /// </summary> /// <param name="box">The box to test.</param> /// <returns>Whether the two objects intersected.</returns> public bool Intersects(BoundingBox box) { return(Intersects(ref box)); }
/// <summary> /// Determines if there is an intersection between the current object and a <see cref="SharpDX.BoundingBox"/>. /// </summary> /// <param name="box">The box to test.</param> /// <param name="distance">When the method completes, contains the distance of the intersection, /// or 0 if there was no intersection.</param> /// <returns>Whether the two objects intersected.</returns> public bool Intersects(ref BoundingBox box, out float distance) { return(Collision.RayIntersectsBox(ref this, ref box, out distance)); }
/// <summary> /// Determines if there is an intersection between the current object and a <see cref="SharpDX.BoundingBox"/>. /// </summary> /// <param name="box">The box to test.</param> /// <param name="point">When the method completes, contains the point of intersection, /// or <see cref="SharpDX.Vector3.Zero"/> if there was no intersection.</param> /// <returns>Whether the two objects intersected.</returns> public bool Intersects(ref BoundingBox box, out Vector3 point) { return(Collision.RayIntersectsBox(ref this, ref box, out point)); }