public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
{
objectCoordinate = new Vector3G();
Matrix4x4G matrix4x4G;
Matrix4x4G matrix4x4G1;
Vector4G vector4G = new Vector4G();
Vector4G vector4G1;
Matrix4x4G.Mult(ref this.projection, ref this.modelview, out matrix4x4G);
if (!Matrix4x4G.Inverse(ref matrix4x4G, out matrix4x4G1))
{
objectCoordinate = new Vector3G();
return(false);
}
vector4G.x = (win.x - this.offset.x) / this.size.x * 2 - 1;
vector4G.y = (win.y - this.offset.y) / this.size.y * 2 - 1;
vector4G.z = -win.z;
vector4G.w = 1;
Matrix4x4G.Mult(ref vector4G, ref matrix4x4G1, out vector4G1);
if (vector4G1.w == 0)
{
objectCoordinate = new Vector3G();
return(false);
}
vector4G1.w = 1 / vector4G1.w;
objectCoordinate.x = vector4G1.x * vector4G1.w;
objectCoordinate.y = vector4G1.y * vector4G1.w;
objectCoordinate.z = vector4G1.z * vector4G1.w;
return(true);
}
// Token: 0x06003B75 RID: 15221 RVA: 0x000D42E4 File Offset: 0x000D24E4
public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
{
Matrix4x4G matrix4x4G;
Matrix4x4G.Mult(ref this.projection, ref this.modelview, ref matrix4x4G);
Matrix4x4G matrix4x4G2;
if (!Matrix4x4G.Inverse(ref matrix4x4G, ref matrix4x4G2))
{
objectCoordinate = default(Vector3G);
return(false);
}
Vector4G vector4G;
vector4G.x = (win.x - this.offset.x) / this.size.x * 2.0 - 1.0;
vector4G.y = (win.y - this.offset.y) / this.size.y * 2.0 - 1.0;
vector4G.z = -win.z;
vector4G.w = 1.0;
Vector4G vector4G2;
Matrix4x4G.Mult(ref vector4G, ref matrix4x4G2, ref vector4G2);
if (vector4G2.w == 0.0)
{
objectCoordinate = default(Vector3G);
return(false);
}
vector4G2.w = 1.0 / vector4G2.w;
objectCoordinate.x = vector4G2.x * vector4G2.w;
objectCoordinate.y = vector4G2.y * vector4G2.w;
objectCoordinate.z = vector4G2.z * vector4G2.w;
return(true);
}
public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
{
Matrix4x4G matrixxg;
Matrix4x4G matrixxg2;
Vector4G vectorg;
Vector4G vectorg2;
Matrix4x4G.Mult(ref this.projection, ref this.modelview, out matrixxg);
if (!Matrix4x4G.Inverse(ref matrixxg, out matrixxg2))
{
objectCoordinate = new Vector3G();
return(false);
}
vectorg.x = (((win.x - this.offset.x) / this.size.x) * 2.0) - 1.0;
vectorg.y = (((win.y - this.offset.y) / this.size.y) * 2.0) - 1.0;
vectorg.z = -win.z;
vectorg.w = 1.0;
Matrix4x4G.Mult(ref vectorg, ref matrixxg2, out vectorg2);
if (vectorg2.w == 0.0)
{
objectCoordinate = new Vector3G();
return(false);
}
vectorg2.w = 1.0 / vectorg2.w;
objectCoordinate.x = vectorg2.x * vectorg2.w;
objectCoordinate.y = vectorg2.y * vectorg2.w;
objectCoordinate.z = vectorg2.z * vectorg2.w;
return(true);
}
internal static void ApplyTransitionAlterations(Camera camera, CameraFX fx, bool useFX)
{
Matrix4x4G matrix4x4G;
Matrix4x4G matrix4x4G1;
if (!useFX)
{
camera.ExtractCameraMatrixWorldToCamera(out matrix4x4G);
camera.ExtractCameraMatrixProjection(out matrix4x4G1);
int num = CameraFX.g_trans.Update(ref matrix4x4G, ref matrix4x4G1);
if ((num & 1) == 1)
{
camera.ResetWorldToCameraMatrix();
camera.worldToCameraMatrix = matrix4x4G.f;
}
if ((num & 2) == 2)
{
camera.ResetProjectionMatrix();
camera.projectionMatrix = matrix4x4G1.f;
}
}
else
{
int num1 = CameraFX.g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
if ((num1 & 1) == 1)
{
camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, out fx.cameraToWorldMatrix);
}
if ((num1 & 2) == 2)
{
camera.projectionMatrix = fx.projectionMatrix.f;
}
}
}
public static Matrix4x4G Inverse(Matrix4x4G v)
{
Matrix4x4G matrixxg;
Matrix4x4G.Inverse(ref v, out matrixxg);
return(matrixxg);
}
internal static void ApplyTransitionAlterations(Camera camera, CameraFX fx, bool useFX)
{
if (useFX)
{
int num = g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
if ((num & 1) == 1)
{
camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, out fx.cameraToWorldMatrix);
}
if ((num & 2) == 2)
{
camera.projectionMatrix = fx.projectionMatrix.f;
}
}
else
{
Matrix4x4G matrixxg;
Matrix4x4G matrixxg2;
camera.ExtractCameraMatrixWorldToCamera(out matrixxg);
camera.ExtractCameraMatrixProjection(out matrixxg2);
int num2 = g_trans.Update(ref matrixxg, ref matrixxg2);
if ((num2 & 1) == 1)
{
camera.ResetWorldToCameraMatrix();
camera.worldToCameraMatrix = matrixxg.f;
}
if ((num2 & 2) == 2)
{
camera.ResetProjectionMatrix();
camera.projectionMatrix = matrixxg2.f;
}
}
}
// Token: 0x06002BC8 RID: 11208 RVA: 0x000A375C File Offset: 0x000A195C
internal static void ApplyTransitionAlterations(Camera camera, global::CameraFX fx, bool useFX)
{
if (useFX)
{
int num = global::CameraFX.g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
if ((num & 1) == 1)
{
camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, ref fx.cameraToWorldMatrix);
}
if ((num & 2) == 2)
{
camera.projectionMatrix = fx.projectionMatrix.f;
}
}
else
{
Matrix4x4G matrix4x4G;
Precise.ExtractCameraMatrixWorldToCamera(camera, ref matrix4x4G);
Matrix4x4G matrix4x4G2;
Precise.ExtractCameraMatrixProjection(camera, ref matrix4x4G2);
int num2 = global::CameraFX.g_trans.Update(ref matrix4x4G, ref matrix4x4G2);
if ((num2 & 1) == 1)
{
camera.ResetWorldToCameraMatrix();
camera.worldToCameraMatrix = matrix4x4G.f;
}
if ((num2 & 2) == 2)
{
camera.ResetProjectionMatrix();
camera.projectionMatrix = matrix4x4G2.f;
}
}
}
public void PostPreCull()
{
Vector3G vector3G;
Matrix4x4G matrix4x4G;
Matrix4x4G matrix4x4G1;
Vector3G vector3G1 = new Vector3G();
Vector3G vector3G2;
Vector3G vector3G3;
Vector3G vector3G4;
Vector3G vector3G5;
Vector3G vector3G6 = new Vector3G();
RaycastHit raycastHit;
Matrix4x4G matrix4x4G2;
PerspectiveMatrixBuilder perspectiveMatrixBuilder = new PerspectiveMatrixBuilder();
Vector4 vector4 = new Vector4();
PerspectiveMatrixBuilder perspectiveMatrixBuilder1 = new PerspectiveMatrixBuilder();
Matrix4x4G matrix4x4G3;
Vector3G vector3G7;
QuaternionG quaternionG;
Vector3G vector3G8;
Matrix4x4G matrix4x4G4;
Matrix4x4G matrix4x4G5;
Matrix4x4G matrix4x4G6;
Matrix4x4G matrix4x4G7;
Matrix4x4G matrix4x4G8;
Matrix4x4G matrix4x4G9;
Matrix4x4G matrix4x4G10;
Matrix4x4G matrix4x4G11;
if (CameraFX.viewModelRootTransform)
{
Quaternion quaternion = base.transform.localRotation;
Vector3 vector3 = base.transform.localPosition;
if (this.viewModel)
{
this.viewModel.ModifyAiming(new Ray(base.transform.parent.position, base.transform.parent.forward), ref vector3, ref quaternion);
}
CameraFX.viewModelRootTransform.localRotation = Quaternion.Inverse(quaternion);
CameraFX.viewModelRootTransform.localPosition = -vector3;
}
this.camera.transform.ExtractLocalToWorldToLocal(out this.localToWorldMatrix, out this.worldToLocalMatrix);
if (this.adaptiveNearPlane)
{
int num = this.camera.cullingMask & ~this.adaptiveNearPlane.ignoreLayers.@value | this.adaptiveNearPlane.forceLayers.@value;
Vector3G vector3G9 = new Vector3G();
this.localToWorldMatrix.MultiplyPoint(ref vector3G9, out vector3G);
Collider[] colliderArray = Physics.OverlapSphere(vector3G.f, this.adaptiveNearPlane.minNear + this.adaptiveNearPlane.maxNear, num);
int num1 = -1;
float single = Single.PositiveInfinity;
double num2 = (double)this.camera.fieldOfView;
double num3 = (double)this.camera.aspect;
double num4 = (double)this.adaptiveNearPlane.minNear;
double num5 = (double)(this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold);
float single1 = this.adaptiveNearPlane.minNear;
float single2 = this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold - single1;
Matrix4x4G.Perspective(ref num2, ref num3, ref num4, ref num5, out matrix4x4G);
Matrix4x4G.Inverse(ref matrix4x4G, out matrix4x4G1);
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
vector3G1.x = ((double)i - 3.5) / 3.5;
vector3G1.y = ((double)j - 3.5) / 3.5;
vector3G1.z = 0;
matrix4x4G1.MultiplyPoint(ref vector3G1, out vector3G2);
vector3G1.z = 1;
matrix4x4G1.MultiplyPoint(ref vector3G1, out vector3G3);
vector3G2.x = -vector3G2.x;
vector3G2.y = -vector3G2.y;
vector3G2.z = -vector3G2.z;
vector3G3.x = -vector3G3.x;
vector3G3.y = -vector3G3.y;
vector3G3.z = -vector3G3.z;
this.localToWorldMatrix.MultiplyPoint(ref vector3G2, out vector3G4);
this.localToWorldMatrix.MultiplyPoint(ref vector3G3, out vector3G5);
vector3G6.x = vector3G5.x - vector3G4.x;
vector3G6.y = vector3G5.y - vector3G4.y;
vector3G6.z = vector3G5.z - vector3G4.z;
float single3 = (float)Math.Sqrt(vector3G6.x * vector3G6.x + vector3G6.y * vector3G6.y + vector3G6.z * vector3G6.z);
float single4 = single3;
Ray ray = new Ray(vector3G4.f, vector3G6.f);
for (int k = 0; k < (int)colliderArray.Length; k++)
{
if (colliderArray[k].Raycast(ray, out raycastHit, single4))
{
float single5 = raycastHit.distance;
if (single5 < single4)
{
single4 = single5;
float single6 = single1 + single5 / single3 * single2;
if (single > single6)
{
single = single6;
num1 = k;
}
}
}
}
}
}
if (!float.IsInfinity(single))
{
single = single - this.adaptiveNearPlane.threshold;
if (single >= this.adaptiveNearPlane.maxNear)
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
else if (single > this.adaptiveNearPlane.minNear)
{
this.camera.nearClipPlane = single;
}
else
{
this.camera.nearClipPlane = this.adaptiveNearPlane.minNear;
}
}
else
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
}
perspectiveMatrixBuilder.fieldOfView = (double)this.camera.fieldOfView;
perspectiveMatrixBuilder.aspectRatio = (double)this.camera.aspect;
perspectiveMatrixBuilder.nearPlane = (double)this.camera.nearClipPlane;
perspectiveMatrixBuilder.farPlane = (double)this.camera.farClipPlane;
PerspectiveMatrixBuilder perspectiveMatrixBuilder2 = perspectiveMatrixBuilder;
if (!this.camera.isOrthoGraphic)
{
if (this.viewModel)
{
this.viewModel.ModifyPerspective(ref perspectiveMatrixBuilder2);
}
if (!CameraFX.vm_projuse)
{
perspectiveMatrixBuilder.ToProjectionMatrix(out this.projectionMatrix);
}
else
{
perspectiveMatrixBuilder2.ToProjectionMatrix(out this.projectionMatrix);
}
this.camera.projectionMatrix = this.projectionMatrix.f;
perspectiveMatrixBuilder2.ToProjectionMatrix(out matrix4x4G2);
}
else
{
this.projectionMatrix.f = this.camera.projectionMatrix;
matrix4x4G2 = this.projectionMatrix;
}
vector4.y = (float)perspectiveMatrixBuilder2.nearPlane;
vector4.z = (float)perspectiveMatrixBuilder2.farPlane;
vector4.w = (float)(1 / perspectiveMatrixBuilder2.farPlane);
if (CameraFX.vm_flip != CameraFX.PLATFORM_POLL.flipRequired)
{
vector4.x = -1f;
perspectiveMatrixBuilder1.nearPlane = perspectiveMatrixBuilder2.nearPlane;
perspectiveMatrixBuilder1.farPlane = perspectiveMatrixBuilder2.farPlane;
perspectiveMatrixBuilder1.fieldOfView = -perspectiveMatrixBuilder2.fieldOfView;
perspectiveMatrixBuilder1.aspectRatio = -perspectiveMatrixBuilder2.aspectRatio;
perspectiveMatrixBuilder1.ToProjectionMatrix(out matrix4x4G3);
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G3.f);
}
else
{
vector4.x = 1f;
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G2.f);
}
Shader.SetGlobalVector("V_M_ProjectionParams", vector4);
if (!this.recalcViewMatrix)
{
this.cameraToWorldMatrix.f = this.camera.cameraToWorldMatrix;
this.worldToCameraMatrix.f = this.camera.worldToCameraMatrix;
}
else
{
this.camera.transform.ExtractWorldCoordinates(out vector3G7, out quaternionG, out vector3G8);
vector3G8.x = 1;
vector3G8.y = 1;
vector3G8.z = -1;
Matrix4x4G.TRS(ref vector3G7, ref quaternionG, ref vector3G8, out this.cameraToWorldMatrix);
if (Matrix4x4G.Inverse(ref this.cameraToWorldMatrix, out this.worldToCameraMatrix))
{
this.camera.worldToCameraMatrix = this.worldToCameraMatrix.f;
}
}
this.worldToCameraMatrixUnAltered = this.worldToCameraMatrix;
this.cameraToWorldMatrixUnAltered = this.cameraToWorldMatrix;
this.projectionMatrixUnAltered = this.projectionMatrix;
CameraFX.ApplyTransitionAlterations(this.camera, this, true);
Matrix4x4G matrix4x4G12 = this.worldToCameraMatrix;
Matrix4x4G matrix4x4G13 = matrix4x4G12;
this.projectViewport.modelview = matrix4x4G12;
this.projectScreen.modelview = matrix4x4G13;
Matrix4x4G matrix4x4G14 = this.projectionMatrix;
matrix4x4G13 = matrix4x4G14;
this.projectViewport.projection = matrix4x4G14;
this.projectScreen.projection = matrix4x4G13;
Rect rect = this.camera.pixelRect;
this.projectScreen.offset.x = (double)rect.x;
this.projectScreen.offset.y = (double)rect.y;
this.projectScreen.size.x = (double)rect.width;
this.projectScreen.size.y = (double)rect.height;
rect = this.camera.rect;
this.projectViewport.offset.x = (double)rect.x;
this.projectViewport.offset.y = (double)rect.y;
this.projectViewport.size.x = (double)rect.width;
this.projectViewport.size.y = (double)rect.height;
Matrix4x4G.Mult(ref this.localToWorldMatrix, ref this.worldToCameraMatrix, out matrix4x4G7);
Matrix4x4G.Mult(ref matrix4x4G7, ref this.projectionMatrix, out matrix4x4G4);
Matrix4x4G.Inverse(ref matrix4x4G7, out matrix4x4G8);
Matrix4x4G.Inverse(ref matrix4x4G4, out matrix4x4G5);
Matrix4x4G.Inverse(ref this.localToWorldMatrix, out matrix4x4G10);
Matrix4x4G.Transpose(ref matrix4x4G5, out matrix4x4G6);
Matrix4x4G.Transpose(ref matrix4x4G8, out matrix4x4G9);
Matrix4x4G.Transpose(ref matrix4x4G10, out matrix4x4G11);
if (this.viewModel)
{
this.viewModel.UpdateProxies();
}
BoundHack.Achieve(base.transform.position);
ContextSprite.UpdateSpriteFading(this.camera);
PlayerClient playerClient = PlayerClient.localPlayerClient;
if (playerClient)
{
playerClient.ProcessLocalPlayerPreRender();
}
RPOS.BeforeSceneRender_Internal(this.camera);
}
public void PostPreCull()
{
Matrix4x4G projectionMatrix;
PerspectiveMatrixBuilder builder;
Vector4 vector2;
Matrix4x4G matrixxg5;
Matrix4x4G matrixxg6;
Matrix4x4G matrixxg7;
Matrix4x4G matrixxg8;
Matrix4x4G matrixxg9;
Matrix4x4G matrixxg10;
Matrix4x4G matrixxg11;
Matrix4x4G matrixxg12;
if (viewModelRootTransform != null)
{
Quaternion localRotation = base.transform.localRotation;
Vector3 localPosition = base.transform.localPosition;
if (this.viewModel != null)
{
this.viewModel.ModifyAiming(new Ray(base.transform.parent.position, base.transform.parent.forward), ref localPosition, ref localRotation);
}
viewModelRootTransform.localRotation = Quaternion.Inverse(localRotation);
viewModelRootTransform.localPosition = -localPosition;
}
this.camera.transform.ExtractLocalToWorldToLocal(out this.localToWorldMatrix, out this.worldToLocalMatrix);
if (this.adaptiveNearPlane != null)
{
Vector3G vectorg2;
Matrix4x4G matrixxg;
Matrix4x4G matrixxg2;
int layerMask = (this.camera.cullingMask & ~this.adaptiveNearPlane.ignoreLayers.value) | this.adaptiveNearPlane.forceLayers.value;
Vector3G a = new Vector3G();
this.localToWorldMatrix.MultiplyPoint(ref a, out vectorg2);
Collider[] colliderArray = Physics.OverlapSphere(vectorg2.f, this.adaptiveNearPlane.minNear + this.adaptiveNearPlane.maxNear, layerMask);
int num2 = -1;
float positiveInfinity = float.PositiveInfinity;
double fieldOfView = this.camera.fieldOfView;
double aspect = this.camera.aspect;
double minNear = this.adaptiveNearPlane.minNear;
double zfar = this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold;
float num8 = this.adaptiveNearPlane.minNear;
float num9 = (this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold) - num8;
Matrix4x4G.Perspective(ref fieldOfView, ref aspect, ref minNear, ref zfar, out matrixxg);
Matrix4x4G.Inverse(ref matrixxg, out matrixxg2);
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
Vector3G vectorg3;
Vector3G vectorg4;
Vector3G vectorg5;
Vector3G vectorg6;
Vector3G vectorg7;
Vector3G vectorg8;
vectorg3.x = (i - 3.5) / 3.5;
vectorg3.y = (j - 3.5) / 3.5;
vectorg3.z = 0.0;
matrixxg2.MultiplyPoint(ref vectorg3, out vectorg4);
vectorg3.z = 1.0;
matrixxg2.MultiplyPoint(ref vectorg3, out vectorg5);
vectorg4.x = -vectorg4.x;
vectorg4.y = -vectorg4.y;
vectorg4.z = -vectorg4.z;
vectorg5.x = -vectorg5.x;
vectorg5.y = -vectorg5.y;
vectorg5.z = -vectorg5.z;
this.localToWorldMatrix.MultiplyPoint(ref vectorg4, out vectorg6);
this.localToWorldMatrix.MultiplyPoint(ref vectorg5, out vectorg7);
vectorg8.x = vectorg7.x - vectorg6.x;
vectorg8.y = vectorg7.y - vectorg6.y;
vectorg8.z = vectorg7.z - vectorg6.z;
float num12 = (float)Math.Sqrt(((vectorg8.x * vectorg8.x) + (vectorg8.y * vectorg8.y)) + (vectorg8.z * vectorg8.z));
float distance = num12;
Ray ray = new Ray(vectorg6.f, vectorg8.f);
for (int k = 0; k < colliderArray.Length; k++)
{
RaycastHit hit;
Collider collider = colliderArray[k];
if (collider.Raycast(ray, out hit, distance))
{
float num15 = hit.distance;
if (num15 < distance)
{
distance = num15;
float num16 = num8 + ((num15 / num12) * num9);
if (positiveInfinity > num16)
{
positiveInfinity = num16;
num2 = k;
}
}
}
}
}
}
if (float.IsInfinity(positiveInfinity))
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
else
{
positiveInfinity -= this.adaptiveNearPlane.threshold;
if (positiveInfinity >= this.adaptiveNearPlane.maxNear)
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
else if (positiveInfinity <= this.adaptiveNearPlane.minNear)
{
this.camera.nearClipPlane = this.adaptiveNearPlane.minNear;
}
else
{
this.camera.nearClipPlane = positiveInfinity;
}
}
}
builder.fieldOfView = this.camera.fieldOfView;
builder.aspectRatio = this.camera.aspect;
builder.nearPlane = this.camera.nearClipPlane;
builder.farPlane = this.camera.farClipPlane;
PerspectiveMatrixBuilder perspective = builder;
if (this.camera.isOrthoGraphic)
{
this.projectionMatrix.f = this.camera.projectionMatrix;
projectionMatrix = this.projectionMatrix;
}
else
{
if (this.viewModel != null)
{
this.viewModel.ModifyPerspective(ref perspective);
}
if (vm_projuse)
{
perspective.ToProjectionMatrix(out this.projectionMatrix);
}
else
{
builder.ToProjectionMatrix(out this.projectionMatrix);
}
this.camera.projectionMatrix = this.projectionMatrix.f;
perspective.ToProjectionMatrix(out projectionMatrix);
}
vector2.y = (float)perspective.nearPlane;
vector2.z = (float)perspective.farPlane;
vector2.w = (float)(1.0 / perspective.farPlane);
if (vm_flip == PLATFORM_POLL.flipRequired)
{
vector2.x = 1f;
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", projectionMatrix.f);
}
else
{
PerspectiveMatrixBuilder builder3;
Matrix4x4G matrixxg4;
vector2.x = -1f;
builder3.nearPlane = perspective.nearPlane;
builder3.farPlane = perspective.farPlane;
builder3.fieldOfView = -perspective.fieldOfView;
builder3.aspectRatio = -perspective.aspectRatio;
builder3.ToProjectionMatrix(out matrixxg4);
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrixxg4.f);
}
Shader.SetGlobalVector("V_M_ProjectionParams", vector2);
if (this.recalcViewMatrix)
{
Vector3G vectorg9;
QuaternionG ng;
Vector3G vectorg10;
this.camera.transform.ExtractWorldCoordinates(out vectorg9, out ng, out vectorg10);
vectorg10.x = 1.0;
vectorg10.y = 1.0;
vectorg10.z = -1.0;
Matrix4x4G.TRS(ref vectorg9, ref ng, ref vectorg10, out this.cameraToWorldMatrix);
if (Matrix4x4G.Inverse(ref this.cameraToWorldMatrix, out this.worldToCameraMatrix))
{
this.camera.worldToCameraMatrix = this.worldToCameraMatrix.f;
}
}
else
{
this.cameraToWorldMatrix.f = this.camera.cameraToWorldMatrix;
this.worldToCameraMatrix.f = this.camera.worldToCameraMatrix;
}
this.worldToCameraMatrixUnAltered = this.worldToCameraMatrix;
this.cameraToWorldMatrixUnAltered = this.cameraToWorldMatrix;
this.projectionMatrixUnAltered = this.projectionMatrix;
ApplyTransitionAlterations(this.camera, this, true);
this.projectScreen.modelview = this.projectViewport.modelview = this.worldToCameraMatrix;
this.projectScreen.projection = this.projectViewport.projection = this.projectionMatrix;
Rect pixelRect = this.camera.pixelRect;
this.projectScreen.offset.x = pixelRect.x;
this.projectScreen.offset.y = pixelRect.y;
this.projectScreen.size.x = pixelRect.width;
this.projectScreen.size.y = pixelRect.height;
pixelRect = this.camera.rect;
this.projectViewport.offset.x = pixelRect.x;
this.projectViewport.offset.y = pixelRect.y;
this.projectViewport.size.x = pixelRect.width;
this.projectViewport.size.y = pixelRect.height;
Matrix4x4G.Mult(ref this.localToWorldMatrix, ref this.worldToCameraMatrix, out matrixxg8);
Matrix4x4G.Mult(ref matrixxg8, ref this.projectionMatrix, out matrixxg5);
Matrix4x4G.Inverse(ref matrixxg8, out matrixxg9);
Matrix4x4G.Inverse(ref matrixxg5, out matrixxg6);
Matrix4x4G.Inverse(ref this.localToWorldMatrix, out matrixxg11);
Matrix4x4G.Transpose(ref matrixxg6, out matrixxg7);
Matrix4x4G.Transpose(ref matrixxg9, out matrixxg10);
Matrix4x4G.Transpose(ref matrixxg11, out matrixxg12);
if (this.viewModel != null)
{
this.viewModel.UpdateProxies();
}
BoundHack.Achieve(base.transform.position);
ContextSprite.UpdateSpriteFading(this.camera);
PlayerClient localPlayerClient = PlayerClient.localPlayerClient;
if (localPlayerClient != null)
{
localPlayerClient.ProcessLocalPlayerPreRender();
}
RPOS.BeforeSceneRender_Internal(this.camera);
}
// Token: 0x06002BC7 RID: 11207 RVA: 0x000A2E68 File Offset: 0x000A1068
public void PostPreCull()
{
if (global::CameraFX.viewModelRootTransform)
{
Quaternion localRotation = base.transform.localRotation;
Vector3 localPosition = base.transform.localPosition;
if (this.viewModel)
{
this.viewModel.ModifyAiming(new Ray(base.transform.parent.position, base.transform.parent.forward), ref localPosition, ref localRotation);
}
global::CameraFX.viewModelRootTransform.localRotation = Quaternion.Inverse(localRotation);
global::CameraFX.viewModelRootTransform.localPosition = -localPosition;
}
Precise.ExtractLocalToWorldToLocal(this.camera.transform, ref this.localToWorldMatrix, ref this.worldToLocalMatrix);
if (this.adaptiveNearPlane)
{
int num = (this.camera.cullingMask & ~this.adaptiveNearPlane.ignoreLayers.value) | this.adaptiveNearPlane.forceLayers.value;
Vector3G vector3G = default(Vector3G);
Vector3G vector3G2;
this.localToWorldMatrix.MultiplyPoint(ref vector3G, ref vector3G2);
Collider[] array = Physics.OverlapSphere(vector3G2.f, this.adaptiveNearPlane.minNear + this.adaptiveNearPlane.maxNear, num);
float num2 = float.PositiveInfinity;
double num3 = (double)this.camera.fieldOfView;
double num4 = (double)this.camera.aspect;
double num5 = (double)this.adaptiveNearPlane.minNear;
double num6 = (double)(this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold);
float minNear = this.adaptiveNearPlane.minNear;
float num7 = this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold - minNear;
Matrix4x4G matrix4x4G;
Matrix4x4G.Perspective(ref num3, ref num4, ref num5, ref num6, ref matrix4x4G);
Matrix4x4G matrix4x4G2;
Matrix4x4G.Inverse(ref matrix4x4G, ref matrix4x4G2);
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
Vector3G vector3G3;
vector3G3.x = ((double)i - 3.5) / 3.5;
vector3G3.y = ((double)j - 3.5) / 3.5;
vector3G3.z = 0.0;
Vector3G vector3G4;
matrix4x4G2.MultiplyPoint(ref vector3G3, ref vector3G4);
vector3G3.z = 1.0;
Vector3G vector3G5;
matrix4x4G2.MultiplyPoint(ref vector3G3, ref vector3G5);
vector3G4.x = -vector3G4.x;
vector3G4.y = -vector3G4.y;
vector3G4.z = -vector3G4.z;
vector3G5.x = -vector3G5.x;
vector3G5.y = -vector3G5.y;
vector3G5.z = -vector3G5.z;
Vector3G vector3G6;
this.localToWorldMatrix.MultiplyPoint(ref vector3G4, ref vector3G6);
Vector3G vector3G7;
this.localToWorldMatrix.MultiplyPoint(ref vector3G5, ref vector3G7);
Vector3G vector3G8;
vector3G8.x = vector3G7.x - vector3G6.x;
vector3G8.y = vector3G7.y - vector3G6.y;
vector3G8.z = vector3G7.z - vector3G6.z;
float num8 = (float)Math.Sqrt(vector3G8.x * vector3G8.x + vector3G8.y * vector3G8.y + vector3G8.z * vector3G8.z);
float num9 = num8;
Ray ray;
ray..ctor(vector3G6.f, vector3G8.f);
foreach (Collider collider in array)
{
RaycastHit raycastHit;
if (collider.Raycast(ray, ref raycastHit, num9))
{
float distance = raycastHit.distance;
if (distance < num9)
{
num9 = distance;
float num10 = minNear + distance / num8 * num7;
if (num2 > num10)
{
num2 = num10;
}
}
}
}
}
}
if (float.IsInfinity(num2))
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
else
{
num2 -= this.adaptiveNearPlane.threshold;
if (num2 >= this.adaptiveNearPlane.maxNear)
{
this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear;
}
else if (num2 <= this.adaptiveNearPlane.minNear)
{
this.camera.nearClipPlane = this.adaptiveNearPlane.minNear;
}
else
{
this.camera.nearClipPlane = num2;
}
}
}
global::PerspectiveMatrixBuilder perspectiveMatrixBuilder;
perspectiveMatrixBuilder.fieldOfView = (double)this.camera.fieldOfView;
perspectiveMatrixBuilder.aspectRatio = (double)this.camera.aspect;
perspectiveMatrixBuilder.nearPlane = (double)this.camera.nearClipPlane;
perspectiveMatrixBuilder.farPlane = (double)this.camera.farClipPlane;
global::PerspectiveMatrixBuilder perspectiveMatrixBuilder2 = perspectiveMatrixBuilder;
Matrix4x4G matrix4x4G3;
if (this.camera.isOrthoGraphic)
{
this.projectionMatrix.f = this.camera.projectionMatrix;
matrix4x4G3 = this.projectionMatrix;
}
else
{
if (this.viewModel)
{
this.viewModel.ModifyPerspective(ref perspectiveMatrixBuilder2);
}
if (global::CameraFX.vm_projuse)
{
perspectiveMatrixBuilder2.ToProjectionMatrix(out this.projectionMatrix);
}
else
{
perspectiveMatrixBuilder.ToProjectionMatrix(out this.projectionMatrix);
}
this.camera.projectionMatrix = this.projectionMatrix.f;
perspectiveMatrixBuilder2.ToProjectionMatrix(out matrix4x4G3);
}
Vector4 vector;
vector.y = (float)perspectiveMatrixBuilder2.nearPlane;
vector.z = (float)perspectiveMatrixBuilder2.farPlane;
vector.w = (float)(1.0 / perspectiveMatrixBuilder2.farPlane);
if (global::CameraFX.vm_flip == global::CameraFX.PLATFORM_POLL.flipRequired)
{
vector.x = 1f;
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G3.f);
}
else
{
vector.x = -1f;
global::PerspectiveMatrixBuilder perspectiveMatrixBuilder3;
perspectiveMatrixBuilder3.nearPlane = perspectiveMatrixBuilder2.nearPlane;
perspectiveMatrixBuilder3.farPlane = perspectiveMatrixBuilder2.farPlane;
perspectiveMatrixBuilder3.fieldOfView = -perspectiveMatrixBuilder2.fieldOfView;
perspectiveMatrixBuilder3.aspectRatio = -perspectiveMatrixBuilder2.aspectRatio;
Matrix4x4G matrix4x4G4;
perspectiveMatrixBuilder3.ToProjectionMatrix(out matrix4x4G4);
Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G4.f);
}
Shader.SetGlobalVector("V_M_ProjectionParams", vector);
if (this.recalcViewMatrix)
{
Vector3G vector3G9;
QuaternionG quaternionG;
Vector3G vector3G10;
Precise.ExtractWorldCoordinates(this.camera.transform, ref vector3G9, ref quaternionG, ref vector3G10);
vector3G10.x = 1.0;
vector3G10.y = 1.0;
vector3G10.z = -1.0;
Matrix4x4G.TRS(ref vector3G9, ref quaternionG, ref vector3G10, ref this.cameraToWorldMatrix);
if (Matrix4x4G.Inverse(ref this.cameraToWorldMatrix, ref this.worldToCameraMatrix))
{
this.camera.worldToCameraMatrix = this.worldToCameraMatrix.f;
}
}
else
{
this.cameraToWorldMatrix.f = this.camera.cameraToWorldMatrix;
this.worldToCameraMatrix.f = this.camera.worldToCameraMatrix;
}
this.worldToCameraMatrixUnAltered = this.worldToCameraMatrix;
this.cameraToWorldMatrixUnAltered = this.cameraToWorldMatrix;
this.projectionMatrixUnAltered = this.projectionMatrix;
global::CameraFX.ApplyTransitionAlterations(this.camera, this, true);
this.projectScreen.modelview = (this.projectViewport.modelview = this.worldToCameraMatrix);
this.projectScreen.projection = (this.projectViewport.projection = this.projectionMatrix);
Rect rect = this.camera.pixelRect;
this.projectScreen.offset.x = (double)rect.x;
this.projectScreen.offset.y = (double)rect.y;
this.projectScreen.size.x = (double)rect.width;
this.projectScreen.size.y = (double)rect.height;
rect = this.camera.rect;
this.projectViewport.offset.x = (double)rect.x;
this.projectViewport.offset.y = (double)rect.y;
this.projectViewport.size.x = (double)rect.width;
this.projectViewport.size.y = (double)rect.height;
Matrix4x4G matrix4x4G5;
Matrix4x4G.Mult(ref this.localToWorldMatrix, ref this.worldToCameraMatrix, ref matrix4x4G5);
Matrix4x4G matrix4x4G6;
Matrix4x4G.Mult(ref matrix4x4G5, ref this.projectionMatrix, ref matrix4x4G6);
Matrix4x4G matrix4x4G7;
Matrix4x4G.Inverse(ref matrix4x4G5, ref matrix4x4G7);
Matrix4x4G matrix4x4G8;
Matrix4x4G.Inverse(ref matrix4x4G6, ref matrix4x4G8);
Matrix4x4G matrix4x4G9;
Matrix4x4G.Inverse(ref this.localToWorldMatrix, ref matrix4x4G9);
Matrix4x4G matrix4x4G10;
Matrix4x4G.Transpose(ref matrix4x4G8, ref matrix4x4G10);
Matrix4x4G matrix4x4G11;
Matrix4x4G.Transpose(ref matrix4x4G7, ref matrix4x4G11);
Matrix4x4G matrix4x4G12;
Matrix4x4G.Transpose(ref matrix4x4G9, ref matrix4x4G12);
if (this.viewModel)
{
this.viewModel.UpdateProxies();
}
global::BoundHack.Achieve(base.transform.position);
global::ContextSprite.UpdateSpriteFading(this.camera);
global::PlayerClient localPlayerClient = global::PlayerClient.localPlayerClient;
if (localPlayerClient)
{
localPlayerClient.ProcessLocalPlayerPreRender();
}
global::RPOS.BeforeSceneRender_Internal(this.camera);
}