void setQuadToCameraCorners(Mesh mesh, Camera cam, Camera.MonoOrStereoscopicEye eye)
{
Vector3[] nearPlaneCorners = new Vector3[4]; // camera returns corners in view space
// NOTE: attaching the render plane at nearClipPlane distance leads to mis-alignment of bounding boxes and thus incorret stereo rendering.
// this is probably due to the non-skewed projection matrices used for rendering in MegaMol.
// until we can use the skewed VR-Projection-Matrices, use a small offset when setting the render plane.
cam.CalculateFrustumCorners(new Rect(0, 0, 1, 1), cam.nearClipPlane + 0.32f, eye, nearPlaneCorners);
mesh.vertices = nearPlaneCorners;
Vector2[] uvCoords = new Vector2[4] {
new Vector2(0.0f, 0.0f), new Vector2(0.0f, 1.0f), new Vector2(1.0f, 1.0f), new Vector2(1.0f, 0.0f)
};
mesh.uv = uvCoords;
int[] indices = new int[6] {
0, 1, 2, 0, 2, 3
};
mesh.SetIndices(indices, MeshTopology.Triangles, 0);
// fixes disappearing of mesh when looked at from certain angles
mesh.RecalculateNormals();
mesh.RecalculateBounds();
mesh.RecalculateTangents();
}
/// <summary>
/// Returns the camera's World space to Clip space matrix
/// </summary>
/// <param name="nearClipPlane">The near clip plane</param>
/// <param name="farClipPlane">The far clip plane</param>
/// <param name="matrixToFill">The allocated matrix object to write into</param>
public static void GetWorldToClipMatrix(this Camera cameraComponent, Camera.MonoOrStereoscopicEye eye, float nearClipPlane, float farClipPlane, ref Matrix4x4 matrixToFill)
{
float tmpNear = cameraComponent.nearClipPlane;
cameraComponent.nearClipPlane = nearClipPlane;
float tmpFar = cameraComponent.farClipPlane;
cameraComponent.farClipPlane = farClipPlane;
Matrix4x4 worldToCameraMatrix = cameraComponent.worldToCameraMatrix;
Matrix4x4 projectionMatrix = cameraComponent.GetProjectionMatrix(eye);
matrixToFill = projectionMatrix * worldToCameraMatrix; // worldToClipMatrix
if (cameraComponent.orthographic)
{
matrixToFill[2, 0] = -worldToCameraMatrix[2, 0];
matrixToFill[2, 1] = -worldToCameraMatrix[2, 1];
matrixToFill[2, 2] = -worldToCameraMatrix[2, 2];
matrixToFill[2, 3] = -worldToCameraMatrix[2, 3];
}
cameraComponent.nearClipPlane = tmpNear;
cameraComponent.farClipPlane = tmpFar;
}
private void SaveFrameData(Camera.MonoOrStereoscopicEye eye)
{
switch (eye)
{
case Camera.MonoOrStereoscopicEye.Right:
if (_previousFrameData.rightEyeTexture)
{
RenderTexture.ReleaseTemporary(_previousFrameData.rightEyeTexture);
}
_camera.ResetProjectionMatrix();
_previousFrameData.rightEyeProjectionMatrix = _camera.projectionMatrix;
_previousFrameData.rightEyeWorldToCameraMatrix = _camera.worldToCameraMatrix;
_previousFrameData.rightEyeTexture = _camera.targetTexture;
break;
case Camera.MonoOrStereoscopicEye.Left:
case Camera.MonoOrStereoscopicEye.Mono:
default:
if (_previousFrameData.leftEyeTexture)
{
RenderTexture.ReleaseTemporary(_previousFrameData.leftEyeTexture);
}
// Need to restore original projection matrix for rendering fake recursion
_camera.ResetProjectionMatrix();
_previousFrameData.leftEyeProjectionMatrix = _camera.projectionMatrix;
_previousFrameData.leftEyeWorldToCameraMatrix = _camera.worldToCameraMatrix;
_previousFrameData.leftEyeTexture = _camera.targetTexture;
break;
}
}
private static Matrix4x4 CalculateReflectionMatrix(Vector4 plane, Camera.MonoOrStereoscopicEye eye = Camera.MonoOrStereoscopicEye.Mono)
{
Matrix4x4 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;
//reflectionMat = Matrix4x4.Translate(new Vector3(float0, 0, 0))*reflectionMat ;
return(reflectionMat);
}
//void OnPreRender()
void OnRenderObject()
{
Camera.MonoOrStereoscopicEye currentEye = cam.stereoActiveEye;
Matrix4x4 camPose = cam.worldToCameraMatrix;
Debug.Log(currentEye);
switch (currentEye)
{
case Camera.MonoOrStereoscopicEye.Left:
case Camera.MonoOrStereoscopicEye.Mono:
ARMaterial.SetTexture(ARMaterialTexName, LeftCameraImage);
// cam.SetStereoProjectionMatrix(Camera.StereoscopicEye.Left, LeftEye.projectionMatrix);
Matrix4x4 viewLeft = new Matrix4x4();
viewLeft.SetTRS(LeftEye.transform.localPosition, LeftEye.transform.localRotation, Vector3.one);
// cam.SetStereoViewMatrix(Camera.StereoscopicEye.Left, viewLeft * camPose);
break;
case Camera.MonoOrStereoscopicEye.Right:
ARMaterial.SetTexture(ARMaterialTexName, RightCameraImage);
// cam.SetStereoProjectionMatrix(Camera.StereoscopicEye.Right, RightEye.projectionMatrix);
Matrix4x4 viewRight = new Matrix4x4();
viewRight.SetTRS(RightEye.transform.localPosition, RightEye.transform.localRotation, Vector3.one);
// cam.SetStereoViewMatrix(Camera.StereoscopicEye.Right, viewRight * camPose);
break;
}
}
// MONOBEHAVIOUR.
private void OnRenderObject()
{
// Check and make sure to only render particles once per camera/eye.
Camera.MonoOrStereoscopicEye activeEye = Camera.current.stereoActiveEye;
if (!sRenderedCameraDictionary.ContainsKey(Camera.current))
{
Dictionary <Camera.MonoOrStereoscopicEye, Camera.MonoOrStereoscopicEye> activeEyeDictionary = new Dictionary <Camera.MonoOrStereoscopicEye, Camera.MonoOrStereoscopicEye>();
sRenderedCameraDictionary[Camera.current] = activeEyeDictionary;
}
if (!sRenderedCameraDictionary[Camera.current].ContainsKey(activeEye))
{
// Add camera to dictionary so we only render system once per camera.
sRenderedCameraDictionary[Camera.current][activeEye] = activeEye;
// Merge particle buffers.
Merge();
// Sort particles.
Sort();
// Render this frame.
RenderSystem();
}
}
public RenderTexture GetRT(Camera.MonoOrStereoscopicEye eye)
{
#if USE_2RT
return((eye == Camera.MonoOrStereoscopicEye.Left) ? ColorDepthLRT[delayFrame] : ColorDepthRRT[delayFrame]);
#else
return(ColorDepthLRT[delayFrame]);
#endif
}
public static bool WorldToViewportPointV3Eye(Camera camera, Vector3 pt, Camera.MonoOrStereoscopicEye eye, out float ox, out float oy, out float oz)
{
var v3 = camera.WorldToViewportPoint(pt, eye);
ox = v3.x;
oy = v3.y;
oz = v3.z;
return(true);
}
static int ConvertToEquirect(IntPtr L)
{
LuaScriptMgr.CheckArgsCount(L, 3);
RenderTexture obj = (RenderTexture)LuaScriptMgr.GetUnityObjectSelf(L, 1, "RenderTexture");
RenderTexture arg0 = (RenderTexture)LuaScriptMgr.GetUnityObject(L, 2, typeof(RenderTexture));
Camera.MonoOrStereoscopicEye arg1 = (Camera.MonoOrStereoscopicEye)LuaScriptMgr.GetNetObject(L, 3, typeof(Camera.MonoOrStereoscopicEye));
obj.ConvertToEquirect(arg0, arg1);
return(0);
}
/// <summary>
/// Gets a point with the same screen point as the source point,
/// but at the specified distance from camera.
/// </summary>
public static Vector3 WorldPointOffsetByDepth(this Camera camera,
Vector3 source,
float distanceFromCamera,
Camera.MonoOrStereoscopicEye eye = Camera.MonoOrStereoscopicEye.Mono)
{
var screenPoint = camera.WorldToScreenPoint(source, eye);
return(camera.ScreenToWorldPoint(screenPoint.SetZ(distanceFromCamera),
eye));
}
/// <summary>
/// Gets the projection matrix of the camera
/// </summary>
/// <param name="eye">The stereoscopic eye</param>
/// <returns></returns>
public static Matrix4x4 GetProjectionMatrix(this Camera camera, Camera.MonoOrStereoscopicEye eye)
{
if (eye == Camera.MonoOrStereoscopicEye.Mono)
{
return(camera.projectionMatrix);
}
else
{
return(camera.GetStereoProjectionMatrix((Camera.StereoscopicEye)eye));
}
}
public static bool ViewportPointToRayV2Eye(Camera camera, Vector2 pt, Camera.MonoOrStereoscopicEye eye, out float ox, out float oy, out float oz, out float dx, out float dy, out float dz)
{
var ray = camera.ViewportPointToRay(pt, eye);
ox = ray.origin.x;
oy = ray.origin.y;
oz = ray.origin.z;
dx = ray.direction.x;
dy = ray.direction.y;
dz = ray.direction.z;
return(true);
}
Vector2 GetScreenPoint(Vector3 eyePos, Vector3 localDirection, Camera.MonoOrStereoscopicEye eye)
{
Vector3 pos = cameraTransform.TransformPoint(eyePos);
Vector3 direction = cameraTransform.TransformDirection(localDirection);
Vector2 point = camera.WorldToScreenPoint(pos + direction, eye);
point.x /= camera.pixelWidth;
point.y /= camera.pixelHeight;
return(point);
}
public void CalculateFrustumCorners(Rect viewport, float z, Camera.MonoOrStereoscopicEye eye, Vector3[] outCorners)
{
if (outCorners == null)
{
throw new ArgumentNullException("outCorners");
}
if (outCorners.Length < 4)
{
throw new ArgumentException("outCorners minimum size is 4", "outCorners");
}
this.CalculateFrustumCornersInternal(viewport, z, eye, outCorners);
}
static Matrix4x4 FrustumCornersMatrix(Camera cam, Camera.MonoOrStereoscopicEye eye)
{
var camtr = cam.transform;
cam.CalculateFrustumCorners(new Rect(0, 0, 1, 1), cam.farClipPlane, eye, frustumCorners);
Matrix4x4 frustumMatrix = Matrix4x4.identity;
frustumMatrix.SetRow(0, camtr.TransformVector(frustumCorners[0]));
frustumMatrix.SetRow(1, camtr.TransformVector(frustumCorners[3]));
frustumMatrix.SetRow(2, camtr.TransformVector(frustumCorners[1]));
frustumMatrix.SetRow(3, camtr.TransformVector(frustumCorners[2]));
return(frustumMatrix);
}
/// <summary>
/// Computes the corners of the plane parallel to the camera at given distance
/// </summary>
/// <param name="eye">The stereoscopic eye</param>
/// <param name="planeDistance">The reference distance</param>
/// <param name="planeCornersArray">The array to fill with the four corners of the intersecting plane</param>
public static void GetFrustumPlaneCorners(this Camera camera, Camera.MonoOrStereoscopicEye eye, float planeDistance, ref Vector4[] planeCornersArray)
{
camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), planeDistance, eye, _tmpRetrievedFrustumPlaneCornersArray);
for (int i = 0; i < 4; ++i)
{
_tmpRetrievedFrustumPlaneCornersArray[i] = camera.transform.localToWorldMatrix.MultiplyPoint(_tmpRetrievedFrustumPlaneCornersArray[i]);
}
Vector3 tmp = _tmpRetrievedFrustumPlaneCornersArray[0];
planeCornersArray[0] = new Vector4(_tmpRetrievedFrustumPlaneCornersArray[1].x, _tmpRetrievedFrustumPlaneCornersArray[1].y, _tmpRetrievedFrustumPlaneCornersArray[1].z, 1.0f);
planeCornersArray[1] = new Vector4(_tmpRetrievedFrustumPlaneCornersArray[2].x, _tmpRetrievedFrustumPlaneCornersArray[2].y, _tmpRetrievedFrustumPlaneCornersArray[2].z, 1.0f);
planeCornersArray[2] = new Vector4(_tmpRetrievedFrustumPlaneCornersArray[3].x, _tmpRetrievedFrustumPlaneCornersArray[3].y, _tmpRetrievedFrustumPlaneCornersArray[3].z, 1.0f);
planeCornersArray[3] = new Vector4(tmp.x, tmp.y, tmp.z, 1.0f);
}
/// <summary>
/// Returns the camera's World space to Clip space matrix
/// </summary>
/// <param name="nearClipPlane">The near clip plane</param>
/// <param name="farClipPlane">The far clip plane</param>
/// <returns>The camera's World space to Clip space matrix</returns>
public static Matrix4x4 GetWorldToClipMatrix(this Camera cameraComponent, Camera.MonoOrStereoscopicEye eye, float nearClipPlane, float farClipPlane)
{
float tmpNear = cameraComponent.nearClipPlane;
cameraComponent.nearClipPlane = nearClipPlane;
float tmpFar = cameraComponent.farClipPlane;
cameraComponent.farClipPlane = farClipPlane;
Matrix4x4 worldToCameraMatrix = cameraComponent.worldToCameraMatrix;
Matrix4x4 projectionMatrix = cameraComponent.GetProjectionMatrix(eye);
Matrix4x4 worldToClipMatrix = projectionMatrix * worldToCameraMatrix;
cameraComponent.nearClipPlane = tmpNear;
cameraComponent.farClipPlane = tmpFar;
return(worldToClipMatrix);
}
/// <summary>
/// Computes the corners of the plane parallel to the camera at given distance
/// </summary>
/// <param name="eye">The stereoscopic eye</param>
/// <param name="planeDistance">The reference distance</param>
/// <returns>the four corners of the intersecting plane</returns>
public static Vector4[] GetFrustumPlaneCorners(this Camera camera, Camera.MonoOrStereoscopicEye eye, float planeDistance)
{
Vector3[] tmpArray = new Vector3[4];
camera.CalculateFrustumCorners(/*camera.rect*/ new Rect(0, 0, 1, 1), planeDistance, eye, tmpArray);
for (int i = 0; i < 4; ++i)
{
tmpArray[i] = camera.transform.localToWorldMatrix.MultiplyPoint(tmpArray[i]);
}
Vector4[] planeCorners = new Vector4[4];
Vector3 tmp = tmpArray[0];
planeCorners[0] = new Vector4(tmpArray[1].x, tmpArray[1].y, tmpArray[1].z, 1.0f);
planeCorners[1] = new Vector4(tmpArray[2].x, tmpArray[2].y, tmpArray[2].z, 1.0f);
planeCorners[2] = new Vector4(tmpArray[3].x, tmpArray[3].y, tmpArray[3].z, 1.0f);
planeCorners[3] = new Vector4(tmp.x, tmp.y, tmp.z, 1.0f);
return(planeCorners);
}
/// <summary>
/// Computes the world space frustum's corners' position
/// </summary>
/// <param name="nearClipDistance">The desired near plane</param>
/// <param name="farClipDistance">The desired far plane</param>
/// <param name="floatsArrayToFill">The floats array to fill with the the positions</param>
public static void GetFrustumCorners(this Camera camera, Camera.MonoOrStereoscopicEye eye, float nearClipDistance, float farClipDistance, ref float[] floatsArrayToFill)
{
camera.GetFrustumPlaneCorners(eye, nearClipDistance, ref _tmpNearPlaneCornersArray);
for (int i = 0; i < 4; ++i)
{
floatsArrayToFill[i * 4] = _tmpNearPlaneCornersArray[i].x;
floatsArrayToFill[i * 4 + 1] = _tmpNearPlaneCornersArray[i].y;
floatsArrayToFill[i * 4 + 2] = _tmpNearPlaneCornersArray[i].z;
floatsArrayToFill[i * 4 + 3] = _tmpNearPlaneCornersArray[i].w;
}
camera.GetFrustumPlaneCorners(eye, farClipDistance, ref _tmpFarPlaneCornersArray);
for (int i = 0; i < 4; ++i)
{
floatsArrayToFill[16 + i * 4] = _tmpFarPlaneCornersArray[i].x;
floatsArrayToFill[16 + i * 4 + 1] = _tmpFarPlaneCornersArray[i].y;
floatsArrayToFill[16 + i * 4 + 2] = _tmpFarPlaneCornersArray[i].z;
floatsArrayToFill[16 + i * 4 + 3] = _tmpFarPlaneCornersArray[i].w;
}
}
private void OnRenderImage(RenderTexture source, RenderTexture destination)
{
Camera.MonoOrStereoscopicEye eyeSide = currentCamera.stereoActiveEye;
RenderWithARDepthMaterial.SetFloat("_CullingBaise", CullingBaise);
RenderWithARDepthMaterial.SetTexture("_MRDepthNormal", MRDepthNormal);
RenderWithARDepthMaterial.SetTexture("_SeeThroughColor", (eyeSide == Camera.MonoOrStereoscopicEye.Left) ? seeThroughL.GetRT() : seeThroughR.GetRT());
RenderWithARDepthMaterial.SetTexture("_VRDepthColor", VRCamera.GetRT(eyeSide));
//RenderWithMRDepthMaterial.SetTexture("_VRDepth", VRCamera.DepthRT);
RenderWithARDepthMaterial.SetFloat("_softCullLength", softCullLength);
// RenderWithMRDepthMaterial.SetFloat("_softCullFactor", softCullFactor);
RenderWithARDepthMaterial.SetFloat("_GlowAmount", glowAmount);
RenderWithARDepthMaterial.SetFloat("_CoefAmount", coefAmount);
RenderWithARDepthMaterial.SetTexture("_SoftCullingMap", softEdgeWeight.SoftEdgeWeightRT);
Graphics.Blit(source, destination, RenderWithARDepthMaterial);
}
public void StartFrame()
{
this.textureDimensionChanged = this.UpdateFrameDimensions();
Camera.MonoOrStereoscopicEye stereoActiveEye = this.myCam.get_stereoActiveEye();
if (stereoActiveEye != 2)
{
if (stereoActiveEye != null)
{
if (stereoActiveEye != 1)
{
return;
}
this.projection = this.myCam.GetStereoProjectionMatrix((Camera.StereoscopicEye) 1);
this.rotation = this.myCam.GetStereoViewMatrix((Camera.StereoscopicEye) 1);
this.inverseRotation = ((Matrix4x4) ref this.rotation).get_inverse();
}
else
{
this.projection = this.myCam.GetStereoProjectionMatrix((Camera.StereoscopicEye) 0);
this.rotation = this.myCam.GetStereoViewMatrix((Camera.StereoscopicEye) 0);
this.inverseRotation = ((Matrix4x4) ref this.rotation).get_inverse();
if (!EnviroSky.instance.singlePassVR)
{
return;
}
this.projectionSPVR = this.myCam.GetStereoProjectionMatrix((Camera.StereoscopicEye) 1);
this.rotationSPVR = this.myCam.GetStereoViewMatrix((Camera.StereoscopicEye) 1);
this.inverseRotationSPVR = ((Matrix4x4) ref this.rotationSPVR).get_inverse();
}
}
else
{
if (this.resetCameraProjection)
{
this.myCam.ResetProjectionMatrix();
}
this.projection = this.myCam.get_projectionMatrix();
this.rotation = this.myCam.get_worldToCameraMatrix();
this.inverseRotation = this.myCam.get_cameraToWorldMatrix();
}
}
private void CalculateFrustumAABB(out Vector3 min, out Vector3 max)
{
const Camera.MonoOrStereoscopicEye eye = Camera.MonoOrStereoscopicEye.Mono;
_camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _camera.nearClipPlane, eye, _frustumBuffer);
min = max = _cameraTransform.TransformPoint(_frustumBuffer[0]);
for (int i = 1; i < 4; ++i)
{
Vector3 testPoint = _cameraTransform.TransformPoint(_frustumBuffer[i]);
min = Vector3.Min(min, testPoint);
max = Vector3.Max(max, testPoint);
}
_camera.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _camera.farClipPlane, eye, _frustumBuffer);
for (int i = 0; i < 4; ++i)
{
Vector3 testPoint = _cameraTransform.TransformPoint(_frustumBuffer[i]);
min = Vector3.Min(min, testPoint);
max = Vector3.Max(max, testPoint);
}
}
private void OnPreRenderCamera(Camera currentCamera)
{
if (!enabled)
{
return;
}
UpdateCameraSettings(currentCamera);
Camera.MonoOrStereoscopicEye activeEye = currentCamera.stereoActiveEye;
if (activeEye == Camera.MonoOrStereoscopicEye.Left ||
activeEye == Camera.MonoOrStereoscopicEye.Mono)
{
RenderReflectionForEye(leftTextureId, currentCamera);
}
else if (activeEye == Camera.MonoOrStereoscopicEye.Right)
{
RenderReflectionForEye(rightTextureId, currentCamera);
}
}
public bool RenderToCubemap(RenderTexture cubemap, int faceMask, Camera.MonoOrStereoscopicEye stereoEye)
{
return(this.RenderToCubemapImpl(cubemap, faceMask, stereoEye));
}
extern public void ConvertToEquirect(RenderTexture equirect, Camera.MonoOrStereoscopicEye eye = Camera.MonoOrStereoscopicEye.Mono);
public RenderTexture RenderToTexture(Camera.MonoOrStereoscopicEye eye, Rect viewportRect, bool renderBackface)
{
_framesSinceLastUse = 0;
// Copy parent camera's settings
CopyCameraSettings(_parent, _camera);
//_camera.farClipPlane = _parent.farClipPlane * _portal.PortalScaleAverage();
Matrix4x4 projectionMatrix;
Matrix4x4 worldToCameraMatrix;
switch (eye)
{
case Camera.MonoOrStereoscopicEye.Left:
projectionMatrix = _parent.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
worldToCameraMatrix = _parent.GetStereoViewMatrix(Camera.StereoscopicEye.Left);
break;
case Camera.MonoOrStereoscopicEye.Right:
projectionMatrix = _parent.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
worldToCameraMatrix = _parent.GetStereoViewMatrix(Camera.StereoscopicEye.Right);
break;
case Camera.MonoOrStereoscopicEye.Mono:
default:
projectionMatrix = _parent.projectionMatrix;
worldToCameraMatrix = _parent.worldToCameraMatrix;
break;
}
_camera.transform.position = _portal.TeleportPoint(_parent.transform.position);
_camera.transform.rotation = _portal.TeleportRotation(_parent.transform.rotation);
_camera.projectionMatrix = projectionMatrix;
//_camera.worldToCameraMatrix = worldToCameraMatrix * _portal.PortalMatrix().inverse;
_camera.ResetWorldToCameraMatrix();
Matrix4x4 defaultProjection = _camera.projectionMatrix;
if (_portal.UseObliqueProjectionMatrix)
{
_camera.ResetProjectionMatrix();
_camera.projectionMatrix = CalculateObliqueProjectionMatrix(projectionMatrix);
}
else
{
_camera.ResetProjectionMatrix();
}
if (_portal.UseScissorRect)
{
_camera.rect = viewportRect;
_camera.projectionMatrix = MathUtil.ScissorsMatrix(_camera.projectionMatrix, viewportRect);
}
else
{
_camera.rect = new Rect(0, 0, 1, 1);
}
if (_portal.UseOcclusionMatrix)
{
_camera.cullingMatrix = CalculateCullingMatrix();
}
else
{
_camera.cullingMatrix = _camera.projectionMatrix * _camera.worldToCameraMatrix;
}
if (_portal.DebuggingEnabled)
{
//Util.DrawDebugFrustum3(_camera.projectionMatrix * _camera.worldToCameraMatrix, Color.white);
if (_portal.UseOcclusionMatrix)
{
Util.DrawDebugFrustum3(_camera.cullingMatrix, Color.blue);
}
}
if (_portal.UseRaycastOcclusion)
{
_camera.useOcclusionCulling = false;
}
RenderTexture texture = GetTemporaryRT();
if (_portal.FakeInfiniteRecursion)
{
// RenderTexture must be cleared when using fake infinite recursion because
// we might sometimes sample uninitialized garbage pixels otherwise, which can
// cause significant visual artifacts.
ClearRenderTexture(texture);
}
_camera.targetTexture = texture;
_camera.Render();
SaveFrameData(eye);
return(texture);
}
private void CalculateFrustumCornersInternal(Rect viewport, float z, Camera.MonoOrStereoscopicEye eye, [Out] Vector3[] outCorners)
{
this.CalculateFrustumCornersInternal_Injected(ref viewport, z, eye, outCorners);
}
private extern bool RenderToCubemapImpl(RenderTexture cubemap, int faceMask, Camera.MonoOrStereoscopicEye stereoEye);
private static extern void INTERNAL_CALL_CalculateFrustumCornersInternal(Camera self, ref Rect viewport, float z, Camera.MonoOrStereoscopicEye eye, Vector3[] outCorners);
private void CalculateFrustumCornersInternal(Rect viewport, float z, Camera.MonoOrStereoscopicEye eye, Vector3[] outCorners)
{
Camera.INTERNAL_CALL_CalculateFrustumCornersInternal(this, ref viewport, z, eye, outCorners);
}
