public static void RenderLights(DSRenderer dsr)
{
foreach(DSLight l in instances) {
Vector4 c = l.lit.color * l.lit.intensity;
Vector4 shadow = Vector4.zero;
shadow.x = l.castShadow ? 1.0f : 0.0f;
shadow.y = (float)l.shadowSteps;
l.mat.SetTexture("_NormalBuffer", dsr.rtNormalBuffer);
l.mat.SetTexture("_PositionBuffer", dsr.rtPositionBuffer);
l.mat.SetTexture("_ColorBuffer", dsr.rtColorBuffer);
l.mat.SetTexture("_GlowBuffer", dsr.rtGlowBuffer);
l.mat.SetVector("_LightColor", c);
l.mat.SetVector("_ShadowParams", shadow);
if (l.lit.type == LightType.Point)
{
Matrix4x4 trans = Matrix4x4.TRS(l.transform.position, Quaternion.identity, Vector3.one);
Vector4 range = Vector4.zero;
range.x = l.lit.range;
range.y = 1.0f / range.x;
l.mat.SetVector("_LightPosition", l.transform.position);
l.mat.SetVector("_LightRange", range);
l.mat.SetPass(0);
Graphics.DrawMeshNow(l.mesh, trans);
}
else if (l.lit.type == LightType.Directional)
{
l.mat.SetVector("_LightDir", l.lit.transform.forward);
l.mat.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
}
}
void Render()
{
if (!enabled || m_material == null)
{
return;
}
DSRenderer dsr = GetDSRenderer();
dsr.CopyFramebuffer();
Graphics.SetRenderTarget(dsr.rtComposite.colorBuffer, dsr.rtNormalBuffer.depthBuffer);
m_material.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
m_material.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
m_material.SetFloat("g_speed", m_speed);
m_material.SetFloat("g_refraction", m_refraction);
m_material.SetFloat("g_reflection_intensity", m_reflection_intensity);
m_material.SetFloat("g_fresnel", m_fresnel);
m_material.SetFloat("g_raymarch_step", m_raymarch_step);
m_material.SetFloat("g_attenuation_by_distance", m_attenuation_by_distance);
m_material.SetPass(0);
DSPEWaterEntity.GetInstances().ForEach((e) =>
{
Graphics.DrawMeshNow(e.GetMesh(), e.GetMatrix());
});
Graphics.SetRenderTarget(dsr.rtComposite);
}
protected void ResetDSRenderer()
{
if (m_dsr == null) m_dsr = GetComponent<DSRenderer>();
if (m_dsr == null) m_dsr = GetComponentInParent<DSRenderer>();
if (m_cam == null) m_cam = GetComponent<Camera>();
if (m_cam == null) m_cam = GetComponentInParent<Camera>();
}
static public void RenderLights(DSRenderer dsr)
{
foreach (DSLight l in instances)
{
Vector4 c = l.lit.color * l.lit.intensity;
Vector4 shadow = Vector4.zero;
shadow.x = l.castShadow ? 1.0f : 0.0f;
shadow.y = (float)l.shadowSteps;
l.mat.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
l.mat.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
l.mat.SetTexture("_ColorBuffer", dsr.rtAlbedoBuffer);
l.mat.SetTexture("g_glow_buffer", dsr.rtEmissionBuffer);
l.mat.SetVector("_LightColor", c);
l.mat.SetVector("_ShadowParams", shadow);
if (l.lit.type == LightType.Point)
{
Matrix4x4 trans = Matrix4x4.TRS(l.transform.position, Quaternion.identity, Vector3.one);
Vector4 range = Vector4.zero;
range.x = l.lit.range;
range.y = 1.0f / range.x;
l.mat.SetVector("_LightPosition", l.transform.position);
l.mat.SetVector("_LightRange", range);
l.mat.SetPass(0);
Graphics.DrawMeshNow(l.mesh, trans);
}
else if (l.lit.type == LightType.Directional)
{
l.mat.SetVector("_LightDir", l.lit.transform.forward);
l.mat.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
}
}
void Render()
{
if (!enabled)
{
return;
}
UpdateRenderTargets();
DSRenderer dsr = GetDSRenderer();
Graphics.SetRenderTarget(rtNormalCopy);
GL.Clear(false, true, Color.black);
matNormalPattern.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
matNormalPattern.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
matNormalPattern.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(dsr.rtNormalBuffer);
matCopyGBuffer.SetTexture("g_normal_buffer", rtNormalCopy);
matCopyGBuffer.SetPass(2);
DSRenderer.DrawFullscreenQuad();
dsr.SetRenderTargetsGBuffer();
}
void OnEnable()
{
m_pw = GetComponent <GPUParticleWorld>();
if (m_camera == null || m_camera.Length == 0)
{
m_camera = new Camera[1] {
Camera.main
};
}
m_tmp_params = new CSTrailParams[1];
m_max_entities = m_pw.GetNumMaxParticles() * 2;
m_buf_trail_params = new ComputeBuffer(1, CSTrailParams.size);
m_buf_trail_entities = new ComputeBuffer(m_max_entities, CSTrailEntity.size);
m_buf_trail_history = new ComputeBuffer(m_max_entities * m_trail_max_history, CSTrailHistory.size);
m_buf_trail_vertices = new ComputeBuffer(m_max_entities * m_trail_max_history * 2, CSTrailVertex.size);
if (m_act_render == null)
{
m_act_render = Render;
foreach (var c in m_camera)
{
if (c == null)
{
continue;
}
DSRenderer dsr = c.GetComponent <DSRenderer>();
dsr.AddCallbackTransparent(m_act_render);
}
}
}
void UpdateRenderTargets()
{
Vector2 reso = GetDSRenderer().GetInternalResolution();
if (rtRDepth != null && rtRDepth.width != (int)reso.x)
{
rtRDepth.Release();
rtRDepth = null;
}
if (rtAndRDepth != null && rtAndRDepth.width != (int)reso.x)
{
rtAndRDepth.Release();
rtAndRDepth = null;
for (int i = 0; i < rtAndGBuffer.Length; ++i)
{
rtAndGBuffer[i].Release();
rtAndGBuffer[i] = null;
}
}
if (rtRDepth == null || !rtRDepth.IsCreated())
{
rtRDepth = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, 32, RenderTextureFormat.RHalf);
}
if (DSAnd.instances.Count > 0 && (rtAndRDepth == null || !rtAndRDepth.IsCreated()))
{
rtAndRDepth = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, 32, RenderTextureFormat.RHalf);
for (int i = 0; i < rtAndGBuffer.Length; ++i)
{
int depthbits = i == 0 ? 32 : 0;
rtAndGBuffer[i] = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, depthbits, RenderTextureFormat.ARGBHalf);
rbAndGBuffer[i] = rtAndGBuffer[i].colorBuffer;
}
}
}
protected void ResetDSRenderer()
{
Transform parent = GetComponent<Transform>().parent;
if (m_dsr == null) m_dsr = GetComponent<DSRenderer>();
if (m_dsr == null) m_dsr = parent.GetComponent<DSRenderer>();
if (m_cam == null) m_cam = GetComponent<Camera>();
if (m_cam == null) m_cam = parent.GetComponent<Camera>();
}
void Render()
{
if (!enabled)
{
return;
}
UpdateRenderTargets();
DSRenderer dsr = GetDSRenderer();
Vector4 hscreen = new Vector4(m_rt_half[0].width, m_rt_half[0].height, 1.0f / m_rt_half[0].width, 1.0f / m_rt_half[0].height);
Vector4 qscreen = new Vector4(m_rt_quarter[0].width, m_rt_quarter[0].height, 1.0f / m_rt_quarter[0].width, 1.0f / m_rt_quarter[0].height);
m_mat_bloom_blur.SetVector("_Screen", hscreen);
Graphics.SetRenderTarget(m_rt_half[0]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", dsr.rtEmissionBuffer);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[1]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_half[0]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[0]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_half[1]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[1]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_half[0]);
m_mat_bloom_blur.SetPass(1);
DSRenderer.DrawFullscreenQuad();
m_mat_bloom_blur.SetVector("_Screen", qscreen);
Graphics.SetRenderTarget(m_rt_quarter[0]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", dsr.rtEmissionBuffer);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[1]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_quarter[0]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[0]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_quarter[1]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[1]);
m_mat_bloom_blur.SetTexture("g_glow_buffer", m_rt_quarter[0]);
m_mat_bloom_blur.SetPass(1);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(dsr.rtComposite);
m_mat_bloom_combine.SetTexture("g_glow_buffer", dsr.rtEmissionBuffer);
m_mat_bloom_combine.SetTexture("g_half_glow_buffer", m_rt_half[1]);
m_mat_bloom_combine.SetTexture("g_quarter_glow_buffer", m_rt_quarter[1]);
m_mat_bloom_combine.SetFloat("g_intensity", m_intensity);
m_mat_bloom_combine.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void Render()
{
if (!enabled || matRaymarching == null)
{
return;
}
matRaymarching.SetFloat("_Fovy", fovy);
matRaymarching.SetFloat("_FixedRadius", fixedRadius);
matRaymarching.SetFloat("_MinRadius", minRadius);
matRaymarching.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void UpdateRenderTargets()
{
if (m_rt_half[0] == null || !m_rt_half[0].IsCreated())
{
for (int i = 0; i < 2; ++i)
{
m_rt_half[i] = DSRenderer.CreateRenderTexture(256, 256, 0, RenderTextureFormat.ARGBHalf);
m_rt_half[i].filterMode = FilterMode.Trilinear;
m_rt_quarter[i] = DSRenderer.CreateRenderTexture(128, 128, 0, RenderTextureFormat.ARGBHalf);
m_rt_quarter[i].filterMode = FilterMode.Trilinear;
}
}
}
void UpdateRenderTargets()
{
Vector2 reso = GetDSRenderer().GetInternalResolution();
if (rtNormalCopy != null && rtNormalCopy.width != (int)reso.x)
{
rtNormalCopy.Release();
rtNormalCopy = null;
}
if (rtNormalCopy == null || !rtNormalCopy.IsCreated())
{
rtNormalCopy = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, 0, RenderTextureFormat.ARGBHalf);
}
}
void Render()
{
if (!enabled)
{
return;
}
matFog.SetTexture("g_position_buffer", GetDSRenderer().rtPositionBuffer);
matFog.SetVector("_Color", color);
matFog.SetFloat("_Near", near);
matFog.SetFloat("_Far", far);
matFog.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
dsr.SwapFramebuffer();
m_material.SetVector("g_range_min", m_range_min);
m_material.SetVector("g_range_max", m_range_max);
m_material.SetVector("g_pow", m_pow);
m_material.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
dsr.SwapFramebuffer();
m_material.SetFloat("g_intensity", m_intensity);
m_material.SetFloat("g_radius", m_radius);
m_material.SetVector("g_center", m_center);
m_material.SetVector("g_threshold", m_threshold);
m_material.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void OnEnable()
{
s_instance = this;
DSRenderer dsr = GetComponent <DSRenderer>();
if (dsr == null)
{
dsr = GetComponentInParent <DSRenderer>();
}
if (m_depth_prepass == null)
{
m_depth_prepass = DepthPrePass;
m_gbuffer = GBufferPass;
dsr.AddCallbackPreGBuffer(m_depth_prepass);
dsr.AddCallbackPostGBuffer(m_gbuffer, 10);
}
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
dsr.SwapFramebuffer();
m_material.SetFloat("g_darkness", m_darkness);
m_material.SetFloat("g_monochrome", m_monochrome);
m_material.SetFloat("g_scanline", m_scanline);
m_material.SetFloat("g_scanline_scale", m_scanline_scale);
m_material.SetVector("g_color_shearing", m_color_shearing);
m_material.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
matGlowNormal.SetVector("_BaseColor", baseColor);
matGlowNormal.SetFloat("g_intensity", intensity);
matGlowNormal.SetFloat("_Threshold", threshold);
matGlowNormal.SetFloat("_Edge", edge);
matGlowNormal.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
matGlowNormal.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
matGlowNormal.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
protected void ResetDSRenderer()
{
if (m_dsr == null)
{
m_dsr = GetComponent <DSRenderer>();
}
if (m_dsr == null)
{
m_dsr = GetComponentInParent <DSRenderer>();
}
if (m_cam == null)
{
m_cam = GetComponent <Camera>();
}
if (m_cam == null)
{
m_cam = GetComponentInParent <Camera>();
}
}
void Render()
{
if (!enabled || m_material == null)
{
return;
}
DSRenderer dsr = GetDSRenderer();
m_material.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
m_material.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
m_material.SetFloat("g_speed", m_speed);
m_material.SetFloat("g_intensity", m_intensity);
m_material.SetPass(0);
DSPECausticsEntity.GetInstances().ForEach((e) => {
Graphics.DrawMeshNow(e.GetMesh(), e.GetMatrix());
});
}
public override void OnEnable()
{
base.OnEnable();
if (m_act_depth_prepass == null)
{
m_act_depth_prepass = DepthPrePass;
m_act_render = Render;
foreach (var c in m_camera)
{
if (c == null)
{
continue;
}
DSRenderer dsr = c.GetComponent <DSRenderer>();
dsr.AddCallbackPreGBuffer(m_act_depth_prepass);
dsr.AddCallbackPostGBuffer(m_act_render);
}
}
}
void UpdateRenderTargets()
{
Vector2 reso = GetDSRenderer().GetInternalResolution() * resolution_scale;
if (rtTemp[0] != null && rtTemp[0].width != (int)reso.x)
{
for (int i = 0; i < rtTemp.Length; ++i)
{
rtTemp[i].Release();
rtTemp[i] = null;
}
}
if (rtTemp[0] == null || !rtTemp[0].IsCreated())
{
for (int i = 0; i < rtTemp.Length; ++i)
{
rtTemp[i] = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, 0, RenderTextureFormat.ARGBHalf);
rtTemp[i].filterMode = FilterMode.Bilinear;
}
}
}
protected void ResetDSRenderer()
{
Transform parent = GetComponent <Transform>().parent;
if (m_dsr == null)
{
m_dsr = GetComponent <DSRenderer>();
}
if (m_dsr == null)
{
m_dsr = parent.GetComponent <DSRenderer>();
}
if (m_cam == null)
{
m_cam = GetComponent <Camera>();
}
if (m_cam == null)
{
m_cam = parent.GetComponent <Camera>();
}
}
void Render()
{
if (!enabled)
{
return;
}
UpdateRenderTargets();
DSRenderer dsr = GetDSRenderer();
Graphics.SetRenderTarget(m_rt_temp[0]);
//GL.Clear(false, true, Color.black);
m_mat_reflection.SetFloat("g_intensity", m_intensity);
m_mat_reflection.SetFloat("_RayMarchDistance", m_raymarch_distance);
m_mat_reflection.SetFloat("_RayDiffusion", m_ray_diffusion);
m_mat_reflection.SetFloat("_FalloffDistance", m_falloff_distance);
m_mat_reflection.SetFloat("_MaxAccumulation", m_max_accumulation);
m_mat_reflection.SetTexture("g_frame_buffer", dsr.rtComposite);
m_mat_reflection.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
m_mat_reflection.SetTexture("g_prev_position_buffer", dsr.rtPrevPositionBuffer);
m_mat_reflection.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
m_mat_reflection.SetTexture("_PrevResult", m_rt_temp[1]);
m_mat_reflection.SetMatrix("_ViewProjInv", dsr.viewProjInv);
m_mat_reflection.SetMatrix("_PrevViewProj", dsr.prevViewProj);
m_mat_reflection.SetMatrix("_PrevViewProjInv", dsr.prevViewProjInv);
m_mat_reflection.SetPass((int)m_algorithm);
DSRenderer.DrawFullscreenQuad();
m_rt_temp[0].filterMode = FilterMode.Trilinear;
Graphics.SetRenderTarget(dsr.rtComposite);
m_mate_combine.SetTexture("_MainTex", m_rt_temp[0]);
m_mate_combine.SetPass(2);
DSRenderer.DrawFullscreenQuad();
m_rt_temp[0].filterMode = FilterMode.Point;
DSRenderer.Swap(ref m_rt_temp[0], ref m_rt_temp[1]);
}
void Render()
{
if (!enabled)
{
return;
}
UpdateRenderTargets();
DSRenderer dsr = GetDSRenderer();
Graphics.SetRenderTarget(rtTemp[1]);
matFill.SetVector("_Color", new Vector4(0.0f, 0.0f, 0.0f, 0.02f));
matFill.SetTexture("g_position_buffer1", dsr.rtPositionBuffer);
matFill.SetTexture("g_position_buffer2", dsr.rtPrevPositionBuffer);
matFill.SetPass(1);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(rtTemp[0]);
matSurfaceLight.SetFloat("g_intensity", intensity);
matSurfaceLight.SetFloat("_RayAdvance", rayAdvance);
matSurfaceLight.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
matSurfaceLight.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
matSurfaceLight.SetTexture("_ColorBuffer", dsr.rtAlbedoBuffer);
matSurfaceLight.SetTexture("g_glow_buffer", dsr.rtEmissionBuffer);
matSurfaceLight.SetTexture("_PrevResult", rtTemp[1]);
matSurfaceLight.SetPass(0);
DSRenderer.DrawFullscreenQuad();
rtTemp[0].filterMode = FilterMode.Trilinear;
Graphics.SetRenderTarget(dsr.rtComposite);
matCombine.SetTexture("_MainTex", rtTemp[0]);
matCombine.SetPass(2);
DSRenderer.DrawFullscreenQuad();
rtTemp[0].filterMode = FilterMode.Point;
Swap(ref rtTemp[0], ref rtTemp[1]);
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
rbBuffers[0] = dsr.rtEmissionBuffer.colorBuffer;
rbBuffers[1] = dsr.rtAlbedoBuffer.colorBuffer;
Graphics.SetRenderTarget(rbBuffers, dsr.rtNormalBuffer.depthBuffer);
matGlowLine.SetTexture("g_position_buffer", dsr.rtPositionBuffer);
matGlowLine.SetTexture("g_normal_buffer", dsr.rtNormalBuffer);
matGlowLine.SetFloat("g_intensity", intensity);
matGlowLine.SetVector("_BaseColor", baseColor);
matGlowLine.SetInt("_GridPattern", (int)gridPattern);
matGlowLine.SetInt("_SpreadPattern", (int)spreadPattern);
matGlowLine.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(dsr.rtComposite);
}
void UpdateRenderTargets()
{
Vector2 reso = GetDSRenderer().GetInternalResolution() * m_resolution_scale;
if (m_rt_temp[0] != null && m_rt_temp[0].width != (int)reso.x)
{
for (int i = 0; i < m_rt_temp.Length; ++i)
{
m_rt_temp[i].Release();
m_rt_temp[i] = null;
}
}
if (m_rt_temp[0] == null || !m_rt_temp[0].IsCreated())
{
for (int i = 0; i < m_rt_temp.Length; ++i)
{
m_rt_temp[i] = DSRenderer.CreateRenderTexture((int)reso.x, (int)reso.y, 0, RenderTextureFormat.ARGBHalf);
m_rt_temp[i].filterMode = FilterMode.Point;
Graphics.SetRenderTarget(m_rt_temp[i]);
GL.Clear(false, true, Color.black);
}
}
}
void Render()
{
if (!enabled)
{
return;
}
UpdateRenderTargets();
DSRenderer dsr = GetDSRenderer();
Vector4 hscreen = new Vector4(m_rt_half[0].width, m_rt_half[0].height, 1.0f / m_rt_half[0].width, 1.0f / m_rt_half[0].height);
Vector4 qscreen = new Vector4(m_rt_quarter[0].width, m_rt_quarter[0].height, 1.0f / m_rt_quarter[0].width, 1.0f / m_rt_quarter[0].height);
m_mat_bloom_blur.SetVector("_Screen", hscreen);
Graphics.SetRenderTarget(m_rt_half[0]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", dsr.rtComposite);
m_mat_bloom_blur.SetVector("g_threshold", m_threshold);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[1]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_half[0]);
m_mat_bloom_blur.SetVector("g_threshold", Vector3.zero);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[0]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_half[1]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_half[1]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_half[0]);
m_mat_bloom_blur.SetPass(1);
DSRenderer.DrawFullscreenQuad();
m_mat_bloom_blur.SetVector("_Screen", qscreen);
Graphics.SetRenderTarget(m_rt_quarter[0]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", dsr.rtComposite);
m_mat_bloom_blur.SetVector("g_threshold", m_threshold);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[1]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_quarter[0]);
m_mat_bloom_blur.SetVector("g_threshold", Vector3.zero);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[0]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_quarter[1]);
m_mat_bloom_blur.SetPass(0);
DSRenderer.DrawFullscreenQuad();
Graphics.SetRenderTarget(m_rt_quarter[1]);
m_mat_bloom_blur.SetTexture("g_frame_buffer", m_rt_quarter[0]);
m_mat_bloom_blur.SetPass(1);
DSRenderer.DrawFullscreenQuad();
dsr.SwapFramebuffer();
m_mat_bloom_combine.SetTexture("g_half_frame_buffer", m_rt_half[1]);
m_mat_bloom_combine.SetTexture("g_quarter_frame_buffer", m_rt_quarter[1]);
m_mat_bloom_combine.SetVector("g_intensity", m_intensity);
m_mat_bloom_combine.SetPass(0);
DSRenderer.DrawFullscreenQuad();
}
void Render()
{
if (!enabled)
{
return;
}
DSRenderer dsr = GetDSRenderer();
// if there is no subtract or and object, just create g-buffer
if (DSSubtract.instances.Count == 0 && DSAnd.instances.Count == 0)
{
foreach (DSLogicOpReceiver l in DSLogicOpReceiver.instances)
{
l.matGBuffer.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
return;
}
UpdateRenderTargets();
// and
if (DSAnd.instances.Count > 0)
{
Graphics.SetRenderTarget(rtAndRDepth);
GL.Clear(true, true, Color.black, 0.0f);
foreach (DSAnd l in DSAnd.instances)
{
l.matReverseDepth.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
Graphics.SetRenderTarget(rbAndGBuffer, rtAndNormalBuffer.depthBuffer);
dsr.matGBufferClear.SetPass(0);
DSRenderer.DrawFullscreenQuad();
foreach (DSAnd l in DSAnd.instances)
{
l.matGBuffer.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
dsr.SetRenderTargetsGBuffer();
}
// create g-buffer
if (DSAnd.instances.Count > 0)
{
Graphics.SetRenderTarget(rtRDepth);
GL.Clear(true, true, Color.black, 0.0f);
foreach (DSLogicOpReceiver l in DSLogicOpReceiver.instances)
{
Graphics.SetRenderTarget(rtRDepth);
l.matReverseDepth.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
dsr.SetRenderTargetsGBuffer();
l.matGBuffer.SetInt("_EnableLogicOp", 1);
l.matGBuffer.SetTexture("_RDepthBuffer", rtRDepth);
l.matGBuffer.SetTexture("_AndRDepthBuffer", rtAndRDepth);
l.matGBuffer.SetTexture("_AndNormalBuffer", rtAndNormalBuffer);
l.matGBuffer.SetTexture("_AndPositionBuffer", rtAndPositionBuffer);
l.matGBuffer.SetTexture("_AndColorBuffer", rtAndColorBuffer);
l.matGBuffer.SetTexture("_AndGlowBuffer", rtAndGlowBuffer);
l.matGBuffer.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
Graphics.SetRenderTarget(rtRDepth);
l.matDepthClear.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
dsr.SetRenderTargetsGBuffer();
}
else
{
foreach (DSLogicOpReceiver l in DSLogicOpReceiver.instances)
{
l.matGBuffer.SetInt("_EnableLogicOp", 0);
l.matGBuffer.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
}
// create depth buffer with reversed meshes
{
Graphics.SetRenderTarget(rtRDepth);
GL.Clear(true, true, Color.black, 0.0f);
foreach (DSLogicOpReceiver l in DSLogicOpReceiver.instances)
{
l.matReverseDepth.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
dsr.SetRenderTargetsGBuffer();
}
// subtraction
foreach (DSSubtract l in DSSubtract.instances)
{
l.matStencilWrite.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
l.matSubtractor.SetTexture("_Depth", rtRDepth);
l.matSubtractor.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
l.matStencilClear.SetPass(0);
Graphics.DrawMeshNow(l.mesh, l.trans.localToWorldMatrix);
}
}
void Start()
{
dsr = GetComponent <DSRenderer>();
dsr.AddCallbackPostGBuffer(() => { Render(); }, 100);
}
void Start()
{
dsr = GetComponent<DSRenderer>();
dsr.AddCallbackPostGBuffer(() => { Render(); }, 100);
}
