Unity_CSMAndSimpleShadow

最新推荐文章于 2023-01-05 12:10:03 发布
最新推荐文章于 2023-01-05 12:10:03 发布
阅读量274 收藏
点赞数
分类专栏： Unity 文章标签： unity 游戏引擎
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wodownload2/article/details/124872645
版权

https://github.com/DreamChaseAndVera/Unity_CSMAndSimpleShadow.git

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CascadedShadowMapping : MonoBehaviour
{
    public Light dirLight;
    Camera dirLightCamera;

    public int shadowResolution = 1;
    public Shader shadowCaster = null;

    private Matrix4x4 biasMatrix = Matrix4x4.identity;

    List<Matrix4x4> world2ShadowMats = new List<Matrix4x4>(4);
    GameObject[] dirLightCameraSplits = new GameObject[4];
    RenderTexture[] depthTextures = new RenderTexture[4];

    void OnDestroy()
    {
        dirLightCamera = null;

        for (int i = 0; i < 4; i++)
        {
            if (depthTextures[i])
            {
                DestroyImmediate(depthTextures[i]);
            }
        }
    }

    void Awake()
    {
        biasMatrix.SetRow(0, new Vector4(0.5f, 0, 0, 0.5f));
        biasMatrix.SetRow(1, new Vector4(0, 0.5f, 0, 0.5f));
        biasMatrix.SetRow(2, new Vector4(0, 0, 0.5f, 0.5f));
        biasMatrix.SetRow(3, new Vector4(0, 0, 0, 1f));

        InitFrustumCorners();
    }

    // Use this for initialization
    void Start()
    {
    }

    private void CreateRenderTexture()
    {
        RenderTextureFormat rtFormat = RenderTextureFormat.Default;
        if (!SystemInfo.SupportsRenderTextureFormat(rtFormat))
            rtFormat = RenderTextureFormat.Default;

        for (int i = 0; i < 4; i++)
        {
            depthTextures[i] = new RenderTexture(1024, 1024, 24, rtFormat);
            Shader.SetGlobalTexture("_gShadowMapTexture" + i, depthTextures[i]);
        }
    }

    public Camera CreateDirLightCamera()
    {
        GameObject goLightCamera = new GameObject("Directional Light Camera");
        Camera LightCamera = goLightCamera.AddComponent<Camera>();

        LightCamera.cullingMask = 1 << LayerMask.NameToLayer("Caster");
        LightCamera.backgroundColor = Color.white;
        LightCamera.clearFlags = CameraClearFlags.SolidColor;
        LightCamera.orthographic = true;
        LightCamera.enabled = false;

        for (int i = 0; i < 4; i++)
        {
            dirLightCameraSplits[i] = new GameObject("dirLightCameraSplits" + i);
        }

        return LightCamera;
    }

    private void Update()
    {
        CalcMainCameraSplitsFrustumCorners();
        CalcLightCameraSplitsFrustum();

        if (dirLight)
        {
            if (!dirLightCamera)
            {
                dirLightCamera = CreateDirLightCamera();

                CreateRenderTexture();
            }

            Shader.SetGlobalFloat("_gShadowBias", 0.005f);
            Shader.SetGlobalFloat("_gShadowStrength", 0.5f);

            world2ShadowMats.Clear();
            for (int i = 0; i < 4; i++)
            {
                ConstructLightCameraSplits(i);

                dirLightCamera.targetTexture = depthTextures[i];
                dirLightCamera.RenderWithShader(shadowCaster, "");

                Matrix4x4 projectionMatrix = GL.GetGPUProjectionMatrix(dirLightCamera.projectionMatrix, false);
                world2ShadowMats.Add(projectionMatrix * dirLightCamera.worldToCameraMatrix);
            }

            Shader.SetGlobalMatrixArray("_gWorld2Shadow", world2ShadowMats);
        }
    }

    float[] _LightSplitsNear;
    float[] _LightSplitsFar;

    struct FrustumCorners
    {
        public Vector3[] nearCorners;
        public Vector3[] farCorners;
    }

    FrustumCorners[] mainCamera_Splits_fcs;
    FrustumCorners[] lightCamera_Splits_fcs;

    void InitFrustumCorners()
    {
        mainCamera_Splits_fcs = new FrustumCorners[4];
        lightCamera_Splits_fcs = new FrustumCorners[4];
        for (int i = 0; i < 4; i++)
        {
            mainCamera_Splits_fcs[i].nearCorners = new Vector3[4];
            mainCamera_Splits_fcs[i].farCorners = new Vector3[4];

            lightCamera_Splits_fcs[i].nearCorners = new Vector3[4];
            lightCamera_Splits_fcs[i].farCorners = new Vector3[4];
        }
    }

    void CalcMainCameraSplitsFrustumCorners()
    {
        float near = Camera.main.nearClipPlane;
        float far = Camera.main.farClipPlane;

        float[] nears = { near,
            far * 0.067f + near,
            far * 0.133f + far * 0.067f + near,
            far * 0.267f + far * 0.133f + far * 0.067f + near
        };
        float[] fars = { far * 0.067f + near, far * 0.133f + far * 0.067f + near, far * 0.267f + far * 0.133f + far * 0.067f + near, far };

        _LightSplitsNear = nears;
        _LightSplitsFar = fars;

        Shader.SetGlobalVector("_gLightSplitsNear", new Vector4(_LightSplitsNear[0], _LightSplitsNear[1], _LightSplitsNear[2], _LightSplitsNear[3]));
        Shader.SetGlobalVector("_gLightSplitsFar", new Vector4(_LightSplitsFar[0], _LightSplitsFar[1], _LightSplitsFar[2], _LightSplitsFar[3]));

        for (int k = 0; k < 4; k++)
        {
            Camera.main.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _LightSplitsNear[k], Camera.MonoOrStereoscopicEye.Mono, mainCamera_Splits_fcs[k].nearCorners);
            for (int i = 0; i < 4; i++)
            {
                mainCamera_Splits_fcs[k].nearCorners[i] = Camera.main.transform.TransformPoint(mainCamera_Splits_fcs[k].nearCorners[i]);
            }

            Camera.main.CalculateFrustumCorners(new Rect(0, 0, 1, 1), _LightSplitsFar[k], Camera.MonoOrStereoscopicEye.Mono, mainCamera_Splits_fcs[k].farCorners);
            for (int i = 0; i < 4; i++)
            {
                mainCamera_Splits_fcs[k].farCorners[i] = Camera.main.transform.TransformPoint(mainCamera_Splits_fcs[k].farCorners[i]);
            }
        }
    }

    void CalcLightCameraSplitsFrustum()
    {
        if (dirLightCamera == null)
            return;

        for (int k = 0; k < 4; k++)
        {
            for (int i = 0; i < 4; i++)
            {
                lightCamera_Splits_fcs[k].nearCorners[i] = dirLightCameraSplits[k].transform.InverseTransformPoint(mainCamera_Splits_fcs[k].nearCorners[i]);
                lightCamera_Splits_fcs[k].farCorners[i] = dirLightCameraSplits[k].transform.InverseTransformPoint(mainCamera_Splits_fcs[k].farCorners[i]);
            }

            float[] xs = { lightCamera_Splits_fcs[k].nearCorners[0].x, lightCamera_Splits_fcs[k].nearCorners[1].x, lightCamera_Splits_fcs[k].nearCorners[2].x, lightCamera_Splits_fcs[k].nearCorners[3].x,
                       lightCamera_Splits_fcs[k].farCorners[0].x, lightCamera_Splits_fcs[k].farCorners[1].x, lightCamera_Splits_fcs[k].farCorners[2].x, lightCamera_Splits_fcs[k].farCorners[3].x };

            float[] ys = { lightCamera_Splits_fcs[k].nearCorners[0].y, lightCamera_Splits_fcs[k].nearCorners[1].y, lightCamera_Splits_fcs[k].nearCorners[2].y, lightCamera_Splits_fcs[k].nearCorners[3].y,
                       lightCamera_Splits_fcs[k].farCorners[0].y, lightCamera_Splits_fcs[k].farCorners[1].y, lightCamera_Splits_fcs[k].farCorners[2].y, lightCamera_Splits_fcs[k].farCorners[3].y };

            float[] zs = { lightCamera_Splits_fcs[k].nearCorners[0].z, lightCamera_Splits_fcs[k].nearCorners[1].z, lightCamera_Splits_fcs[k].nearCorners[2].z, lightCamera_Splits_fcs[k].nearCorners[3].z,
                       lightCamera_Splits_fcs[k].farCorners[0].z, lightCamera_Splits_fcs[k].farCorners[1].z, lightCamera_Splits_fcs[k].farCorners[2].z, lightCamera_Splits_fcs[k].farCorners[3].z };

            float minX = Mathf.Min(xs);
            float maxX = Mathf.Max(xs);

            float minY = Mathf.Min(ys);
            float maxY = Mathf.Max(ys);

            float minZ = Mathf.Min(zs);
            float maxZ = Mathf.Max(zs);

            lightCamera_Splits_fcs[k].nearCorners[0] = new Vector3(minX, minY, minZ);
            lightCamera_Splits_fcs[k].nearCorners[1] = new Vector3(maxX, minY, minZ);
            lightCamera_Splits_fcs[k].nearCorners[2] = new Vector3(maxX, maxY, minZ);
            lightCamera_Splits_fcs[k].nearCorners[3] = new Vector3(minX, maxY, minZ);

            lightCamera_Splits_fcs[k].farCorners[0] = new Vector3(minX, minY, maxZ);
            lightCamera_Splits_fcs[k].farCorners[1] = new Vector3(maxX, minY, maxZ);
            lightCamera_Splits_fcs[k].farCorners[2] = new Vector3(maxX, maxY, maxZ);
            lightCamera_Splits_fcs[k].farCorners[3] = new Vector3(minX, maxY, maxZ);

            Vector3 pos = lightCamera_Splits_fcs[k].nearCorners[0] + (lightCamera_Splits_fcs[k].nearCorners[2] - lightCamera_Splits_fcs[k].nearCorners[0]) * 0.5f;


            dirLightCameraSplits[k].transform.position = dirLightCameraSplits[k].transform.TransformPoint(pos);
            dirLightCameraSplits[k].transform.rotation = dirLight.transform.rotation;

        }
    }

    void ConstructLightCameraSplits(int k)
    {
        dirLightCamera.transform.position = dirLightCameraSplits[k].transform.position;
        dirLightCamera.transform.rotation = dirLightCameraSplits[k].transform.rotation;

        dirLightCamera.nearClipPlane = lightCamera_Splits_fcs[k].nearCorners[0].z;
        dirLightCamera.farClipPlane = lightCamera_Splits_fcs[k].farCorners[0].z;

        dirLightCamera.aspect = Vector3.Magnitude(lightCamera_Splits_fcs[k].nearCorners[0] - lightCamera_Splits_fcs[k].nearCorners[1]) / Vector3.Magnitude(lightCamera_Splits_fcs[k].nearCorners[1] - lightCamera_Splits_fcs[k].nearCorners[2]);
        dirLightCamera.orthographicSize = Vector3.Magnitude(lightCamera_Splits_fcs[k].nearCorners[1] - lightCamera_Splits_fcs[k].nearCorners[2]) * 0.5f;
    }

    void CalcWorldToShadows()
    {

    }

    void OnDrawGizmos()
    {
        if (dirLightCamera == null)
            return;

        /*
        Gizmos.color = Color.blue;
        for (int i = 0; i < 4; i++)
        {
            Gizmos.DrawSphere(mainCamera_fcs.nearCorners[i], 0.1f);
            Gizmos.DrawSphere(mainCamera_fcs.farCorners[i], 0.1f);
        }

        Gizmos.color = Color.red;
        for (int i = 0; i < 4; i++)
        {
            Gizmos.DrawSphere(lightCamera_fcs.nearCorners[i], 0.1f);
            Gizmos.DrawSphere(lightCamera_fcs.farCorners[i], 0.1f);
        }

        Gizmos.color = Color.red;
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[0], lightCamera_fcs.nearCorners[1]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[1], lightCamera_fcs.nearCorners[2]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[2], lightCamera_fcs.nearCorners[3]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[3], lightCamera_fcs.nearCorners[0]);

        Gizmos.color = Color.green;
        Gizmos.DrawLine(lightCamera_fcs.farCorners[0], lightCamera_fcs.farCorners[1]);
        Gizmos.DrawLine(lightCamera_fcs.farCorners[1], lightCamera_fcs.farCorners[2]);
        Gizmos.DrawLine(lightCamera_fcs.farCorners[2], lightCamera_fcs.farCorners[3]);
        Gizmos.DrawLine(lightCamera_fcs.farCorners[3], lightCamera_fcs.farCorners[0]);

        Gizmos.DrawLine(lightCamera_fcs.nearCorners[0], lightCamera_fcs.farCorners[0]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[1], lightCamera_fcs.farCorners[1]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[2], lightCamera_fcs.farCorners[2]);
        Gizmos.DrawLine(lightCamera_fcs.nearCorners[3], lightCamera_fcs.farCorners[3]);
        */

        FrustumCorners[] fcs = new FrustumCorners[4];
        for (int k = 0; k < 4; k++)
        {
            Gizmos.color = Color.white;
            Gizmos.DrawLine(mainCamera_Splits_fcs[k].nearCorners[1], mainCamera_Splits_fcs[k].nearCorners[2]);

            fcs[k].nearCorners = new Vector3[4];
            fcs[k].farCorners = new Vector3[4];

            for (int i = 0; i < 4; i++)
            {
                fcs[k].nearCorners[i] = dirLightCameraSplits[k].transform.TransformPoint(lightCamera_Splits_fcs[k].nearCorners[i]);
                fcs[k].farCorners[i] = dirLightCameraSplits[k].transform.TransformPoint(lightCamera_Splits_fcs[k].farCorners[i]);
            }

            Gizmos.color = Color.red;
            Gizmos.DrawLine(fcs[k].nearCorners[0], fcs[k].nearCorners[1]);
            Gizmos.DrawLine(fcs[k].nearCorners[1], fcs[k].nearCorners[2]);
            Gizmos.DrawLine(fcs[k].nearCorners[2], fcs[k].nearCorners[3]);
            Gizmos.DrawLine(fcs[k].nearCorners[3], fcs[k].nearCorners[0]);

            Gizmos.color = Color.green;
            Gizmos.DrawLine(fcs[k].farCorners[0], fcs[k].farCorners[1]);
            Gizmos.DrawLine(fcs[k].farCorners[1], fcs[k].farCorners[2]);
            Gizmos.DrawLine(fcs[k].farCorners[2], fcs[k].farCorners[3]);
            Gizmos.DrawLine(fcs[k].farCorners[3], fcs[k].farCorners[0]);

            Gizmos.DrawLine(fcs[k].nearCorners[0], fcs[k].farCorners[0]);
            Gizmos.DrawLine(fcs[k].nearCorners[1], fcs[k].farCorners[1]);
            Gizmos.DrawLine(fcs[k].nearCorners[2], fcs[k].farCorners[2]);
            Gizmos.DrawLine(fcs[k].nearCorners[3], fcs[k].farCorners[3]);
        }
    }
}


// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

///
// author     : chen yong
// create time: 2015/8/5
// modify time: 
// description: Generate a depth texture from the projector
///

Shader "Kingsoft/CustomShadow/Caster" 
{
	SubShader {
		Tags { 			
		    "RenderType" = "Opaque"
		}

		CGINCLUDE
		#include "UnityCG.cginc"	
		struct v2f {
			float4 pos : SV_POSITION;
			float2 depth:TEXCOORD0;
		};

		uniform float _gShadowBias;
		v2f vert (appdata_full v)
		{
			v2f o;
			o.pos = UnityObjectToClipPos(v.vertex);
			o.pos.z += _gShadowBias;
			o.depth = o.pos.zw;
			return o;
		}
		
		fixed4 frag (v2f i) : COLOR
		{
			float depth = i.depth.x/i.depth.y;

		#if defined (SHADER_TARGET_GLSL) 
			depth = depth*0.5 + 0.5; //(-1, 1)-->(0, 1)
		#elif defined (UNITY_REVERSED_Z)
			depth = 1 - depth;       //(1, 0)-->(0, 1)
		#endif

			//return EncodeFloatRGBA(depth);
			return depth;
		}
		ENDCG 

		Pass {
			Fog { Mode Off }
			Cull front
			
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag	
			ENDCG
		}	
	}
}


// Upgrade NOTE: replaced '_World2Shadow' with 'unity_WorldToShadow[0]'

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
// Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'

///
// author     : chen yong
// create time: 2017/7/5
// modify time: 
// description: 
///

Shader "Kingsoft/CustomShadow/Receiver" {

	SubShader {
		Tags { "RenderType"="Opaque"  }

		LOD 300 

		Pass {
			Name "FORWARD"
			Tags{ "LightMode" = "ForwardBase" }

			CGPROGRAM
			#include "UnityCG.cginc"

			struct v2f
			{
				float4 pos : SV_POSITION;
				float2 uv : TEXCOORD0;
				float4 shadowCoord : TEXCOORD1;
				float eyeZ : TEXCOORD2;
				float4 worldPos : TEXCOORD3;
			};

			uniform float4x4 _gWorldToShadow;
			uniform sampler2D _gShadowMapTexture;
			uniform float4 _gShadowMapTexture_TexelSize;

			uniform float4 _gLightSplitsNear;
			uniform float4 _gLightSplitsFar;
			uniform float4x4 _gWorld2Shadow[4];
			
			uniform sampler2D _gShadowMapTexture0;
			uniform sampler2D _gShadowMapTexture1;
			uniform sampler2D _gShadowMapTexture2;
			uniform sampler2D _gShadowMapTexture3;

			uniform float _gShadowStrength;

			v2f vert (appdata_full v) 
			{
				v2f o;
				o.pos = UnityObjectToClipPos (v.vertex);
				o.uv = v.texcoord.xy;
                o.worldPos = mul(unity_ObjectToWorld, v.vertex);
                o.shadowCoord = mul(_gWorldToShadow, o.worldPos);
				o.eyeZ = o.pos.w;
				return o; 
			}

			float PCFSample(float depth, float2 uv)
			{
				float shadow = 0.0;
				for (int x = -1; x <= 1; ++x)
				{
					for (int y = -1; y <= 1; ++y)
					{
						float4 col = tex2D(_gShadowMapTexture, uv + float2(x, y) * _gShadowMapTexture_TexelSize.xy);
						float sampleDepth = DecodeFloatRGBA(col);
						shadow += sampleDepth < depth ? _gShadowStrength : 1;
					}
				}
				return shadow /= 9;
			}

			fixed4 getCascadeWeights(float z)
			{
				fixed4 zNear = float4(z >= _gLightSplitsNear);
				fixed4 zFar = float4(z < _gLightSplitsFar);
				fixed4 weights = zNear * zFar;
				return weights;
			}

			float4 getShadowCoord(float4 wpos, fixed4 cascadeWeights)
			{
				float3 sc0 = mul(_gWorld2Shadow[0], wpos).xyz;
				float3 sc1 = mul(_gWorld2Shadow[1], wpos).xyz;
				float3 sc2 = mul(_gWorld2Shadow[2], wpos).xyz;
				float3 sc3 = mul(_gWorld2Shadow[3], wpos).xyz;
				return float4(sc0 * cascadeWeights[0] + sc1 * cascadeWeights[1] + sc2 * cascadeWeights[2] + sc3 * cascadeWeights[3], 1);
			}

			float4 SampleShadowTexture(float4 wPos, fixed4 cascadeWeights)
			{
				float4 shadowCoord0 = mul(_gWorld2Shadow[0], wPos);
				float4 shadowCoord1 = mul(_gWorld2Shadow[1], wPos);
				float4 shadowCoord2 = mul(_gWorld2Shadow[2], wPos);
				float4 shadowCoord3 = mul(_gWorld2Shadow[3], wPos);

				shadowCoord0.xy /= shadowCoord0.w;
				shadowCoord1.xy /= shadowCoord1.w;
				shadowCoord2.xy /= shadowCoord2.w;
				shadowCoord3.xy /= shadowCoord3.w;

				shadowCoord0.xy = shadowCoord0.xy*0.5 + 0.5;
				shadowCoord1.xy = shadowCoord1.xy*0.5 + 0.5;
				shadowCoord2.xy = shadowCoord2.xy*0.5 + 0.5;
				shadowCoord3.xy = shadowCoord3.xy*0.5 + 0.5;

				float4 sampleDepth0 = tex2D(_gShadowMapTexture0, shadowCoord0.xy);
				float4 sampleDepth1 = tex2D(_gShadowMapTexture1, shadowCoord1.xy);
				float4 sampleDepth2 = tex2D(_gShadowMapTexture2, shadowCoord2.xy);
				float4 sampleDepth3 = tex2D(_gShadowMapTexture3, shadowCoord3.xy);

				float depth0 = shadowCoord0.z / shadowCoord0.w;
				float depth1 = shadowCoord1.z / shadowCoord1.w;
				float depth2 = shadowCoord2.z / shadowCoord2.w;
				float depth3 = shadowCoord3.z / shadowCoord3.w;

				#if defined (SHADER_TARGET_GLSL)
					depth0 = depth0*0.5 + 0.5; //(-1, 1)-->(0, 1)
					depth1 = depth1*0.5 + 0.5;
					depth2 = depth2*0.5 + 0.5;
					depth3 = depth3*0.5 + 0.5;
				#elif defined (UNITY_REVERSED_Z)
					depth0 = 1 - depth0;       //(1, 0)-->(0, 1)
					depth1 = 1 - depth1;
					depth2 = 1 - depth2;
					depth3 = 1 - depth3;
				#endif

				float shadow0 = sampleDepth0 < depth0 ? _gShadowStrength : 1;
				float shadow1 = sampleDepth1 < depth1 ? _gShadowStrength : 1;
				float shadow2 = sampleDepth2 < depth2 ? _gShadowStrength : 1;
				float shadow3 = sampleDepth3 < depth3 ? _gShadowStrength : 1;

				//return col0;
				float shadow = shadow0*cascadeWeights[0] + shadow1*cascadeWeights[1] + shadow2*cascadeWeights[2] + shadow3*cascadeWeights[3];
				return shadow*cascadeWeights;
			}

			fixed4 frag (v2f i) : COLOR0 
			{			
				//return float4(i.eyeZ < _gLightSplitsFar);

				fixed4 weights = getCascadeWeights(i.eyeZ);
				fixed4 coord = getShadowCoord(i.worldPos, weights);

			

				//return i.shadowCoord;
				// shadow
				i.shadowCoord.xy = i.shadowCoord.xy/i.shadowCoord.w;
				float2 uv = i.shadowCoord.xy;
				uv = uv*0.5 + 0.5; //(-1, 1)-->(0, 1)
	
				float depth = i.shadowCoord.z / i.shadowCoord.w;

			#if defined (SHADER_TARGET_GLSL)
				depth = depth*0.5 + 0.5; //(-1, 1)-->(0, 1)
			#elif defined (UNITY_REVERSED_Z)
				depth = 1 - depth;       //(1, 0)-->(0, 1)
			#endif

				// sample depth texture
				float4 col = SampleShadowTexture(i.worldPos, weights);
				return col;

				//return PCFSample(depth, uv);
			}	
		
			#pragma vertex vert
			#pragma fragment frag
			#pragma fragmentoption ARB_precision_hint_fastest 	
			ENDCG
		}
	}
}
wodownload2
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Simple Shadow Mapping
weixin_33875564的博客
10-30 56
　　Simple Shadow Mapping 最基本的SM。之前曾经被坑过，后来发现其实原理并不麻烦。就是 绘制深度图 加上 投影纹理映射 以及简单的比较就行了。 　　首先要获得深度图·其实要怎么获取·获取什么样的值（W-BUF或者Z-BUF）并没有太重要的关系·只要能有一张把光源当做摄像机所绘制出的深度图并保证比较时是一致的应该就可以了· 下面是简易的HLSL： #pragma pa...
CSM
阿拉平平的专栏
02-14 1079
csm基本概念和思想 csm基本概念：相机视锥体的不同区域需要不同 分辨率的shadowmap，离相机越近的物体需要的分辨率越高。 csm的基本思想：将平头锥体划分为多个子平头椎体，每一个子平头椎体用一个shadowmap进行渲染，像素shader对最接近所需要像素的shadowmap进行采样。 csm每帧需要以下几个步骤： （1）将视锥体划分为几个子视锥体； （2）为每个子视锥体计算一个正交投影...
【Unity Shader】Unity中阴影走样的解决方案
qq_41835314的博客
10-28 1522
对阴影映射过程出现的两种走样问题做了简单的介绍，以及介绍了Unity中处理的方法。
Unity实时阴影实现——Cascaded Shadow Mapping
u011105442的专栏
05-31 2482
前言 Unity内置的方向光实时阴影技术是Cascaded Shadow Mapping(简称CSM)。 由于Unity封装的原因，可能并不能满足实际项目实时阴影的需求，但我们可以从Unity开源出来的built-in shaders看出一些实现细节，这些可以作为自定义实现CSM的参考。 简述 Perspective aliasing in a shadow map is one of the most difficult problems to overcome. In the technical art
Unity实时阴影技术（shadowMap)
qq_53057269的博客
10-21 3255
Unity实时阴影技术
Unity圣典_unity圣典_unity_Unity圣典_
10-03
《Unity圣典》是一本深度探索Unity引擎的权威指南，旨在帮助开发者，无论是新手还是有经验的从业者，提升在游戏开发、虚拟现实(VR)、增强现实(AR)以及跨平台应用开发中的技能。这本书涵盖了从基础概念到高级技术的...
unity_builtin_extra
11-22
unity_builtin_extra
PicoVR_Unity_SDK_64bit 32bit.zip
12-25
《Pico VR Unity SDK详解与应用》 在虚拟现实（VR）技术的快速发展中，Pico作为一家专注于VR硬件和软件开发的公司，为开发者提供了一系列的工具和平台，其中包括Pico VR Unity SDK。这个SDK是针对Unity引擎设计的，...
OpenNI_Unity_Toolkit-0.9.7.4.rar
10-15
在"OpenNI_Unity_Toolkit-0.9.7.4.rar"这个压缩包中，包含了一个名为"OpenNI_Unity_Toolkit-0.9.7.4.unitypackage"的文件。这是一个Unity插件，它集成了OpenNI的功能，使得开发者无需深入理解底层的传感器交互，就能...
Unity _Quickpopes绳子插件
04-14
Unity Quickpopes是一款专为Unity游戏引擎设计的高效绳索插件，旨在帮助开发者快速创建出逼真的绳索、锁链以及其他类似物理效果的元素。这个插件的强大之处在于其简洁易用的接口和高度可定制化的物理模拟，使得...
Unity无缝大世界实现调研
最新发布
聚焦游戏和图形引擎开发技术
01-05 2720
无缝大世界的技术要求。世界足够大，一个地图就完整包含一个非常大的世界，如魔兽世界的整块卡利姆多大陆。面积从几平方公里到数十乃至上百平方公里。包含室外地形，城镇，也包含一定量的室内场景。室外地形包含各种地表，植被，河流，道路，山峰山谷，天空，云雾，光线。城镇场景包含大量的建筑和装饰物。室内场景也可能非常庞大，包含多个层次。
基于CSM和PCF的软阴影实现
种子、水、阳光
06-30 9868
断断续续花了两个多礼拜才把这个问题完全搞定，比开始预想的时间多多了，一开始也没想到会碰到这么多的状况，不过好在是都解决了。阴影技术是三维渲染里面的一个非常重要的课题，实现方式多种多样，最基本的是从光源方向渲一张ShadowMap，简单易行，但是效果很差，锯齿像牛一样大。想要获得更精细的阴影，唯一的办法就是加大SM的分辨率。 事实上我们对远处的阴影要求并没有近处那么高，粗糙点无所谓，反正离得远也
Unity移动端动态阴影总结
UWA—简单优化，优化简单！
06-12 8166
本文作者主要对Unity移动端动态阴影进行了一些总结。对各种不同阴影的构建作了简单的介绍。欢迎大家共同讨论。
Shadow Map 原理和改进
热门推荐
ronintao的专栏
07-07 4万+
shadow map基础及基本改进方法
CSM阴影技术讲解
海洋个人博客
08-16 4428
笔者介绍：姜雪伟，IT公司技术合伙人，IT高级讲师，CSDN社区专家，特邀编辑，畅销书作者，已出版书籍：《手把手教你架构3D游戏引擎》电子工业出版社和《Unity3D实战核心技术详解》电子工业出版社，《Cocos2d-x 3.x图形学渲染技术讲解》电子工业出版社等。CSDN视频网址：http://edu.csdn.net/lecturer/144 该篇博客主要是给读者介绍关于CSM实时阴影技术实
Unity3D移动平台简单实现
长溪木可的博客
07-17 4190
在电子游戏中移动平台可谓是十分常见的，如平台从一处至另一处的来回移动，或当需要玩家触发机关时，平台浮动并按一定的路线移动至目标处。本文主要是在Unity3D引擎下使用少量脚本实现两点之间来回移动平台的最基本功能，是一种比较简单且好理解的移动平台解决方案。 涉及到的点如下： 平台对象的实现 平台移动路线的设定 处于平台上游戏对象（如：玩家）的相对运动 创建平台控制对象 创建平台实...
Unity移动平台下的烘焙使用及优化
UWA—简单优化，优化简单！
08-23 4247
这是侑虎科技第436篇文章，感谢作者文雅供稿。欢迎转发分享，未经作者授权请勿转载。如果您有任何独到的见解或者发现也欢迎联系我们，一起探讨。（QQ群465082844） 作者也是U Sparkle活动参与者，UWA欢迎更多开发朋友加入U Sparkle开发者计划，这个舞台有你更精彩！ 前言 移动平台下场景制作的规模越来越大，开放视角的3D大世界场景，对地图大小、可视距离的要求越来越高，随之带来...
Unity3D游戏制作（三）——移动平台上的角色阴影制作
lilybeast的专栏
02-23 745
本系列文章由 Amazonzx 编写，欢迎转载，转载请注明出处。 http://blog.csdn.net/amazonzx/article/details/7973740 本文将重点介绍两种目前在移动平台上的主流阴影制作技术，同时也会简单介绍两种移动平台上相对较为高级的动态阴影生成方法。 由于目前主流使用Unity3.x在移动平台上并不支持阴影的动态生成技术，所以目前最普遍流行同时性价

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值