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));
}
