protected override Box CreateRootNodeAABB(List <Vector3> points) { // Note: We will scale the root node size by a small factor in order to account for // floating point rounding errors. Otherwise, it is possible that the tree // build algorithm will ignore certain positions because they fall outside // of the root when in fact they are not. return(Box.FromPoints(points, 1.1f)); }
public void RenderGizmos(XZGrid grid, CameraViewVolume cameraViewVolume) { if (!grid.RenderSettings.IsVisible) { return; } // Note: Can not figure out how to render a finite grid inside a shader yet... :D if (grid.DimensionSettings.DimensionType == XZGridDimensionType.Finite) { RenderGizmos_Obsolete(grid, cameraViewVolume); return; } Plane gridPlane = grid.Plane; Vector3 gridPlaneCenter = gridPlane.ProjectPoint(SceneViewCamera.Camera.transform.position); Box camVolumeAABB = cameraViewVolume.WorldSpaceAABB; List <Vector3> projectedVolumeAABBPts = gridPlane.ProjectAllPoints(camVolumeAABB.GetCornerPoints()); List <Vector3> modelSpacePrjPts = Vector3Extensions.GetTransformedPoints(projectedVolumeAABBPts, grid.TransformMatrix.ToMatrix4x4x.inverse); Box modelSpacePtsBox = Box.FromPoints(modelSpacePrjPts); Vector3 gridPlaneSize = modelSpacePtsBox.Size; Matrix4x4 planeTransformMatrix = Matrix4x4.TRS(gridPlaneCenter, grid.Rotation, gridPlaneSize); Material xzGridMaterial = MaterialPool.Get().XZGridMaterial; xzGridMaterial.SetFloat("_CellSizeX", grid.CellSizeSettings.CellSizeX); xzGridMaterial.SetFloat("_CellSizeZ", grid.CellSizeSettings.CellSizeZ); xzGridMaterial.SetVector("_CellOffset", grid.GetOriginPosition()); xzGridMaterial.SetColor("_LineColor", grid.RenderSettings.CellLineColor); xzGridMaterial.SetColor("_PlaneColor", grid.RenderSettings.PlaneColor); xzGridMaterial.SetFloat("_CamFarPlaneDist", SceneViewCamera.Camera.farClipPlane); xzGridMaterial.SetVector("_CamWorldPos", SceneViewCamera.Camera.transform.position); xzGridMaterial.SetMatrix("_InvRotMatrix", Matrix4x4.TRS(Vector3.zero, grid.Rotation, Vector3.one).inverse); xzGridMaterial.SetMatrix("_PlaneTransformMtx", planeTransformMatrix); int numPasses = xzGridMaterial.passCount; for (int passIndex = 0; passIndex < numPasses; ++passIndex) { xzGridMaterial.SetPass(passIndex); Graphics.DrawMeshNow(GizmosEx.XZRectangleMesh, planeTransformMatrix); } GizmosMatrix.Push(grid.TransformMatrix.ToMatrix4x4x); grid.RenderableCoordinateSystem.RenderGizmos(); GizmosMatrix.Pop(); }
public static Object2ObjectBoxSnapData Create(GameObject meshObject) { if (meshObject == null) { return(null); } Mesh objectMesh = meshObject.GetMeshFromFilterOrSkinnedMeshRenderer(); if (objectMesh == null) { return(null); } Renderer renderer = meshObject.GetRenderer(); if (renderer == null || !renderer.enabled) { return(null); } Octave3DMesh octaveMesh = Octave3DMeshDatabase.Get().GetOctave3DMesh(objectMesh); if (octaveMesh == null) { return(null); } List <Box> modelVertOverlapBoxes = BuildModelVertOverlapBoxes(octaveMesh); var snapBoxIDs = Object2ObjectBoxSnapData.GetAllSnapBoxIDs(); var modelSnapBoxes = new List <Box>(snapBoxIDs.Length); Box modelMeshBox = octaveMesh.ModelAABB; BoxFace[] meshBoxFaces = Object2ObjectBoxSnapData.GetBoxFaceToSnapBoxIDMap(); foreach (var snapBox in snapBoxIDs) { Box overlapBox = modelVertOverlapBoxes[(int)snapBox]; List <Vector3> overlappedVerts = octaveMesh.GetOverlappedModelVerts(overlapBox); Plane meshFacePlane = modelMeshBox.GetBoxFacePlane(meshBoxFaces[(int)snapBox]); overlappedVerts = meshFacePlane.ProjectAllPoints(overlappedVerts); modelSnapBoxes.Add(Box.FromPoints(overlappedVerts)); } return(new Object2ObjectBoxSnapData(meshObject, modelSnapBoxes)); }
public List <Triangle3D> GetOverlappedWorldTriangles(OrientedBox box, TransformMatrix meshTransformMatrix) { // If the tree was not yet build, we need to build it because we need // the triangle information in order to perform the raycast. if (!_wasBuilt) { Build(); } // Work in mesh model space because the tree data exists in model space OrientedBox meshSpaceBox = new OrientedBox(box); Matrix4x4 inverseTransform = meshTransformMatrix.ToMatrix4x4x.inverse; meshSpaceBox.Transform(inverseTransform); List <SphereTreeNode <MeshSphereTreeTriangle> > overlappedNodes = _sphereTree.OverlapBox(meshSpaceBox); if (overlappedNodes.Count == 0) { return(new List <Triangle3D>()); } Box queryBox = Box.FromPoints(meshSpaceBox.GetCenterAndCornerPoints()); var overlappedWorldTriangles = new List <Triangle3D>(50); foreach (var node in overlappedNodes) { int triangleIndex = node.Data.TriangleIndex; MeshTriangleInfo triangleInfo = _octave3DMesh.GetMeshTriangleInfo(triangleIndex); if (triangleInfo.ModelSpaceTriangle.IntersectsBox(queryBox)) { triangleInfo.ModelSpaceTriangle.TransformPoints(meshTransformMatrix); overlappedWorldTriangles.Add(triangleInfo.ModelSpaceTriangle); } } return(overlappedWorldTriangles); }
/// <summary> /// Builds the camera view volume for the specified camera. Please see the comments for the /// class constructor in order to understand what the second parameter is about. /// </summary> public void BuildForCamera(Camera camera, float desiredCameraFarClipPlane) { // Store the old camera far clip plane distance. We need to do this because we will // temporarily modify the camera far clip plane to 'desiredCameraFarClipPlane' in order // to perform all the necessary calculations. float oldCameraFarClipPlane = camera.farClipPlane; AdjustCameraFarClipPlane(camera, desiredCameraFarClipPlane); // Calculate the view volume data CalculateWorldSpacePoints(camera); CalculateWorldSpacePlanes(camera); CalculateWorldSpaceVolumeEdgeRays(); // Restore the camera far clip plane to what it was before camera.farClipPlane = oldCameraFarClipPlane; // Store clip plane distances _farClipPlaneDistance = desiredCameraFarClipPlane; _nearClipPlaneDistance = camera.nearClipPlane; _worldSpaceAABB = Box.FromPoints(new List <Vector3>(_worldSpaceVolumePoints)); }
public Box GetEncapsulatingBox() { List <Vector3> centerAndCornerPoints = GetCenterAndCornerPoints(); return(Box.FromPoints(centerAndCornerPoints)); }