private void Init()
{
Camera camera = Window.Camera;
IRTEGraphicsLayer graphicsLayer = Window.IOCContainer.Resolve <IRTEGraphicsLayer>();
if (graphicsLayer != null && graphicsLayer.Camera != null)
{
camera = graphicsLayer.Camera.Camera;
}
if (camera == null)
{
return;
}
IRTEGraphics graphics = IOC.Resolve <IRTEGraphics>();
m_rteCamera = graphics.CreateCamera(camera, CameraEvent.AfterImageEffects, false, true);
m_rteCamera.RenderersCache.Add(m_output.GetComponent <Renderer>());
m_rteCamera.RefreshCommandBuffer();
DoSceneGizmo();
if (BtnProjection != null)
{
BtnProjection.gameObject.SetActive(true);
}
}
protected override void Render(Shader shader, string tag, Camera renderCamera)
{
IRTEGraphics graphics = IOC.Resolve <IRTEGraphics>();
m_rteCamera = graphics.CreateCamera(renderCamera, UnityEngine.Rendering.CameraEvent.AfterForwardAlpha, false, true);
for (int i = 0; i < m_renderers.Count; ++i)
{
Renderer[] renderers = m_renderers[i];
for (int j = 0; j < renderers.Length; ++j)
{
m_rteCamera.RenderersCache.Add(renderers[j]);
}
}
//Material material = new Material(shader);
//m_rteCamera.RenderersCache.MaterialOverride = material;
bool invertCulling = GL.invertCulling;
GL.invertCulling = true;
renderCamera.projectionMatrix *= Matrix4x4.Scale(new Vector3(1, -1, 1));
renderCamera.Render();
GL.invertCulling = invertCulling;
//Object.Destroy(material);
m_rteCamera.Destroy();
m_renderers.Clear();
}
private void CreateGraphicsCamera()
{
IRTEGraphics graphics = IOC.Resolve <IRTEGraphics>();
if (graphics != null)
{
IRTECamera rteCamera = graphics.CreateCamera(m_camera);
IOCContainer.RegisterFallback(rteCamera);
}
}
protected virtual void OnEnable()
{
Camera camera = Window.Camera;
IRTEGraphicsLayer graphicsLayer = Window.IOCContainer.Resolve <IRTEGraphicsLayer>();
if (graphicsLayer != null)
{
camera = graphicsLayer.Camera.Camera;
}
m_rteCamera = m_graphics.CreateCamera(camera);
m_rteCamera.RenderersCache.Add(m_output.GetComponent <Renderer>());
m_rteCamera.Event = CameraEvent.AfterImageEffects;
DoSceneGizmo();
if (BtnProjection != null)
{
BtnProjection.gameObject.SetActive(true);
}
}
private void PrepareGraphicsLayerCamera()
{
bool wasActive = m_window.Camera.gameObject.activeSelf;
m_window.Camera.gameObject.SetActive(false);
if (m_window.Editor.IsVR && m_window.Camera.stereoEnabled && m_window.Camera.stereoTargetEye == StereoTargetEyeMask.Both)
{
m_camera = Instantiate(m_window.Camera, m_window.Camera.transform.parent);
m_camera.transform.SetSiblingIndex(m_window.Camera.transform.GetSiblingIndex() + 1);
}
else
{
m_camera = Instantiate(m_window.Camera, m_window.Camera.transform);
}
for (int i = m_camera.transform.childCount - 1; i >= 0; i--)
{
Destroy(m_camera.transform.GetChild(i).gameObject);
}
Component[] components = m_camera.GetComponents <Component>();
for (int i = 0; i < components.Length; ++i)
{
Component component = components[i];
if (component is Transform)
{
continue;
}
if (component is Camera)
{
continue;
}
if (component is RenderTextureCamera)
{
continue;
}
Destroy(component);
}
m_camera.transform.localPosition = Vector3.zero;
m_camera.transform.localRotation = Quaternion.identity;
m_camera.transform.localScale = Vector3.one;
m_camera.name = "GraphicsLayerCamera";
m_camera.depth = m_window.Camera.depth + 1;
m_camera.cullingMask = 0;
if (RenderPipelineInfo.Type == RPType.Standard)
{
m_graphicsCamera = m_graphics.CreateCamera(m_camera, CameraEvent.BeforeImageEffects, true, true);
}
else
{
m_graphicsCamera = m_graphics.CreateCamera(m_camera, CameraEvent.AfterImageEffectsOpaque, true, true);
}
m_renderTextureCamera = m_camera.GetComponent <RenderTextureCamera>();
if (m_renderTextureCamera == null)
{
if (RenderPipelineInfo.Type == RPType.Standard)
{
if (m_window.RenderTextureUsage == RenderTextureUsage.On || m_window.RenderTextureUsage == RenderTextureUsage.UsePipelineSettings && RenderPipelineInfo.UseRenderTextures)
{
CreateRenderTextureCamera();
}
else
{
m_camera.clearFlags = CameraClearFlags.Depth;
}
}
else
{
RenderPipelineManager.beginFrameRendering += OnBeginFrameRendering;
RenderPipelineManager.endFrameRendering += OnEndFrameRendering;
}
}
else
{
if (m_window.RenderTextureUsage == RenderTextureUsage.Off || m_window.RenderTextureUsage == RenderTextureUsage.UsePipelineSettings && !RenderPipelineInfo.UseRenderTextures)
{
DestroyImmediate(m_renderTextureCamera);
}
else
{
m_renderTextureCamera.OverlayMaterial = new Material(Shader.Find("Battlehub/RTCommon/RenderTextureOverlay"));
m_camera.clearFlags = CameraClearFlags.SolidColor;
m_camera.backgroundColor = new Color(0, 0, 0, 0);
}
}
m_camera.allowHDR = false; //fix strange screen blinking bug...
m_camera.projectionMatrix = m_window.Camera.projectionMatrix; //for ARCore
m_window.Camera.gameObject.SetActive(wasActive);
m_camera.gameObject.SetActive(true);
}
private static Texture2D Render(
Camera camera,
Shader shader,
Renderer[] renderers,
int width = -1,
int height = -1)
{
bool autoSize = width < 0 || height < 0;
int _width = autoSize ? (int)camera.pixelRect.width : width;
int _height = autoSize ? (int)camera.pixelRect.height : height;
GameObject go = new GameObject();
Camera renderCam = go.AddComponent <Camera>();
renderCam.CopyFrom(camera);
renderCam.renderingPath = RenderingPath.Forward;
renderCam.enabled = false;
renderCam.clearFlags = CameraClearFlags.SolidColor;
renderCam.backgroundColor = Color.white;
renderCam.cullingMask = 0;
IRenderPipelineCameraUtility cameraUtility = IOC.Resolve <IRenderPipelineCameraUtility>();
if (cameraUtility != null)
{
cameraUtility.EnablePostProcessing(renderCam, false);
cameraUtility.SetBackgroundColor(renderCam, Color.white);
}
renderCam.allowHDR = false;
renderCam.allowMSAA = false;
renderCam.forceIntoRenderTexture = true;
float aspect = renderCam.aspect;
renderCam.rect = new Rect(Vector2.zero, Vector2.one);
renderCam.aspect = aspect;
RenderTextureDescriptor descriptor = new RenderTextureDescriptor()
{
width = _width,
height = _height,
colorFormat = RenderTextureFormat,
autoGenerateMips = false,
depthBufferBits = 16,
dimension = TextureDimension.Tex2D,
enableRandomWrite = false,
memoryless = RenderTextureMemoryless.None,
sRGB = true,
useMipMap = false,
volumeDepth = 1,
msaaSamples = 1
};
RenderTexture rt = RenderTexture.GetTemporary(descriptor);
RenderTexture prev = RenderTexture.active;
renderCam.targetTexture = rt;
RenderTexture.active = rt;
Material replacementMaterial = new Material(shader);
IRTEGraphics graphics = IOC.Resolve <IRTEGraphics>();
IRTECamera rteCamera = graphics.CreateCamera(renderCam, CameraEvent.AfterForwardAlpha, false, true);
rteCamera.RenderersCache.MaterialOverride = replacementMaterial;
rteCamera.Camera.name = "BoxSelectionCamera";
foreach (Renderer renderer in renderers)
{
Material[] materials = renderer.sharedMaterials;
for (int i = 0; i < materials.Length; ++i)
{
if (materials[i] != null)
{
rteCamera.RenderersCache.Add(renderer);
}
}
}
rteCamera.RefreshCommandBuffer();
if (RenderPipelineInfo.Type != RPType.Standard)
{
bool invertCulling = GL.invertCulling;
GL.invertCulling = true;
renderCam.projectionMatrix *= Matrix4x4.Scale(new Vector3(1, -1, 1));
renderCam.Render();
GL.invertCulling = invertCulling;
}
else
{
renderCam.Render();
}
Texture2D img = new Texture2D(_width, _height, TextureFormat, false, false);
img.ReadPixels(new Rect(0, 0, _width, _height), 0, 0);
img.Apply();
RenderTexture.active = prev;
RenderTexture.ReleaseTemporary(rt);
UnityObject.DestroyImmediate(go);
UnityObject.Destroy(replacementMaterial);
rteCamera.Destroy();
//System.IO.File.WriteAllBytes("Assets/box_selection.png", img.EncodeToPNG());
return(img);
}
