public void RenderStereoDepth() { Camera camera = GetComponent <Camera>(); // Remember camera config parameters CameraClearFlags clrFlgs = camera.clearFlags; Color bgColor = camera.backgroundColor; RenderingPath path = camera.renderingPath; // Setup camera for depth stereo rendering camera.stereoSeparation = 0.064f; camera.clearFlags = CameraClearFlags.SolidColor; camera.backgroundColor = Color.black; camera.SetReplacementShader(depthShader, "RenderType"); if (autoDepth) { depthCorrection = camera.stereoConvergence / camera.farClipPlane; } Shader.SetGlobalFloat("_MaxDepth", depthCorrection); camera.renderingPath = RenderingPath.Forward; // Render stero texture RenderCubemap(camera, "_depth"); // Restore camera config parameters camera.SetReplacementShader(null, "RenderType"); camera.renderingPath = path; camera.clearFlags = clrFlgs; camera.backgroundColor = bgColor; }
public void GraphicsUsingRenderingPathIsReported(RenderingPath renderingPath) { var buildGroup = BuildPipeline.GetBuildTargetGroup(EditorUserBuildSettings.activeBuildTarget); var savedTier1settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier1); var savedTier2settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier2); var savedTier3settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier3); var tier1settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier1); var tier2settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier2); var tier3settings = EditorGraphicsSettings.GetTierSettings(buildGroup, GraphicsTier.Tier3); tier1settings.renderingPath = renderingPath; tier2settings.renderingPath = renderingPath; tier3settings.renderingPath = renderingPath; EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier1, tier1settings); EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier2, tier2settings); EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier3, tier3settings); if (renderingPath == RenderingPath.Forward) { Assert.AreEqual(true, Evaluators.GraphicsUsingForwardRendering()); Assert.AreEqual(false, Evaluators.GraphicsUsingDeferredRendering()); } else { Assert.AreEqual(false, Evaluators.GraphicsUsingForwardRendering()); Assert.AreEqual(true, Evaluators.GraphicsUsingDeferredRendering()); } EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier1, savedTier1settings); EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier2, savedTier2settings); EditorGraphicsSettings.SetTierSettings(buildGroup, GraphicsTier.Tier3, savedTier3settings); }
/// <summary> /// This is just before the rendering process starts, so both <c>DrawMesh</c> and <c>CommandBuffer</c> will work /// </summary> protected virtual void OnPreCull() { var cam = GetComponent <Camera>(); if (cmdDepthTexture == null || cmdDepthZtest == null || prevRenderingPath != cam.actualRenderingPath) { if (cmdDepthTexture != null) { cam.RemoveCommandBuffer(evtDepthTexture, cmdDepthTexture); } if (cmdDepthZtest != null) { cam.RemoveCommandBuffer(evtDepthZtest, cmdDepthZtest); } prevRenderingPath = cam.actualRenderingPath; GetCameraEvents(prevRenderingPath, out evtDepthTexture, out evtDepthZtest); cmdDepthTexture = GetOrAddBuffer(evtDepthTexture); cmdDepthZtest = GetOrAddBuffer(evtDepthZtest); } cmdDepthTexture.Clear(); cmdDepthZtest.Clear(); SetupCommandBuffer(evtDepthTexture, cmdDepthTexture); SetupCommandBuffer(evtDepthZtest, cmdDepthZtest); ResetFrame(); DrawDecals(cmdDepthTexture, cmdDepthZtest); }
void AddBlitCommand() { if (cam is ImmediateMixCastCamera) { insertFeedCommands = new CommandBuffer(); if (cam.gameCamera.actualRenderingPath == RenderingPath.Forward) { insertFeedCommands.Blit(Texture, BuiltinRenderTextureType.CurrentActive, blitMaterial); //Insert real world cam.gameCamera.AddCommandBuffer(CameraEvent.AfterForwardOpaque, insertFeedCommands); } else { //insertFeedCommands.SetRenderTarget(BuiltinRenderTextureType.GBuffer0); insertFeedCommands.Blit(Texture, BuiltinRenderTextureType.CurrentActive, blitMaterial); //Insert real world cam.gameCamera.AddCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, insertFeedCommands); } renderPath = cam.gameCamera.actualRenderingPath; } else if (cam is BufferedMixCastCamera) { BufferedMixCastCamera buffCam = cam as BufferedMixCastCamera; buffCam.inputMaterial = blitMaterial; } }
/// <summary> /// Calculates the points in the rendering pipeline decal draws should be added to /// </summary> /// <param name="path">The rendering path being used</param> /// <param name="depthTexture">The event for when depth needs to be read from (typically screen space)</param> /// <param name="depthZtest">The event for when we need ZTest to work (non-screen-space)</param> /// <remarks>The two events can be the same</remarks> protected virtual void GetCameraEvents(RenderingPath path, out CameraEvent depthTexture, out CameraEvent depthZtest) { bool hasDepthZtest = false; depthZtest = default(CameraEvent); switch (path) { case RenderingPath.Forward: depthTexture = CameraEvent.AfterForwardOpaque; break; case RenderingPath.DeferredShading: // In Deferred, the depth buffer from the previous frame is used int the G-Buffer stages // so for depthTexture we need to use the next stage - BeforeReflections - instead depthTexture = CameraEvent.BeforeReflections; depthZtest = CameraEvent.AfterGBuffer; hasDepthZtest = true; break; case RenderingPath.DeferredLighting: depthTexture = CameraEvent.AfterFinalPass; break; case RenderingPath.VertexLit: depthTexture = CameraEvent.BeforeImageEffects; break; default: throw new ArgumentOutOfRangeException(); } if (!hasDepthZtest) { depthZtest = depthTexture; } }
void RenderFinalPass() { int oldCulling = gameCamera.cullingMask; CameraClearFlags oldClear = gameCamera.clearFlags; float oldFarClip = gameCamera.farClipPlane; float oldNearClip = gameCamera.nearClipPlane; RenderingPath oldRenderPath = gameCamera.renderingPath; gameCamera.cullingMask = 0; gameCamera.clearFlags = CameraClearFlags.Depth; gameCamera.farClipPlane = 1; gameCamera.nearClipPlane = 0.1f; gameCamera.renderingPath = RenderingPath.DeferredShading; gameCamera.AddCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, finalizeFrameCommand); gameCamera.targetTexture = Output as RenderTexture; gameCamera.aspect = (float)Output.width / Output.height; gameCamera.Render(); gameCamera.targetTexture = null; gameCamera.RemoveCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, finalizeFrameCommand); gameCamera.cullingMask = oldCulling; gameCamera.clearFlags = oldClear; gameCamera.farClipPlane = oldFarClip; gameCamera.nearClipPlane = oldNearClip; gameCamera.renderingPath = oldRenderPath; }
static int IntToEnum(IntPtr L) { int arg0 = (int)LuaDLL.lua_tonumber(L, 1); RenderingPath o = (RenderingPath)arg0; LuaScriptMgr.PushEnum(L, o); return(1); }
// The screen-space deferred material needs to use front-face culling so it doesn't // vanish when the camera moves within the bounding box public override Material ModifyMaterial(Material m, RenderingPath rp) { if (m.IsKeywordEnabled(ScreenSpace) && rp == RenderingPath.DeferredShading) { return(GetMaterial(ScreenSpace, "_Cull", (int)UnityEngine.Rendering.CullMode.Front)); } return(m); }
public override int[] GetKnownPasses(RenderingPath renderingPath) { if (renderingPath == RenderingPath.DeferredShading) { return(deferredPasses); } return(base.GetKnownPasses(renderingPath)); }
public CameraSettings() { _clearFlags = MainCamera.clearFlags; _renderingPath = MainCamera.renderingPath; _occulsionCulling = MainCamera.useOcclusionCulling; _hdr = MainCamera.allowHDR; _msaa = MainCamera.allowMSAA; _dynamicResolution = MainCamera.allowDynamicResolution; }
// Wird aufgerufen sobald das Script aktiviert wird (also schon deutlich vor start()) private void OnEnable() { RegisterDebugCallback(new DebugCallback(DebugMethod)); // Ob Forward oder deferred shading. Da FR aktiviert und deaktiviert werden muss vor und nach dem zeichnen von Geometrie. MainCamera = GameObject.Find("Main Camera").GetComponent <Camera>(); RenderingPath renderPath = MainCamera.actualRenderingPath; // Muss aktiviert sein if (InitFoveation()) { Debug.Log("Done: Initialiserung Foveation"); } else { //Debug.Log("Error: Initialiserung Foveation"); } // Forward ist im Projekt if (renderPath == RenderingPath.Forward) { CommandBuffer CbBeforeForwardO = new CommandBuffer(); CbBeforeForwardO.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.enableFoveation); CbBeforeForwardO.ClearRenderTarget(false, true, Color.black); MainCamera.AddCommandBuffer(CameraEvent.BeforeForwardOpaque, CbBeforeForwardO); CommandBuffer CbAfterForwardO = new CommandBuffer(); CbAfterForwardO.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.disableFoveation); MainCamera.AddCommandBuffer(CameraEvent.AfterForwardAlpha, CbAfterForwardO); } else if (renderPath == RenderingPath.DeferredShading) { CommandBuffer CbBeforeGBuffer = new CommandBuffer(); CbBeforeGBuffer.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.enableFoveation); CbBeforeGBuffer.ClearRenderTarget(false, true, Color.black); MainCamera.AddCommandBuffer(CameraEvent.BeforeGBuffer, CbBeforeGBuffer); CommandBuffer CbAfterGBuffer = new CommandBuffer(); CbAfterGBuffer.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.disableFoveation); MainCamera.AddCommandBuffer(CameraEvent.AfterGBuffer, CbAfterGBuffer); CommandBuffer CbBeforeForwardO = new CommandBuffer(); CbBeforeForwardO.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.enableFoveation); MainCamera.AddCommandBuffer(CameraEvent.BeforeForwardAlpha, CbBeforeForwardO); CommandBuffer CbAfterForwardO = new CommandBuffer(); CbAfterForwardO.IssuePluginEvent(GetRenderEventFunc(), (int)FoveationEvent.disableFoveation); MainCamera.AddCommandBuffer(CameraEvent.AfterForwardAlpha, CbAfterForwardO); } else { Debug.Log("Diese Plugin Unterstützt nur Forward oder Deffered Shading"); } SetShadingRate(innerShadingRate, middleShadingRate, outerShadingRate); SetShadingRadii(innerRadii, middleRadii, outerRadii); }
private void OnEnable() { this.SetGlobalParamsToNull(); this.m_Camera = (Camera)((Component)this).GetComponent <Camera>(); if (!Object.op_Implicit((Object)this.m_Camera)) { Debug.LogError((object)("DeepSky::DS_HazeView: GameObject '" + ((Object)((Component)this).get_gameObject()).get_name() + "' does not have a camera component!")); ((Behaviour)this).set_enabled(false); } else if (!this.CheckHasSystemSupport()) { ((Behaviour)this).set_enabled(false); } else { if (Object.op_Equality((Object)DS_HazeView.kShader, (Object)null)) { DS_HazeView.kShader = (Shader)Resources.Load <Shader>("DS_Haze"); } if (Object.op_Equality((Object)this.m_Material, (Object)null)) { this.m_Material = new Material(DS_HazeView.kShader); ((Object)this.m_Material).set_hideFlags((HideFlags)61); } if (this.m_Camera.get_actualRenderingPath() == 1 && (this.m_Camera.get_depthTextureMode() & 1) != 1) { this.m_Camera.set_depthTextureMode((DepthTextureMode)(this.m_Camera.get_depthTextureMode() | 1)); } if (this.m_RenderNonShadowVolumes == null) { CommandBuffer[] commandBuffers = this.m_Camera.GetCommandBuffers((CameraEvent)12); bool flag = false; foreach (CommandBuffer commandBuffer in commandBuffers) { if (commandBuffer.get_name() == DS_HazeView.kRenderLightVolumeCmdBufferName) { this.m_RenderNonShadowVolumes = commandBuffer; flag = true; break; } } if (!flag) { this.m_RenderNonShadowVolumes = new CommandBuffer(); this.m_RenderNonShadowVolumes.set_name(DS_HazeView.kRenderLightVolumeCmdBufferName); this.m_Camera.AddCommandBuffer((CameraEvent)12, this.m_RenderNonShadowVolumes); } } this.m_CurrentRadianceTarget = this.m_RadianceTarget_01; this.m_PreviousRadianceTarget = this.m_RadianceTarget_02; this.SetSkyboxKeywords(); this.SetDebugKeywords(); this.m_ColourSpace = QualitySettings.get_activeColorSpace(); this.m_PreviousRenderPath = this.m_Camera.get_actualRenderingPath(); } }
internal void UpdateCameraDepthBufferCameraEvent(RenderingPath renderingPath) { camera.RemoveCommandBuffer(m_DepthCommandBufferCameraEvent, depthCommandBuffer); if (m_requiresDepthTexture) { m_DepthCommandBufferCameraEvent = GetAppropriateDepthBufferCameraEvent(renderingPath); camera.AddCommandBuffer(m_DepthCommandBufferCameraEvent, depthCommandBuffer); } }
public void Apply() { myCam = GetComponent <Camera> (); currentUsedRenderingPath = myCam.actualRenderingPath; if (EnviroSky.instance.singlePassVR == true) { CreateSinglePassCameras(); } RefreshCameraCommand(); }
private void UpdateInfo() { currentDepthMode = camera.depthTextureMode; currentRenderPath = camera.actualRenderingPath; PostEffectsBase[] fx = gameObject.GetComponents<PostEffectsBase>(); int fxCount = 0; foreach (var post in fx) if (post.enabled) fxCount++; recognizedPostFxCount = fxCount; }
/// <summary> /// Format a matrix in the Unity format. This should only be used with projection matrix passing into shaders. /// </summary> /// <param name="m">The matrix</param> /// <returns></returns> public static Matrix4x4 FormatProjectionMatrix(Matrix4x4 m, RenderingPath renderingPath) { if (renderingPath == RenderingPath.DeferredShading) { for (int i = 0; i < 4; i++) { m[1, i] = -m[1, i]; } } return m; }
public void renderingPathSliderChanged(float val) { string[] renderingPathNames = System.Enum.GetNames(typeof(RenderingPath)); string renderingPathName = renderingPathNames[(int)val]; RenderingPath rp = (RenderingPath)System.Enum.Parse(typeof(RenderingPath), renderingPathName); foreach (GameObject cam in m_camerasObjects) { cam.GetComponent <Camera>().renderingPath = rp; } updateRenderingPathName(); }
private ScriptableRendererData CreateRendererDataAsset(string assetPath, RenderingPath renderingPath, string fileName) { var rendererAsset = UniversalRenderPipelineAsset.CreateRendererAsset(assetPath, RendererType.UniversalRenderer, true, fileName) as UniversalRendererData; //Missing API to set deferred or forward rendererAsset.renderingMode = renderingPath == RenderingPath.Forward ? RenderingMode.Forward : RenderingMode.Deferred; //missing API to assign to pipeline asset return(rendererAsset); }
static void BackupSettings() { GetInput("Horizontal"); GetLayers(); GetQuality(); GetBuildSettings(); initial_RenderPath = PlayerSettings.renderingPath; initial_ColorSpace = PlayerSettings.colorSpace; initial_DefaultIsFullScreen = PlayerSettings.defaultIsFullScreen; initial_APICompatibilityLevel = PlayerSettings.apiCompatibilityLevel; initial_CompanyName = PlayerSettings.companyName; initial_ProductName = PlayerSettings.productName; }
void AddBlitCommand() { if (gameCamera.actualRenderingPath == RenderingPath.Forward) { gameCamera.AddCommandBuffer(CameraEvent.AfterForwardOpaque, feedCommand); } else { gameCamera.AddCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, feedCommand); } lastRenderPath = gameCamera.actualRenderingPath; }
private RenderingMode GetEquivalentRenderMode(RenderingPath path) { switch (path) { case RenderingPath.VertexLit: case RenderingPath.Forward: return(RenderingMode.Forward); case RenderingPath.DeferredShading: return(RenderingMode.Deferred); default: return(RenderingMode.Forward); } }
protected override void ReadFromImpl(object obj) { base.ReadFromImpl(obj); Camera uo = (Camera)obj; nearClipPlane = uo.nearClipPlane; farClipPlane = uo.farClipPlane; fieldOfView = uo.fieldOfView; renderingPath = uo.renderingPath; allowHDR = uo.allowHDR; allowMSAA = uo.allowMSAA; allowDynamicResolution = uo.allowDynamicResolution; forceIntoRenderTexture = uo.forceIntoRenderTexture; orthographicSize = uo.orthographicSize; orthographic = uo.orthographic; opaqueSortMode = uo.opaqueSortMode; transparencySortMode = uo.transparencySortMode; transparencySortAxis = uo.transparencySortAxis; depth = uo.depth; aspect = uo.aspect; cullingMask = uo.cullingMask; eventMask = uo.eventMask; layerCullSpherical = uo.layerCullSpherical; cameraType = uo.cameraType; layerCullDistances = uo.layerCullDistances; useOcclusionCulling = uo.useOcclusionCulling; cullingMatrix = uo.cullingMatrix; backgroundColor = uo.backgroundColor; clearFlags = uo.clearFlags; depthTextureMode = uo.depthTextureMode; clearStencilAfterLightingPass = uo.clearStencilAfterLightingPass; usePhysicalProperties = uo.usePhysicalProperties; sensorSize = uo.sensorSize; lensShift = uo.lensShift; focalLength = uo.focalLength; rect = uo.rect; pixelRect = uo.pixelRect; targetTexture = ToID(uo.targetTexture); targetDisplay = uo.targetDisplay; worldToCameraMatrix = uo.worldToCameraMatrix; projectionMatrix = uo.projectionMatrix; nonJitteredProjectionMatrix = uo.nonJitteredProjectionMatrix; useJitteredProjectionMatrixForTransparentRendering = uo.useJitteredProjectionMatrixForTransparentRendering; scene = uo.scene; stereoSeparation = uo.stereoSeparation; stereoConvergence = uo.stereoConvergence; stereoTargetEye = uo.stereoTargetEye; }
void UpdateInfo() { currentDepthMode = GetComponent <Camera>().depthTextureMode; currentRenderPath = GetComponent <Camera>().actualRenderingPath; PostEffectsBase[] fx = gameObject.GetComponents <PostEffectsBase>(); int fxCount = 0; foreach (PostEffectsBase post in fx) { if (post.enabled) { fxCount++; } } currentPostFxCount = fxCount; }
private void UpdateInfo() { currentDepthMode = camera.depthTextureMode; currentRenderPath = camera.actualRenderingPath; PostEffectsBase[] fx = gameObject.GetComponents <PostEffectsBase>(); int fxCount = 0; foreach (var post in fx) { if (post.enabled) { fxCount++; } } recognizedPostFxCount = fxCount; }
private void SoftParticlesHintGUI() { Camera main = Camera.main; if (!(main == null)) { RenderingPath actualRenderingPath = main.actualRenderingPath; if (actualRenderingPath != RenderingPath.DeferredLighting && actualRenderingPath != RenderingPath.DeferredShading) { if ((main.depthTextureMode & DepthTextureMode.Depth) == DepthTextureMode.None) { EditorGUILayout.HelpBox(QualitySettingsEditor.Styles.kSoftParticlesHint.text, MessageType.Warning, false); } } } }
void OnPrecull(Camera camera) { // In case we use Metal and deferred shading reading and writing to the depth buffer makes water vanishing. So we do a copy of the depth buffer. if (GrabDepthTexture) { RenderingPath path = cam.actualRenderingPath; // Only needed if we use metal and deferred if (path == RenderingPath.DeferredShading && SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal) { CommandBuffer cBuffer; if (!m_cmdBuffer.TryGetValue(camera, out cBuffer)) { cBuffer = new CommandBuffer(); cBuffer.name = "Lux Water Grab Depth"; // This adds it to the lighting of the second camera? // camera.AddCommandBuffer(CameraEvent.AfterLighting, cBuffer); // This seems to work as the 2nd camera does not render a skybox camera.AddCommandBuffer(CameraEvent.BeforeSkybox, cBuffer); m_cmdBuffer[camera] = cBuffer; } cBuffer.Clear(); var width = camera.pixelWidth; var height = camera.pixelHeight; int depthGrabID = Shader.PropertyToID("_Lux_GrabbedDepth"); cBuffer.GetTemporaryRT(depthGrabID, width, height, 0, FilterMode.Point, format, RenderTextureReadWrite.Linear); cBuffer.Blit(BuiltinRenderTextureType.CurrentActive, depthGrabID, CopyDepthMat, 0); //Shader.EnableKeyword("LUXWATERMETALDEFERRED"); } else { GrabDepthTexture = false; foreach (var cam in m_cmdBuffer) { if (cam.Key != null) { cam.Key.RemoveCommandBuffer(CameraEvent.AfterLighting, cam.Value); } } m_cmdBuffer.Clear(); ShowShaderWarning = true; //Shader.DisableKeyword("LUXWATERMETALDEFERRED"); } } }
/// <summary> /// Returns what camera event the command should run /// at depending on the cameras rendering mode. /// </summary> CameraEvent GetCommandEvent(Camera cam) { RenderingPath path = cam.actualRenderingPath; if (path == RenderingPath.DeferredShading) { return(DEFERRED_EVENT); } else if (path == RenderingPath.DeferredLighting) { return(LEGACY_DEFERRED_EVENT); } else { return(FORWARD_EVENT); } }
public void CopyFrom(Camera camera) { this.clearFlags = camera.clearFlags; this.backgroundColor = camera.backgroundColor; this.cullingMask = camera.cullingMask; this.orthographic = camera.orthographic; this.orthographicSize = camera.orthographicSize; this.fieldOfView = camera.fieldOfView; this.nearClipPlane = camera.nearClipPlane; this.farClipPlane = camera.farClipPlane; this.rect = camera.rect; this.depth = camera.depth; this.renderingPath = camera.renderingPath; this.targetTexture = camera.targetTexture; this.useOcclusionCulling = camera.useOcclusionCulling; this.hdr = camera.hdr; }
private void UpdateMaterialProperties() { if (this.noiseTex == null || this._quality != this.generalSettings.quality || this._noiseType != this.generalSettings.noiseType) { if (this.noiseTex != null) { UnityEngine.Object.DestroyImmediate(this.noiseTex); } float num = (float)((this.generalSettings.noiseType != HBAO.NoiseType.Dither) ? 64 : 4); this.CreateRandomTexture((int)num); } this._quality = this.generalSettings.quality; this._noiseType = this.generalSettings.noiseType; this._radius = this.aoSettings.radius; this._maxRadiusPixels = this.aoSettings.maxRadiusPixels; this._bias = this.aoSettings.bias; this._intensity = this.aoSettings.intensity; this._luminanceInfluence = this.aoSettings.luminanceInfluence; this._maxDistance = this.aoSettings.maxDistance; this._distanceFalloff = this.aoSettings.distanceFalloff; this._perPixelNormals = this.aoSettings.perPixelNormals; this._aoBaseColor = this.aoSettings.baseColor; this._colorBleedingEnabled = this.colorBleedingSettings.enabled; this._colorBleedSaturation = this.colorBleedingSettings.saturation; this._albedoMultiplier = this.colorBleedingSettings.albedoMultiplier; this._blurAmount = this.blurSettings.amount; this._blurSharpness = this.blurSettings.sharpness; this._renderingPath = this._hbaoCamera.renderingPath; this._hbaoMaterial.SetTexture("_NoiseTex", this.noiseTex); this._hbaoMaterial.SetFloat("_NoiseTexSize", (float)((this._noiseType != HBAO.NoiseType.Dither) ? 64 : 4)); this._hbaoMaterial.SetFloat("_Radius", this._radius); this._hbaoMaterial.SetFloat("_MaxRadiusPixels", this._maxRadiusPixels); this._hbaoMaterial.SetFloat("_NegInvRadius2", -1f / (this._radius * this._radius)); this._hbaoMaterial.SetFloat("_AngleBias", this._bias); this._hbaoMaterial.SetFloat("_AOmultiplier", 2f * (1f / (1f - this._bias))); this._hbaoMaterial.SetFloat("_Intensity", this._intensity); this._hbaoMaterial.SetFloat("_LuminanceInfluence", this._luminanceInfluence); this._hbaoMaterial.SetFloat("_MaxDistance", this._maxDistance); this._hbaoMaterial.SetFloat("_DistanceFalloff", this._distanceFalloff); this._hbaoMaterial.SetColor("_BaseColor", this._aoBaseColor); this._hbaoMaterial.SetFloat("_ColorBleedSaturation", this._colorBleedSaturation); this._hbaoMaterial.SetFloat("_AlbedoMultiplier", this._albedoMultiplier); this._hbaoMaterial.SetFloat("_BlurSharpness", this._blurSharpness); }
public void RenderStereoAlbedo() { Camera camera = GetComponent <Camera>(); // Remember camera config parameters RenderingPath path = camera.renderingPath; // Setup camera for albedo stereo rendering camera.stereoSeparation = 0.064f; camera.SetReplacementShader(null, "RenderType"); camera.renderingPath = RenderingPath.Forward; // Render stero texture RenderCubemap(camera, "_albedo"); // Restore camera config parameters camera.SetReplacementShader(null, "RenderType"); camera.renderingPath = RenderingPath.UsePlayerSettings; }
private void RenderPathChanged() { if (this.m_Camera.get_actualRenderingPath() == 1 && (this.m_Camera.get_depthTextureMode() & 1) != 1) { this.m_Camera.set_depthTextureMode((DepthTextureMode)(this.m_Camera.get_depthTextureMode() | 1)); } if (this.m_ClearRadianceCmdBuffer != null) { CameraEvent cameraEvent = this.m_PreviousRenderPath != 3 ? ((this.m_Camera.get_depthTextureMode() & 2) != 2 ? (CameraEvent)0 : (CameraEvent)2) : (CameraEvent)4; foreach (CommandBuffer commandBuffer in this.m_Camera.GetCommandBuffers(cameraEvent)) { if (commandBuffer.get_name() == DS_HazeView.kClearRadianceCmdBufferName) { this.m_Camera.RemoveCommandBuffer(cameraEvent, commandBuffer); break; } } } this.m_PreviousRenderPath = this.m_Camera.get_actualRenderingPath(); }
private static bool IsDeferredRenderingPath(RenderingPath rp) { return ((rp == RenderingPath.DeferredLighting) || (rp == RenderingPath.DeferredShading)); }
internal RenderingPath RenderingPathPopup(RenderingPath rp) { return (RenderingPath) EditorGUILayout.IntPopup((int) rp, Styles.renderingPathName, Styles.renderingPathValue, new GUILayoutOption[0]); }
private void UpdateBuffer() { // copy settings from main camera in case of changes m_bufferCam.CopyFrom(SceneCamera); var rect = m_bufferCam.rect; rect.width = 1.0f; rect.x = 0.0f; m_bufferCam.rect = rect; m_bufferCam.depthTextureMode |= DepthTextureMode.Depth; // update frustum rays SetFrustumRays(); // update matrices m_matViewProjInverse = (m_bufferCam.projectionMatrix * m_bufferCam.worldToCameraMatrix).inverse; m_normalMatrix = m_bufferCam.worldToCameraMatrix.inverse.transpose; // save current tagret texture var texTmp = m_bufferCam.targetTexture; // save current rendering path var pathTmp = m_bufferCam.renderingPath; // generate buffer always in forward m_bufferCam.renderingPath = RenderingPath.Forward; // account for linear / gamma space var linearPow = LinearColorSpace ? 2.2f : 1.0f; Shader.SetGlobalFloat("_LinearPow", linearPow); // fill albedo buffer m_bufferCam.targetTexture = m_albedoBuffer; m_bufferCam.RenderWithShader(m_albedoMaterial.shader, "RenderType"); // fill transparency buffer m_bufferCam.targetTexture = m_transparencyBuffer; m_bufferCam.RenderWithShader(m_transparencyMaterial.shader, "RenderType"); // generate normals m_bufferCam.targetTexture = m_normalBuffer; m_bufferCam.RenderWithShader(m_normalMaterial.shader, "RenderType"); // restore rendering path m_bufferCam.renderingPath = pathTmp; // restore previous target texture m_bufferCam.targetTexture = texTmp; // if dimensions have changed, update render buffers dimensions if (m_screenDim.x != Screen.width || m_screenDim.y != Screen.height) { m_screenDim = new Vector2(Screen.width, Screen.height); DestroyImmediate(m_albedoBuffer); m_albedoBuffer = new RenderTexture(Screen.width, Screen.height, 24); DestroyImmediate(m_transparencyBuffer); m_transparencyBuffer = new RenderTexture(Screen.width, Screen.height, 24); DestroyImmediate(m_normalBuffer); m_normalBuffer = new RenderTexture(Screen.width, Screen.height, 24); } // rendering path changed? if (m_currentRenderingPath != SceneCamera.renderingPath) { // memorize rendering path m_currentRenderingPath = SceneCamera.renderingPath; foreach (var light in m_areaLightList) { if (light == null || !light.active) { continue; } var tmp = light.GetComponent<AreaLight>(); tmp.PickMaterial(); } if (m_currentRenderingPath == RenderingPath.DeferredLighting) { Shader.DisableKeyword("FORWARD"); Shader.EnableKeyword("DEFERRED"); } else { Shader.DisableKeyword("DEFERRED"); Shader.EnableKeyword("FORWARD"); } } }
void InitCamera() { SceneCamera = GetComponent<Camera>(); // setup separate camera for render buffer var camTrans = transform.FindChild("CamNode"); if (camTrans != null) { DestroyImmediate(camTrans.gameObject); } var camNode = new GameObject("CamNode"); camNode.transform.parent = transform; m_bufferCam = camNode.AddComponent<Camera>(); m_bufferCam.CopyFrom(SceneCamera); m_bufferCam.enabled = false; if (m_bufferCam == null) { Debug.LogError("Camera must not be null!"); } m_bufferCam.depthTextureMode |= DepthTextureMode.Depth; // default forward rendering if (m_bufferCam.renderingPath == RenderingPath.UsePlayerSettings) { m_bufferCam.renderingPath = RenderingPath.Forward; } // memorize rendering path m_currentRenderingPath = m_bufferCam.renderingPath; // set initial frustum rays SetFrustumRays(); }