您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
268 行
11 KiB
268 行
11 KiB
using System;
|
|
|
|
namespace UnityEngine.Experimental.Rendering
|
|
{
|
|
public struct Frustum
|
|
{
|
|
public Plane[] planes; // Left, right, top, bottom, near, far
|
|
public Vector3[] corners; // Positions of the 8 corners
|
|
|
|
// The frustum will be camera-relative if given a camera-relative VP matrix.
|
|
public static Frustum Create(Matrix4x4 viewProjMatrix, bool depth_0_1, bool reverseZ)
|
|
{
|
|
Frustum frustum = new Frustum();
|
|
|
|
frustum.planes = new Plane[6];
|
|
frustum.corners = new Vector3[8];
|
|
|
|
GeometryUtility.CalculateFrustumPlanes(viewProjMatrix, frustum.planes);
|
|
|
|
float nd = -1.0f;
|
|
|
|
if (depth_0_1)
|
|
{
|
|
nd = 0.0f;
|
|
|
|
// See "Fast Extraction of Viewing Frustum Planes" by Gribb and Hartmann.
|
|
Vector3 f = new Vector3(viewProjMatrix.m20, viewProjMatrix.m21, viewProjMatrix.m22);
|
|
float s = (float)(1.0 / Math.Sqrt(f.sqrMagnitude));
|
|
Plane np = new Plane(s * f, s * viewProjMatrix.m23);
|
|
|
|
frustum.planes[4] = np;
|
|
}
|
|
|
|
if (reverseZ)
|
|
{
|
|
Plane tmp = frustum.planes[4];
|
|
frustum.planes[4] = frustum.planes[5];
|
|
frustum.planes[5] = tmp;
|
|
}
|
|
|
|
Matrix4x4 invViewProjMatrix = viewProjMatrix.inverse;
|
|
|
|
// Unproject 8 frustum points.
|
|
frustum.corners[0] = invViewProjMatrix.MultiplyPoint(new Vector3(-1, -1, 1));
|
|
frustum.corners[1] = invViewProjMatrix.MultiplyPoint(new Vector3(1, -1, 1));
|
|
frustum.corners[2] = invViewProjMatrix.MultiplyPoint(new Vector3(-1, 1, 1));
|
|
frustum.corners[3] = invViewProjMatrix.MultiplyPoint(new Vector3(1, 1, 1));
|
|
frustum.corners[4] = invViewProjMatrix.MultiplyPoint(new Vector3(-1, -1, nd));
|
|
frustum.corners[5] = invViewProjMatrix.MultiplyPoint(new Vector3(1, -1, nd));
|
|
frustum.corners[6] = invViewProjMatrix.MultiplyPoint(new Vector3(-1, 1, nd));
|
|
frustum.corners[7] = invViewProjMatrix.MultiplyPoint(new Vector3(1, 1, nd));
|
|
|
|
return frustum;
|
|
}
|
|
} // struct Frustum
|
|
|
|
[GenerateHLSL]
|
|
public struct OrientedBBox
|
|
{
|
|
// 3 x float4 = 48 bytes.
|
|
// TODO: pack the axes into 16-bit UNORM per channel, and consider a quaternionic representation.
|
|
public Vector3 right;
|
|
public float extentX;
|
|
public Vector3 up;
|
|
public float extentY;
|
|
public Vector3 center;
|
|
public float extentZ;
|
|
|
|
public Vector3 forward { get { return Vector3.Cross(up, right); } }
|
|
|
|
public static OrientedBBox Create(Transform t)
|
|
{
|
|
OrientedBBox obb = new OrientedBBox();
|
|
|
|
Vector3 vecX = t.localToWorldMatrix.GetColumn(0);
|
|
Vector3 vecY = t.localToWorldMatrix.GetColumn(1);
|
|
Vector3 vecZ = t.localToWorldMatrix.GetColumn(2);
|
|
|
|
obb.center = t.position;
|
|
obb.right = vecX * (1.0f / vecX.magnitude);
|
|
obb.up = vecY * (1.0f / vecY.magnitude);
|
|
|
|
obb.extentX = 0.5f * vecX.magnitude;
|
|
obb.extentY = 0.5f * vecY.magnitude;
|
|
obb.extentZ = 0.5f * vecZ.magnitude;
|
|
|
|
return obb;
|
|
}
|
|
} // struct OrientedBBox
|
|
|
|
public static class GeometryUtils
|
|
{
|
|
// Returns 'true' if the OBB intersects (or is inside) the frustum, 'false' otherwise.
|
|
public static bool Overlap(OrientedBBox obb, Frustum frustum, int numPlanes, int numCorners)
|
|
{
|
|
bool overlap = true;
|
|
|
|
// Test the OBB against frustum planes. Frustum planes are inward-facing.
|
|
// The OBB is outside if it's entirely behind one of the frustum planes.
|
|
// See "Real-Time Rendering", 3rd Edition, 16.10.2.
|
|
for (int i = 0; overlap && i < numPlanes; i++)
|
|
{
|
|
Vector3 n = frustum.planes[i].normal;
|
|
float d = frustum.planes[i].distance;
|
|
|
|
// Max projection of the half-diagonal onto the normal (always positive).
|
|
float maxHalfDiagProj = obb.extentX * Mathf.Abs(Vector3.Dot(n, obb.right))
|
|
+ obb.extentY * Mathf.Abs(Vector3.Dot(n, obb.up))
|
|
+ obb.extentZ * Mathf.Abs(Vector3.Dot(n, obb.forward));
|
|
|
|
// Positive distance -> center in front of the plane.
|
|
// Negative distance -> center behind the plane (outside).
|
|
float centerToPlaneDist = Vector3.Dot(n, obb.center) + d;
|
|
|
|
// outside = maxHalfDiagProj < -centerToPlaneDist
|
|
// outside = maxHalfDiagProj + centerToPlaneDist < 0
|
|
// overlap = overlap && !outside
|
|
overlap = overlap && (maxHalfDiagProj + centerToPlaneDist >= 0);
|
|
}
|
|
|
|
if (numCorners == 0) return overlap;
|
|
|
|
// Test the frustum corners against OBB planes. The OBB planes are outward-facing.
|
|
// The frustum is outside if all of its corners are entirely in front of one of the OBB planes.
|
|
// See "Correct Frustum Culling" by Inigo Quilez.
|
|
// We can exploit the symmetry of the box by only testing against 3 planes rather than 6.
|
|
Plane[] planes = new Plane[3];
|
|
|
|
planes[0].normal = obb.right;
|
|
planes[0].distance = obb.extentX;
|
|
planes[1].normal = obb.up;
|
|
planes[1].distance = obb.extentY;
|
|
planes[2].normal = obb.forward;
|
|
planes[2].distance = obb.extentZ;
|
|
|
|
for (int i = 0; overlap && i < 3; i++)
|
|
{
|
|
Plane plane = planes[i];
|
|
|
|
// We need a separate counter for the "box fully inside frustum" case.
|
|
bool outsidePos = true; // Positive normal
|
|
bool outsideNeg = true; // Reversed normal
|
|
|
|
// Merge 2 loops. Continue as long as all points are outside either plane.
|
|
for (int j = 0; j < numCorners; j++)
|
|
{
|
|
float proj = Vector3.Dot(plane.normal, frustum.corners[j] - obb.center);
|
|
outsidePos = outsidePos && (proj > plane.distance);
|
|
outsideNeg = outsideNeg && (-proj > plane.distance);
|
|
}
|
|
|
|
overlap = overlap && !(outsidePos || outsideNeg);
|
|
}
|
|
|
|
return overlap;
|
|
}
|
|
|
|
public static readonly Matrix4x4 FlipMatrixLHSRHS = Matrix4x4.Scale(new Vector3(1, 1, -1));
|
|
|
|
public static Vector4 Plane(Vector3 position, Vector3 normal)
|
|
{
|
|
var n = normal;
|
|
var d = -Vector3.Dot(n, position);
|
|
var plane = new Vector4(n.x, n.y, n.z, d);
|
|
return plane;
|
|
}
|
|
|
|
public static Vector4 CameraSpacePlane(Matrix4x4 worldToCamera, Vector3 pos, Vector3 normal, float sideSign = 1, float clipPlaneOffset = 0)
|
|
{
|
|
var offsetPos = pos + normal * clipPlaneOffset;
|
|
var cpos = worldToCamera.MultiplyPoint(offsetPos);
|
|
var cnormal = worldToCamera.MultiplyVector(normal).normalized * sideSign;
|
|
return new Vector4(cnormal.x, cnormal.y, cnormal.z, -Vector3.Dot(cpos, cnormal));
|
|
}
|
|
|
|
public static Matrix4x4 CalculateWorldToCameraMatrixRHS(Vector3 position, Quaternion rotation)
|
|
{
|
|
return Matrix4x4.Scale(new Vector3(1, 1, -1)) * Matrix4x4.TRS(position, rotation, Vector3.one).inverse;
|
|
}
|
|
|
|
public static Matrix4x4 CalculateWorldToCameraMatrixRHS(Transform transform)
|
|
{
|
|
return Matrix4x4.Scale(new Vector3(1, 1, -1)) * transform.localToWorldMatrix.inverse;
|
|
}
|
|
|
|
public static Matrix4x4 CalculateObliqueMatrix(Matrix4x4 sourceProjection, Vector4 clipPlane)
|
|
{
|
|
var projection = sourceProjection;
|
|
var inversion = sourceProjection.inverse;
|
|
|
|
var cps = new Vector4(
|
|
Mathf.Sign(clipPlane.x),
|
|
Mathf.Sign(clipPlane.y),
|
|
1.0f,
|
|
1.0f);
|
|
var q = inversion * cps;
|
|
Vector4 M4 = new Vector4(projection[3], projection[7], projection[11], projection[15]);
|
|
|
|
var c = clipPlane * ((2.0f*Vector4.Dot(M4, q)) / Vector4.Dot(clipPlane, q));
|
|
|
|
projection[2] = c.x - M4.x;
|
|
projection[6] = c.y - M4.y;
|
|
projection[10] = c.z - M4.z;
|
|
projection[14] = c.w - M4.w;
|
|
|
|
return projection;
|
|
}
|
|
|
|
public static Matrix4x4 CalculateReflectionMatrix(Vector3 position, Vector3 normal)
|
|
{
|
|
return CalculateReflectionMatrix(Plane(position, normal.normalized));
|
|
}
|
|
|
|
public static Matrix4x4 CalculateReflectionMatrix(Vector4 plane)
|
|
{
|
|
var reflectionMat = new Matrix4x4();
|
|
|
|
reflectionMat.m00 = (1F - 2F * plane[0] * plane[0]);
|
|
reflectionMat.m01 = (-2F * plane[0] * plane[1]);
|
|
reflectionMat.m02 = (-2F * plane[0] * plane[2]);
|
|
reflectionMat.m03 = (-2F * plane[3] * plane[0]);
|
|
|
|
reflectionMat.m10 = (-2F * plane[1] * plane[0]);
|
|
reflectionMat.m11 = (1F - 2F * plane[1] * plane[1]);
|
|
reflectionMat.m12 = (-2F * plane[1] * plane[2]);
|
|
reflectionMat.m13 = (-2F * plane[3] * plane[1]);
|
|
|
|
reflectionMat.m20 = (-2F * plane[2] * plane[0]);
|
|
reflectionMat.m21 = (-2F * plane[2] * plane[1]);
|
|
reflectionMat.m22 = (1F - 2F * plane[2] * plane[2]);
|
|
reflectionMat.m23 = (-2F * plane[3] * plane[2]);
|
|
|
|
reflectionMat.m30 = 0F;
|
|
reflectionMat.m31 = 0F;
|
|
reflectionMat.m32 = 0F;
|
|
reflectionMat.m33 = 1F;
|
|
|
|
return reflectionMat;
|
|
}
|
|
|
|
public static Matrix4x4 GetWorldToCameraMatrixLHS(this Camera camera)
|
|
{
|
|
return FlipMatrixLHSRHS * camera.worldToCameraMatrix;
|
|
}
|
|
|
|
public static Matrix4x4 GetProjectionMatrixLHS(this Camera camera)
|
|
{
|
|
return camera.projectionMatrix * FlipMatrixLHSRHS;
|
|
}
|
|
|
|
public static bool IsProjectionMatrixOblique(Matrix4x4 projectionMatrix)
|
|
{
|
|
return projectionMatrix[2] != 0 || projectionMatrix[6] != 0;
|
|
}
|
|
|
|
public static Matrix4x4 CalculateProjectionMatrix(Camera camera)
|
|
{
|
|
if (camera.orthographic)
|
|
{
|
|
var h = camera.orthographicSize;
|
|
var w = camera.orthographicSize * camera.aspect;
|
|
return Matrix4x4.Ortho(-w, w, -h, h, camera.nearClipPlane, camera.farClipPlane);
|
|
}
|
|
else
|
|
return Matrix4x4.Perspective(camera.fieldOfView, camera.aspect, camera.nearClipPlane, camera.farClipPlane);
|
|
}
|
|
} // class GeometryUtils
|
|
}
|