public HVRViewportInterface FlipViewport()
{
HVRViewportInterface viewport = CurrentViewport();
m_viewportIndex = (m_viewportIndex + 1) % MAXIMUM_VIEWPORTS;
return(viewport);
}
public void RenderCamera(HvrRender hvrRender, HVRViewportInterface viewport, bool resizedViewport = false)
{
// If the Unity viewport has been resized and an OpenGL renderer
// is in use then Unity will have recreated the main OpenGL
// context so all framebuffer and vertex attribute objects that
// are not shareable need to be destroyed and recreated.
//
// The extra call to `PlayerInterface.PreRender()` in this case is
// to make sure that the vertex buffers are populated for the
// render call below to avoid flickering.
if (resizedViewport)
{
StaticInterface.Self().ResetFrameBuffersAndMeshes();
PlayerInterface.PreRender(SceneInterface.Self().hvrSceneInterface);
PlayerInterface.PreRender(SceneInterface.Self().hvrSceneInterface);
}
Update();
LateUpdate();
if (!SceneInterface.Self().sceneHasPreRendered)
{
PlayerInterface.PreRender(SceneInterface.Self().hvrSceneInterface);
SceneInterface.Self().sceneHasPreRendered = true;
}
PlayerInterface.Render(SceneInterface.Self().hvrSceneInterface, viewport);
}
public HVRViewportInterface CurrentViewport()
{
HVRViewportInterface viewport = m_viewports[m_viewportIndex];
if (viewport == null || !viewport.IsValid() || m_initializedGraphicsDeviceType != SystemInfo.graphicsDeviceType)
{
InitializeViewports();
viewport = m_viewports[m_viewportIndex];
}
return(viewport);
}
private void InitializeViewports()
{
m_initializedGraphicsDeviceType = SystemInfo.graphicsDeviceType;
m_frameBuffer = new HVRFrameBufferInterface();
m_viewports = new HVRViewportInterface [MAXIMUM_VIEWPORTS];
m_viewportIndex = 0;
for (int i = 0; i < MAXIMUM_VIEWPORTS; ++i)
{
HVRViewportInterface viewport = new HVRViewportInterface();
viewport.SetFrameBuffer(m_frameBuffer);
m_viewports[i] = viewport;
}
}
public static void Render(HVRSceneInterface scene, HVRViewportInterface viewport)
{
if (scene != null && viewport != null)
{
HVRFrameBufferInterface frameBuffer = viewport.frameBuffer;
if (frameBuffer != null)
{
int clearEventID = HVRPlayerInterfaceAPI.Unity_FrameBuffer_Clear(frameBuffer.handle, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f);
GL.IssuePluginEvent(HVRPlayerInterfaceAPI.UnityRenderEventFunc(), clearEventID);
}
int eventID = HVRPlayerInterfaceAPI.Unity_Player_Render(scene.handle, viewport.handle);
GL.IssuePluginEvent(HVRPlayerInterfaceAPI.UnityRenderEventFunc(), eventID);
}
}
void DrawDebugTextures()
{
scrollViewPos = EditorGUILayout.BeginScrollView(scrollViewPos, false, false, GUILayout.MinHeight(240));
{
EditorGUILayout.BeginHorizontal();
{
{
Rect rect = EditorGUILayout.BeginHorizontal("box", GUILayout.Height(220), GUILayout.Width(210));
{
EditorGUI.LabelField(new Rect(rect.x, rect.y, rect.width, 15), "Color:");
HVRViewportInterface viewport = hvrRender.renderInterface.CurrentViewport();
Texture tex = viewport.frameBuffer.renderColourBuffer;
if (tex)
{
EditorGUI.DrawPreviewTexture(new Rect(rect.x + 5, rect.y + 15, 200, 200), tex, hvrRenderEditorPreviewMat);
}
GUILayout.Space(200);
}
EditorGUILayout.EndHorizontal();
}
{
Rect rect = EditorGUILayout.BeginHorizontal("box", GUILayout.Height(220), GUILayout.Width(210));
{
EditorGUI.LabelField(new Rect(rect.x, rect.y, rect.width, 15), "Depth:");
HVRViewportInterface viewport = hvrRender.renderInterface.CurrentViewport();
Texture tex = viewport.frameBuffer.renderDepthBuffer;
if (tex)
{
EditorGUI.DrawPreviewTexture(new Rect(rect.x + 5, rect.y + 15, 200, 200), tex, hvrRenderEditorPreviewMat);
}
GUILayout.Space(200);
}
EditorGUILayout.EndHorizontal();
}
GUILayout.FlexibleSpace();
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.EndScrollView();
}
public HVRViewportInterface FlipViewport()
{
HVRViewportInterface viewport = m_viewports[m_viewportIndex];
if (viewport == null || !viewport.IsValid() || m_initializedGraphicsDeviceType != SystemInfo.graphicsDeviceType)
{
m_initializedGraphicsDeviceType = SystemInfo.graphicsDeviceType;
m_viewports = new HVRViewportInterface [MAXIMUM_VIEWPORTS];
m_viewportIndex = 0;
for (int i = 0; i < MAXIMUM_VIEWPORTS; ++i)
{
m_viewports[i] = new HVRViewportInterface();
}
viewport = m_viewports[m_viewportIndex];
}
m_viewportIndex = (m_viewportIndex + 1) % MAXIMUM_VIEWPORTS;
return(viewport);
}
void OnPostRender()
{
Camera camera = GetComponent <Camera>();
int width = camera.pixelWidth;
int height = camera.pixelHeight;
bool resizedViewport = m_currentWidth != 0 && m_currentWidth != width || m_currentHeight != 0 && m_currentHeight != height;
m_currentWidth = width;
m_currentHeight = height;
HVRViewportInterface viewport = FlipViewport();
viewport.SetViewMatrix(camera.worldToCameraMatrix);
viewport.SetProjMatrix(GL.GetGPUProjectionMatrix(camera.projectionMatrix, false));
viewport.SetNearFarPlane(camera.nearClipPlane, camera.farClipPlane);
viewport.SetDimensions(0, 0, width, height);
viewport.SetFrameBuffer(null);
HvrStaticInterface.Self().RenderCamera(null, viewport, resizedViewport);
}
void OnPreRender()
{
if (CheckResources() == false)
{
return;
}
CommandBuffer_Validate();
Camera cam = GetComponent <Camera>();
//Viewport Settings
viewportSizeMultiplier = Mathf.Clamp(viewportSizeMultiplier, viewportSizeMin, viewportSizeMax);
viewportSettings.width = Mathf.RoundToInt((float)cam.pixelWidth * viewportSizeMultiplier);
viewportSettings.height = Mathf.RoundToInt((float)cam.pixelHeight * viewportSizeMultiplier);
viewport = renderInterface.FlipViewport();
viewport.SetViewMatrix(cam.worldToCameraMatrix);
viewport.SetProjMatrix(GL.GetGPUProjectionMatrix(cam.projectionMatrix, false));
viewport.SetNearFarPlane(cam.nearClipPlane, cam.farClipPlane);
viewport.SetDimensions(0, 0, viewportSettings.width, viewportSettings.height);
bool resizedViewport = viewport.frameBuffer.Resize(viewportSettings.width, viewportSettings.height);
if (resizedViewport)
{
CommandBuffer_Remove(activeCameraEvent);
}
// Render viewport
HvrStaticInterface.Self().RenderCamera(this, viewport, resizedViewport);
HvrColorGrading colorGrading = GameObject.FindObjectOfType <HvrColorGrading>();
if (colorGrading != null)
{
if (colorGradedTexture == null || colorGradedTexture.width != viewportSettings.width || colorGradedTexture.height != viewportSettings.height)
{
if (colorGradedTexture)
{
colorGradedTexture.Release();
}
colorGradedTexture = new RenderTexture(viewportSettings.width, viewportSettings.height, 0);
}
colorGrading.DoGrade(viewport.frameBuffer.renderColourBuffer, colorGradedTexture);
}
else
{
if (colorGradedTexture != null)
{
colorGradedTexture.Release();
colorGradedTexture = null;
}
}
switch (compositeMethod)
{
case CompositeMethods.commandBuffer:
// Command Buffer
commandBuffer_material.SetTexture("_oCOL", colorGradedTexture ? colorGradedTexture : viewport.frameBuffer.renderColourBuffer);
commandBuffer_material.SetTexture("_oDEP", viewport.frameBuffer.renderDepthBuffer);
Matrix4x4 inverseProjection = (cam.projectionMatrix.inverse);
commandBuffer_material.SetMatrix("_ProjectInverse", inverseProjection);
Matrix4x4 inverseViewProjection = (cam.projectionMatrix * cam.worldToCameraMatrix).inverse;
commandBuffer_material.SetMatrix("_ViewProjectInverse", inverseViewProjection);
commandBuffer_material.SetInt("g_hdr", cam.hdr ? 1 : 0);
break;
default:
break;
}
}
