/////////////////////////////////////////////////////////////////////////////////
// render related
public void InvokeStereoRenderers(VRRenderEventDetector detector)
{
// render registored stereo cameras
for (int renderIter = 0; renderIter < stereoRendererList.Count; renderIter++)
{
StereoRenderer stereoRenderer = stereoRendererList[renderIter];
if (stereoRenderer.shouldRender)
{
stereoRenderer.Render(detector);
}
}
}
public void MoveStereoCameraBasedOnHmdPose(VRRenderEventDetector detector)
{
Vector3 mainCamPos = detector.transform.position;
Quaternion mainCamRot = detector.transform.rotation;
if (isMirror)
{
// get reflection plane -- assume +y as normal
float offset = 0.07f;
float d = -Vector3.Dot(canvasOriginUp, canvasOriginPos) - offset;
Vector4 reflectionPlane = new Vector4(canvasOriginUp.x, canvasOriginUp.y, canvasOriginUp.z, d);
// get reflection matrix
reflectionMat = Matrix4x4.zero;
CalculateReflectionMatrix(ref reflectionMat, reflectionPlane);
// set head position
Vector3 reflectedPos = reflectionMat.MultiplyPoint(mainCamPos);
stereoCameraHead.transform.position = reflectedPos;
// set head orientation
stereoCameraHead.transform.rotation = mainCamRot;
}
else
{
Vector3 posCanvasToMainCam = mainCamPos - canvasOriginPos;
// compute the rotation between the portal entry and the portal exit
Quaternion rotCanvasToAnchor = anchorRot * Quaternion.Inverse(canvasOriginRot);
// move remote camera position
Vector3 posAnchorToStereoCam = rotCanvasToAnchor * posCanvasToMainCam;
stereoCameraHead.transform.position = anchorPos + posAnchorToStereoCam;
// rotate remote camera
stereoCameraHead.transform.rotation = rotCanvasToAnchor * mainCamRot;
}
}
private void RenderToOneStereoTexture(VRRenderEventDetector detector)
{
// get eye poses
if (detector.eye == 0)
{
Vector3 leftEyeOffset = StereoRenderManager.Instance.paramFactory.GetEyeSeperation(0);
Quaternion leftEyeRotation = StereoRenderManager.Instance.paramFactory.GetEyeLocalRotation(0);
RenderEye(
leftEyeOffset, leftEyeRotation,
leftProjMatrix, detector.unityCamera.worldToCameraMatrix,
leftEyeTexture, "_MainTexture");
}
else
{
Vector3 rightEyeOffset = StereoRenderManager.Instance.paramFactory.GetEyeSeperation(1);
Quaternion rightEyeRotation = StereoRenderManager.Instance.paramFactory.GetEyeLocalRotation(1);
RenderEye(
rightEyeOffset, rightEyeRotation,
rightProjMatrix, detector.unityCamera.worldToCameraMatrix,
rightEyeTexture, "_MainTexture");
}
}
private void RenderToTwoStereoTextures(VRRenderEventDetector detector)
{
// get eye poses
var leftEyeOffset = StereoRenderManager.Instance.paramFactory.GetEyeSeperation(0);
var leftEyeRotation = StereoRenderManager.Instance.paramFactory.GetEyeLocalRotation(0);
var rightEyeOffset = StereoRenderManager.Instance.paramFactory.GetEyeSeperation(1);
var rightEyeRotation = StereoRenderManager.Instance.paramFactory.GetEyeLocalRotation(1);
// render stereo textures
RenderEye(
leftEyeOffset, leftEyeRotation,
leftProjMatrix, detector.unityCamera.worldToCameraMatrix,
leftEyeTexture, "_LeftEyeTexture");
var rightEyeWorldToCameraMatrix = detector.unityCamera.worldToCameraMatrix;
rightEyeWorldToCameraMatrix.m03 -= 2.0f * Mathf.Abs(leftEyeOffset.x);
RenderEye(
rightEyeOffset, rightEyeRotation,
rightProjMatrix, rightEyeWorldToCameraMatrix,
rightEyeTexture, "_RightEyeTexture");
}
public void MoveStereoCameraBasedOnHmdPose(VRRenderEventDetector detector)
{
Vector3 mainCamPos = detector.transform.position;
Quaternion mainCamRot = detector.transform.rotation;
if (isMirror)
{
// get reflection plane -- assume +y as normal
float offset = 0.07f;
float d = -Vector3.Dot(canvasOriginUp, canvasOriginPos) - offset;
Vector4 reflectionPlane = new Vector4(canvasOriginUp.x, canvasOriginUp.y, canvasOriginUp.z, d);
// get reflection matrix
reflectionMat = Matrix4x4.zero;
CalculateReflectionMatrix(ref reflectionMat, reflectionPlane);
// set head position
Vector3 reflectedPos = reflectionMat.MultiplyPoint(mainCamPos);
stereoCameraHead.transform.position = reflectedPos;
// set head orientation
stereoCameraHead.transform.rotation = mainCamRot;
}
else
{
Quaternion Rot180 = Quaternion.Euler(0, 180.0f, 0);
Vector3 LocalPos = canvasOrigin.InverseTransformPoint(mainCamPos);
Vector3 RotatedPos = Rot180 * LocalPos;
stereoCameraHead.transform.position = anchorTransform.TransformPoint(RotatedPos);
stereoCameraHead.transform.rotation = anchorTransform.rotation * Rot180 * Quaternion.Inverse(canvasOrigin.rotation) * mainCamRot;
// Vector3 posCanvasToMainCam = mainCamPos - canvasOriginPos;
// // compute the rotation between the portal entry and the portal exit
// Quaternion rotCanvasToAnchor = anchorRot * Quaternion.Inverse(canvasOriginRot);
// // move remote camera position
// Vector3 posAnchorToStereoCam = rotCanvasToAnchor * posCanvasToMainCam;
// Vector3 posCanvasToMainCam = canvasOrigin
// Vector3 invTransformPoint = canvasOrigin.InverseTransformDirection(mainCamPos);
// Vector3 rotPos = Quaternion.Euler(0, 180.0f, 0) * invTransformPoint;
// Debug.Log("Canvas Origin Pos: " + canvasOriginPos);
// Debug.Log("Transform Pos:" + transform.position);
// Debug.Log("MainCameraPos: " + mainCamPos);
// Debug.Log("Pos Canvas To main cam:" + posCanvasToMainCam);
// Debug.Log("invTransformPoint" + invTransformPoint);
// Debug.Log("Rot Pos: " + rotPos);
// stereoCameraHead.transform.position = anchorPos + rotPos;
// Debug.Log(posCanvasTomainCam);
// stereoCameraHead.transform.position = anchorTransform.TransformDirection(rotPos);
// stereoCameraHead.transform.position = anchorPos + posAnchorToStereoCam;
// // rotate remote camera
// stereoCameraHead.transform.rotation = rotCanvasToAnchor * mainCamRot;
}
}
public void Render(VRRenderEventDetector detector)
{
// move stereo camera around based on HMD pose
MoveStereoCameraBasedOnHmdPose(detector);
// invoke pre-render events
if (preRenderListeners != null)
{
preRenderListeners.Invoke();
}
if (canvasVisible)
{
// change layer of specified objects,
// so that they become invisible to currect camera
ignoreObjOriginalLayer.Clear();
for (int i = 0; i < ignoreWhenRender.Count; i++)
{
ignoreObjOriginalLayer.Add(ignoreWhenRender[i].layer);
if (ignoreLayerNumber > 0)
{
ignoreWhenRender[i].layer = ignoreLayerNumber;
}
}
// invert backface culling when rendering a mirror
if (isMirror)
{
GL.invertCulling = true;
}
// render the canvas
if (StereoRenderDevice.IsNotUnityNativeSupport(StereoRenderManager.Instance.hmdType))
{
RenderToOneStereoTexture(detector);
}
else
{
RenderToTwoStereoTextures(detector);
}
// reset backface culling
if (isMirror)
{
GL.invertCulling = false;
}
// resume object layers
for (int i = 0; i < ignoreWhenRender.Count; i++)
{
ignoreWhenRender[i].layer = ignoreObjOriginalLayer[i];
}
// finish this render pass, reset visibility
canvasVisible = false;
}
// invoke post-render events
if (postRenderListeners != null)
{
postRenderListeners.Invoke();
}
}