GitHub
7 年前
当前提交
34abb246
共有 24 个文件被更改，包括 744 次插入 和 85 次删除
-
2Assets/ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl
-
10Assets/ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl
-
68Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs
-
4Assets/ScriptableRenderPipeline/HDRenderPipeline/HDShaderIDs.cs
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs
-
179Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl
-
2Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/HDRenderPipelineResources.asset
-
2Assets/ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/ShaderVariables.hlsl
-
10Assets/ScriptableRenderPipeline/Core/ShaderLibrary/Random.hlsl.meta
-
49Assets/ScriptableRenderPipeline/Core/ShaderLibrary/VolumeRendering.hlsl
-
10Assets/ScriptableRenderPipeline/Core/ShaderLibrary/VolumeRendering.hlsl.meta
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics.meta
-
13Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs.meta
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs.hlsl.meta
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/Resources.meta
-
136Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs
-
48Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs.hlsl
-
10Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/Resources/VolumetricLighting.compute.meta
-
226Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/Resources/VolumetricLighting.compute
-
10Assets/ScriptableRenderPipeline/Core/ShaderLibrary/Noise.hlsl.meta
-
0/Assets/ScriptableRenderPipeline/Core/ShaderLibrary/Random.hlsl
|
|||
fileFormatVersion: 2 |
|||
guid: 11914c30949383848ab39385375eff34 |
|||
timeCreated: 1504012042 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#ifndef UNITY_VOLUME_RENDERING_INCLUDED |
|||
#define UNITY_VOLUME_RENDERING_INCLUDED |
|||
|
|||
float OpticalDepthHomogeneous(float extinction, float intervalLength) |
|||
{ |
|||
return extinction * intervalLength; |
|||
} |
|||
|
|||
float Transmittance(float opticalDepth) |
|||
{ |
|||
return exp(-opticalDepth); |
|||
} |
|||
|
|||
float3 OpticalDepthHomogeneous(float3 extinction, float intervalLength) |
|||
{ |
|||
return extinction * intervalLength; |
|||
} |
|||
|
|||
float3 Transmittance(float3 opticalDepth) |
|||
{ |
|||
return exp(-opticalDepth); |
|||
} |
|||
|
|||
float IsotropicPhaseFunction() |
|||
{ |
|||
return INV_FOUR_PI; |
|||
} |
|||
|
|||
float HenyeyGreensteinPhasePartConstant(float asymmetry) |
|||
{ |
|||
float g = asymmetry; |
|||
|
|||
return INV_FOUR_PI * (1 - g * g); |
|||
} |
|||
|
|||
float HenyeyGreensteinPhasePartVarying(float asymmetry, float LdotD) |
|||
{ |
|||
float g = asymmetry; |
|||
|
|||
return pow(abs(1 + g * g - 2 * g * LdotD), -1.5); |
|||
} |
|||
|
|||
float HenyeyGreensteinPhaseFunction(float asymmetry, float LdotD) |
|||
{ |
|||
return HenyeyGreensteinPhasePartConstant(asymmetry) * |
|||
HenyeyGreensteinPhasePartVarying(asymmetry, LdotD); |
|||
} |
|||
|
|||
#endif // UNITY_VOLUME_RENDERING_INCLUDED |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 76b6dbce57ad3e647a01b5ad36f737a5 |
|||
timeCreated: 1503651539 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 1fe4fc72895e4bb4f90ff44b47e76051 |
|||
folderAsset: yes |
|||
timeCreated: 1503411233 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
externalObjects: {} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 8f608e240d5376341bcef2478d231457 |
|||
timeCreated: 1503411233 |
|||
licenseType: Pro |
|||
MonoImporter: |
|||
externalObjects: {} |
|||
serializedVersion: 2 |
|||
defaultReferences: [] |
|||
executionOrder: 0 |
|||
icon: {instanceID: 0} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: af39a96c040c8ec4da47ed13c6455ffe |
|||
timeCreated: 1503567986 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 333b470add5766f44a744f476efc19a8 |
|||
folderAsset: yes |
|||
timeCreated: 1503591964 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
externalObjects: {} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
using UnityEngine.Rendering; |
|||
using UnityEngine; |
|||
using System; |
|||
|
|||
namespace UnityEngine.Experimental.Rendering.HDPipeline |
|||
{ |
|||
[GenerateHLSL] |
|||
public struct VolumeProperties |
|||
{ |
|||
public Vector3 scattering; // [0, 1], prefer sRGB
|
|||
public float extinction; // [0, 1], prefer sRGB
|
|||
public float asymmetry; // Global (scene) property
|
|||
public float align16_0; |
|||
public float align16_1; |
|||
public float align16_2; |
|||
|
|||
public static VolumeProperties GetNeutralVolumeProperties() |
|||
{ |
|||
VolumeProperties properties = new VolumeProperties(); |
|||
|
|||
properties.scattering = Vector3.zero; |
|||
properties.extinction = 0; |
|||
properties.asymmetry = 0; |
|||
|
|||
return properties; |
|||
} |
|||
} |
|||
|
|||
[Serializable] |
|||
public class VolumeParameters |
|||
{ |
|||
public Bounds bounds; // Position and dimensions in meters
|
|||
public Color albedo; // Single scattering albedo [0, 1]
|
|||
public float meanFreePath; // In meters [1, inf]. Should be chromatic - this is an optimization!
|
|||
public float anisotropy; // [-1, 1]; 0 = isotropic
|
|||
|
|||
public VolumeParameters() |
|||
{ |
|||
bounds = new Bounds(Vector3.zero, Vector3.positiveInfinity); |
|||
albedo = new Color(0.5f, 0.5f, 0.5f); |
|||
meanFreePath = 10.0f; |
|||
anisotropy = 0.0f; |
|||
} |
|||
|
|||
public bool IsVolumeUnbounded() |
|||
{ |
|||
return bounds.size.x == float.PositiveInfinity && |
|||
bounds.size.y == float.PositiveInfinity && |
|||
bounds.size.z == float.PositiveInfinity; |
|||
} |
|||
|
|||
public Vector3 GetAbsorptionCoefficient() |
|||
{ |
|||
float extinction = GetExtinctionCoefficient(); |
|||
Vector3 scattering = GetScatteringCoefficient(); |
|||
|
|||
return Vector3.Max(new Vector3(extinction, extinction, extinction) - scattering, Vector3.zero); |
|||
} |
|||
|
|||
public Vector3 GetScatteringCoefficient() |
|||
{ |
|||
float extinction = GetExtinctionCoefficient(); |
|||
|
|||
return new Vector3(albedo.r * extinction, albedo.g * extinction, albedo.b * extinction); |
|||
} |
|||
|
|||
public float GetExtinctionCoefficient() |
|||
{ |
|||
return 1.0f / meanFreePath; |
|||
} |
|||
|
|||
public void Constrain() |
|||
{ |
|||
bounds.size = Vector3.Max(bounds.size, Vector3.zero); |
|||
|
|||
albedo.r = Mathf.Clamp01(albedo.r); |
|||
albedo.g = Mathf.Clamp01(albedo.g); |
|||
albedo.b = Mathf.Clamp01(albedo.b); |
|||
|
|||
meanFreePath = Mathf.Max(meanFreePath, 1.0f); |
|||
|
|||
anisotropy = Mathf.Clamp(anisotropy, -1.0f, 1.0f); |
|||
} |
|||
|
|||
public VolumeProperties GetProperties() |
|||
{ |
|||
VolumeProperties properties = new VolumeProperties(); |
|||
|
|||
properties.scattering = GetScatteringCoefficient(); |
|||
properties.extinction = GetExtinctionCoefficient(); |
|||
properties.asymmetry = anisotropy; |
|||
|
|||
return properties; |
|||
} |
|||
} |
|||
|
|||
[ExecuteInEditMode] |
|||
[AddComponentMenu("Rendering/Homogeneous Fog", -1)] |
|||
public class HomogeneousFog : MonoBehaviour |
|||
{ |
|||
public VolumeParameters volumeParameters; |
|||
|
|||
private void Awake() |
|||
{ |
|||
if (volumeParameters == null) |
|||
{ |
|||
volumeParameters = new VolumeParameters(); |
|||
} |
|||
} |
|||
|
|||
private void OnEnable() |
|||
{ |
|||
} |
|||
|
|||
private void OnDisable() |
|||
{ |
|||
} |
|||
|
|||
private void Update() |
|||
{ |
|||
} |
|||
|
|||
private void OnValidate() |
|||
{ |
|||
volumeParameters.Constrain(); |
|||
} |
|||
|
|||
void OnDrawGizmos() |
|||
{ |
|||
if (volumeParameters != null && !volumeParameters.IsVolumeUnbounded()) |
|||
{ |
|||
Gizmos.DrawWireCube(volumeParameters.bounds.center, volumeParameters.bounds.size); |
|||
} |
|||
} |
|||
} |
|||
} // UnityEngine.Experimental.Rendering.HDPipeline
|
|||
|
|||
// |
|||
// This file was automatically generated from Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs. Please don't edit by hand. |
|||
// |
|||
|
|||
#ifndef HOMOGENEOUSFOG_CS_HLSL |
|||
#define HOMOGENEOUSFOG_CS_HLSL |
|||
// Generated from UnityEngine.Experimental.Rendering.HDPipeline.VolumeProperties |
|||
// PackingRules = Exact |
|||
struct VolumeProperties |
|||
{ |
|||
float3 scattering; |
|||
float extinction; |
|||
float asymmetry; |
|||
float align16_0; |
|||
float align16_1; |
|||
float align16_2; |
|||
}; |
|||
|
|||
// |
|||
// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.VolumeProperties |
|||
// |
|||
float3 GetScattering(VolumeProperties value) |
|||
{ |
|||
return value.scattering; |
|||
} |
|||
float GetExtinction(VolumeProperties value) |
|||
{ |
|||
return value.extinction; |
|||
} |
|||
float GetAsymmetry(VolumeProperties value) |
|||
{ |
|||
return value.asymmetry; |
|||
} |
|||
float GetAlign16_0(VolumeProperties value) |
|||
{ |
|||
return value.align16_0; |
|||
} |
|||
float GetAlign16_1(VolumeProperties value) |
|||
{ |
|||
return value.align16_1; |
|||
} |
|||
float GetAlign16_2(VolumeProperties value) |
|||
{ |
|||
return value.align16_2; |
|||
} |
|||
|
|||
|
|||
#endif |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 799166e2ee6a4b041bba9e74f6942097 |
|||
timeCreated: 1503570390 |
|||
licenseType: Pro |
|||
ComputeShaderImporter: |
|||
externalObjects: {} |
|||
currentAPIMask: 4 |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
//-------------------------------------------------------------------------------------------------- |
|||
// Definitions |
|||
//-------------------------------------------------------------------------------------------------- |
|||
|
|||
#pragma kernel VolumetricLightingAllLights VolumetricLighting=VolumetricLightingAllLights LIGHTLOOP_SINGLE_PASS |
|||
#pragma kernel VolumetricLightingClustered VolumetricLighting=VolumetricLightingClustered LIGHTLOOP_TILE_PASS USE_CLUSTERED_LIGHTLIST |
|||
|
|||
#pragma enable_d3d11_debug_symbols |
|||
|
|||
#include "../../../ShaderPass/ShaderPass.cs.hlsl" |
|||
#define SHADERPASS SHADERPASS_VOLUMETRIC_LIGHTING |
|||
#define GROUP_SIZE_1D 16 |
|||
#define GROUP_SIZE_2D (GROUP_SIZE_1D * GROUP_SIZE_1D) |
|||
|
|||
//-------------------------------------------------------------------------------------------------- |
|||
// Included headers |
|||
//-------------------------------------------------------------------------------------------------- |
|||
|
|||
#include "../../../../Core/ShaderLibrary/Common.hlsl" |
|||
#include "../../../../Core/ShaderLibrary/SpaceFillingCurves.hlsl" |
|||
#include "../../../../Core/ShaderLibrary/VolumeRendering.hlsl" |
|||
|
|||
#include "../HomogeneousFog.cs.hlsl" |
|||
#define UNITY_MATERIAL_LIT // Need to be defined before including Material.hlsl |
|||
#include "../../../ShaderVariables.hlsl" |
|||
#include "../../../Lighting/Lighting.hlsl" // This includes Material.hlsl |
|||
|
|||
//-------------------------------------------------------------------------------------------------- |
|||
// Inputs & outputs |
|||
//-------------------------------------------------------------------------------------------------- |
|||
|
|||
TEXTURE2D(_DepthTexture); // Z-buffer |
|||
RW_TEXTURE2D(float4, _CameraColorTexture); // Updated texture |
|||
|
|||
//-------------------------------------------------------------------------------------------------- |
|||
// Implementation |
|||
//-------------------------------------------------------------------------------------------------- |
|||
|
|||
struct Ray |
|||
{ |
|||
float3 originWS; |
|||
float3 directionWS; // Normalized |
|||
float maxLength; // In meters |
|||
}; |
|||
|
|||
// Computes the in-scattered radiance along the ray. |
|||
float3 PerformIntegration(PositionInputs posInput, Ray ray, uint numSteps) |
|||
{ |
|||
float3 scattering = _GlobalFog_Scattering; |
|||
float extinction = _GlobalFog_Extinction; |
|||
float asymmetry = _GlobalFog_Asymmetry; |
|||
|
|||
LightLoopContext context; |
|||
// ZERO_INITIALIZE(LightLoopContext, context); |
|||
context.shadowContext = InitShadowContext(); |
|||
uint featureFlags = 0xFFFFFFFF; // TODO |
|||
|
|||
float maxDepthVS = posInput.depthVS; |
|||
|
|||
// Note: we are already using 'unPositionSS' for randomization of LODDitheringTransition(). |
|||
float zeta = GenerateHashedRandomFloat(posInput.unPositionSS.yx); |
|||
|
|||
float du = rcp(numSteps); |
|||
float u0 = 0.25 * du + 0.5 * du * zeta; |
|||
float dt = du * ray.maxLength; |
|||
|
|||
float3 radiance = 0; |
|||
|
|||
for (uint s = 0; s < numSteps; s++) |
|||
{ |
|||
float u = u0 + s * du; // [0, 1] |
|||
float t = u * ray.maxLength; // [0, ray.maxLength] |
|||
|
|||
float3 positionWS = ray.originWS + t * ray.directionWS; |
|||
|
|||
float3 sampleRadiance = 0; |
|||
|
|||
if (featureFlags & LIGHTFEATUREFLAGS_DIRECTIONAL) |
|||
{ |
|||
for (uint i = 0; i < _DirectionalLightCount; ++i) |
|||
{ |
|||
// Fetch the light. |
|||
DirectionalLightData lightData = _DirectionalLightDatas[i]; |
|||
|
|||
float3 L = -lightData.forward; // Lights point backwards in Unity |
|||
float intensity = 1; |
|||
float3 color = lightData.color; |
|||
|
|||
// Note: we apply the scattering coefficient and the constant part of the phase function later. |
|||
intensity *= HenyeyGreensteinPhasePartVarying(asymmetry, dot(L, ray.directionWS)); |
|||
|
|||
[branch] if (lightData.shadowIndex >= 0) |
|||
{ |
|||
float shadow = GetDirectionalShadowAttenuation(context.shadowContext, positionWS, |
|||
0, lightData.shadowIndex, L, posInput.unPositionSS); |
|||
|
|||
intensity *= shadow; |
|||
} |
|||
|
|||
[branch] if (lightData.cookieIndex >= 0) |
|||
{ |
|||
float3 lightToSample = positionWS - lightData.positionWS; |
|||
float4 cookie = EvaluateCookie_Directional(context, lightData, lightToSample); |
|||
|
|||
color *= cookie.rgb; |
|||
intensity *= cookie.a; |
|||
} |
|||
|
|||
// Compute the amount of in-scattered radiance. |
|||
sampleRadiance += color * intensity; |
|||
} |
|||
} |
|||
|
|||
if (featureFlags & LIGHTFEATUREFLAGS_PUNCTUAL) |
|||
{ |
|||
uint punctualLightCount; |
|||
|
|||
#ifdef LIGHTLOOP_TILE_PASS |
|||
uint punctualLightStart; |
|||
|
|||
posInput.depthVS = u * maxDepthVS; |
|||
GetCountAndStart(posInput, LIGHTCATEGORY_PUNCTUAL, punctualLightStart, punctualLightCount); |
|||
#else |
|||
punctualLightCount = _PunctualLightCount; |
|||
#endif |
|||
|
|||
for (uint i = 0; i < punctualLightCount; ++i) |
|||
{ |
|||
#ifdef LIGHTLOOP_TILE_PASS |
|||
uint punctualLightIndex = FetchIndex(punctualLightStart, i); |
|||
#else |
|||
uint punctualLightIndex = i; |
|||
#endif |
|||
|
|||
// Fetch the light. |
|||
LightData lightData = _LightDatas[punctualLightIndex]; |
|||
int lightType = lightData.lightType; |
|||
|
|||
float3 lightToSample = positionWS - lightData.positionWS; |
|||
float distSq = dot(lightToSample, lightToSample); |
|||
float dist = sqrt(distSq); |
|||
float3 L = lightToSample * -rsqrt(distSq); |
|||
float intensity = GetPunctualShapeAttenuation(lightData, L, distSq); |
|||
float3 color = lightData.color; |
|||
|
|||
// Note: we apply the scattering coefficient and the constant part of the phase function later. |
|||
intensity *= HenyeyGreensteinPhasePartVarying(asymmetry, dot(L, ray.directionWS)); |
|||
intensity *= Transmittance(OpticalDepthHomogeneous(extinction, dist)); |
|||
|
|||
[branch] if (lightData.shadowIndex >= 0) |
|||
{ |
|||
// TODO: make projector lights cast shadows. |
|||
float3 offset = 0; // GetShadowPosOffset(nDotL, normal); |
|||
|
|||
float shadow = GetPunctualShadowAttenuation(context.shadowContext, positionWS + offset, |
|||
0, lightData.shadowIndex, float4(L, dist), posInput.unPositionSS); |
|||
|
|||
intensity *= lerp(1, shadow, lightData.shadowDimmer); |
|||
} |
|||
|
|||
// Projector lights always have a cookies, so we can perform clipping inside the if(). |
|||
[branch] if (lightData.cookieIndex >= 0) |
|||
{ |
|||
float4 cookie = EvaluateCookie_Punctual(context, lightData, lightToSample); |
|||
|
|||
color *= cookie.rgb; |
|||
intensity *= cookie.a; |
|||
} |
|||
|
|||
// Compute the amount of in-scattered radiance. |
|||
sampleRadiance += color * intensity; |
|||
} |
|||
} |
|||
|
|||
radiance += sampleRadiance * (Transmittance(OpticalDepthHomogeneous(extinction, t)) * dt); |
|||
} |
|||
|
|||
float3 phaseConstant = scattering * HenyeyGreensteinPhasePartConstant(asymmetry); |
|||
return radiance * phaseConstant; |
|||
} |
|||
|
|||
[numthreads(GROUP_SIZE_2D, 1, 1)] |
|||
void VolumetricLighting(uint2 groupId : SV_GroupID, |
|||
uint groupThreadId : SV_GroupThreadID) |
|||
{ |
|||
// Note: any factor of 64 is a suitable wave size for our algorithm. |
|||
uint waveIndex = groupThreadId / 64; |
|||
uint laneIndex = groupThreadId % 64; |
|||
uint quadIndex = laneIndex / 4; |
|||
|
|||
// Arrange threads in the Morton order to optimally match the memory layout of GCN tiles. |
|||
uint mortonCode = groupThreadId; |
|||
uint2 localCoord = DecodeMorton2D(mortonCode); |
|||
uint2 tileAnchor = groupId * GROUP_SIZE_1D; |
|||
uint2 pixelCoord = tileAnchor + localCoord; |
|||
uint2 tileCoord = pixelCoord / GetTileSize(); |
|||
|
|||
if (pixelCoord.x >= (uint)_ScreenSize.x || pixelCoord.y >= (uint)_ScreenSize.y) { return; } |
|||
|
|||
// Idea: zenith angle based distance limiting to simulate aerial perspective? |
|||
#ifdef UNITY_REVERSED_Z |
|||
float z = max(LOAD_TEXTURE2D(_DepthTexture, pixelCoord).r, 0 + 0.001); |
|||
#else |
|||
float z = min(LOAD_TEXTURE2D(_DepthTexture, pixelCoord).r, 1 - 0.001); |
|||
#endif |
|||
|
|||
PositionInputs posInput = GetPositionInput(pixelCoord, _ScreenSize.zw, tileCoord); |
|||
UpdatePositionInput(z, _InvViewProjMatrix, _ViewProjMatrix, posInput); |
|||
|
|||
Ray cameraRay; |
|||
|
|||
// Note: the camera ray does not start on the the near (camera sensor) plane. |
|||
// While this is not correct (strictly speaking), the introduced error is small. |
|||
cameraRay.originWS = GetCurrentViewPosition(); |
|||
cameraRay.directionWS = posInput.positionWS - cameraRay.originWS; |
|||
cameraRay.maxLength = sqrt(dot(cameraRay.directionWS, cameraRay.directionWS)); |
|||
cameraRay.directionWS *= rsqrt(dot(cameraRay.directionWS, cameraRay.directionWS)); // Normalize |
|||
|
|||
float rayT = Transmittance(OpticalDepthHomogeneous(_GlobalFog_Extinction, cameraRay.maxLength)); |
|||
|
|||
const int numSamples = 64; |
|||
float3 inL = PerformIntegration(posInput, cameraRay, numSamples); |
|||
|
|||
// In-place UAV updates do not work on Intel GPUs. |
|||
_CameraColorTexture[pixelCoord] = float4(rayT * _CameraColorTexture[pixelCoord].rgb + inL, _CameraColorTexture[pixelCoord].a); |
|||
} |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 5918bc8b07f593546974c1961387db77 |
|||
timeCreated: 1501167559 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
撰写
预览
正在加载...
取消
保存
Reference in new issue