dal4segno/Northbound
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Flatkit 추가 및 설정

Browse Source
This commit is contained in:
dal4segno
2026-01-25 11:27:33 +09:00
parent 05233497e7
commit cf16910a32
1938 changed files with 408633 additions and 244 deletions
Download Patch File Download Diff File Expand all files Collapse all files

488
Assets/FlatKit/[Render Pipeline] URP/Water/Shaders/Water.shader Normal file
View File

@@ -0,0 +1,488 @@
Shader "FlatKit/Water"
{
Properties
{
[KeywordEnum(Linear, Gradient Texture)] _ColorMode ("[FOLDOUT(Colors){9}]Source{Colors}", Float) = 0.0
_ColorShallow ("[_COLORMODE_LINEAR]Shallow", Color) = (0.35, 0.6, 0.75, 0.8) // Color alpha controls opacity
_ColorDeep ("[_COLORMODE_LINEAR]Deep", Color) = (0.65, 0.9, 1.0, 1.0)
[NoScaleOffset] _ColorGradient("[_COLORMODE_GRADIENT_TEXTURE]Gradient", 2D) = "white" {}
_FadeDistance("Shallow Depth", Float) = 0.5
_WaterDepth("Gradient Size", Float) = 5.0
_LightContribution("Light Color Contribution", Range(0, 1)) = 0
_WaterClearness("Transparency", Range(0, 1)) = 0.3
_ShadowStrength("Shadow Strength", Range(0, 1)) = 0.35
_CrestColor("[FOLDOUT(Crest){3}]Color{Crest}", Color) = (1.0, 1.0, 1.0, 0.9)
_CrestSize("Size{Crest}", Range(0, 1)) = 0.1
_CrestSharpness("Sharp transition{Crest}", Range(0, 1)) = 0.1
[KeywordEnum(None, Round, Grid, Pointy)] _WaveMode ("[FOLDOUT(Wave Geometry){7}]Shape{Wave}", Float) = 1.0
_WaveSpeed("[!_WAVEMODE_NONE]Speed{Wave}", Float) = 0.5
_WaveAmplitude("[!_WAVEMODE_NONE]Amplitude{Wave}", Float) = 0.25
_WaveFrequency("[!_WAVEMODE_NONE]Frequency{Wave}", Float) = 1.0
_WaveDirection("[!_WAVEMODE_NONE]Direction{Wave}", Range(-1.0, 1.0)) = 0
[KeywordEnum(UV, World Space)] _NoiseSource ("Tiling Source{Wave}", Float) = 1.0
_WaveNoise("[!_WAVEMODE_NONE]Noise{Wave}", Range(0, 2)) = 0.25
[KeywordEnum(None, Gradient Noise, Texture)] _FoamMode ("[FOLDOUT(Foam){12}]Source{Foam}", Float) = 1.0
[NoScaleOffset] _NoiseMap("[_FOAMMODE_TEXTURE]Texture{Foam}", 2D) = "white" {}
_FoamColor("[!_FOAMMODE_NONE]Color{Foam}", Color) = (1, 1, 1, 1)
[Space]
_FoamDepth("[!_FOAMMODE_NONE]Shore Depth{Foam}", Float) = 0.5
_FoamNoiseAmount("[!_FOAMMODE_NONE]Shore Blending{Foam}", Range(0.0, 1.0)) = 1.0
[Space]
_FoamAmount("[!_FOAMMODE_NONE]Amount{Foam}", Range(0, 3)) = 0.25
[Space]
_FoamScale("[!_FOAMMODE_NONE]Scale{Foam}", Range(0, 3)) = 1
_FoamStretchX("[!_FOAMMODE_NONE]Stretch X{Foam}", Range(0, 10)) = 1
_FoamStretchY("[!_FOAMMODE_NONE]Stretch Y{Foam}", Range(0, 10)) = 1
[Space]
_FoamSharpness("[!_FOAMMODE_NONE]Sharpness{Foam}", Range(0, 1)) = 0.5
[Space]
_FoamSpeed("[!_FOAMMODE_NONE]Speed{Foam}", Float) = 0.1
_FoamDirection("[!_FOAMMODE_NONE]Direction{Foam}", Range(-1.0, 1.0)) = 0
_RefractionFrequency("[FOLDOUT(Refraction){4}]Frequency", Float) = 35
_RefractionAmplitude("Amplitude", Range(0, 0.1)) = 0.01
_RefractionSpeed("Speed", Float) = 0.1
_RefractionScale("Scale", Float) = 1
/*
_SpecularAmount("[FOLDOUT(Specular){2}]Amount{Specular}", Range(0, 1)) = 0.5
[HDR] _SpecularColor("Color{Specular}", Color) = (1, 1, 1, 1)
*/
[HideInInspector] [ToggleOff] _Opaque("Opaque", Float) = 0.0
[HideInInspector] _QueueOffset("Queue offset", Float) = 0.0
}
SubShader
{
Tags
{
"Queue" = "Transparent" "IgnoreProjector" = "True" "RenderType" = "Transparent"
}
LOD 200
Blend SrcAlpha OneMinusSrcAlpha
Lighting Off
ZWrite[_ZWrite]
HLSLINCLUDE
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Version.hlsl"
ENDHLSL
Pass
{
HLSLPROGRAM
// #define FLAT_KIT_DOTS_INSTANCING_ON // Uncomment to enable DOTS instancing
#pragma prefer_hlslcc gles
#if defined(FLAT_KIT_DOTS_INSTANCING_ON)
#pragma target 4.5
#pragma multi_compile _ DOTS_INSTANCING_ON
#else
#pragma target 2.0
#endif
#pragma shader_feature_local _COLORMODE_LINEAR _COLORMODE_GRADIENT_TEXTURE
#pragma shader_feature_local _FOAMMODE_NONE _FOAMMODE_GRADIENT_NOISE _FOAMMODE_TEXTURE
#pragma shader_feature_local _WAVEMODE_NONE _WAVEMODE_ROUND _WAVEMODE_GRID _WAVEMODE_POINTY
#pragma shader_feature_local __ _NOISESOURCE_WORLD_SPACE
// -------------------------------------
// Universal Pipeline keywords
#if VERSION_GREATER_EQUAL(11, 0)
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
#else
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
#endif
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
#pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
#pragma multi_compile _ SHADOWS_SHADOWMASK
#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
#pragma multi_compile_fragment _ _SHADOWS_SOFT
#pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
#if VERSION_GREATER_EQUAL(12, 0)
#pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
#pragma multi_compile_fragment _ _LIGHT_LAYERS
#pragma multi_compile_fragment _ _LIGHT_COOKIES
#endif
#if UNITY_VERSION >= 202220 && UNITY_VERSION < 600000
#pragma multi_compile _ _FORWARD_PLUS
#pragma multi_compile_fragment _ _WRITE_RENDERING_LAYERS
#endif
#if UNITY_VERSION >= 600000
#pragma multi_compile _ _FORWARD_PLUS
#include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl"
#include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"
#endif
// -------------------------------------
// Unity defined keywords
#pragma multi_compile _ DIRLIGHTMAP_COMBINED
#pragma multi_compile _ LIGHTMAP_ON
#pragma multi_compile_fog
#if UNITY_VERSION >= 202220
#pragma multi_compile _ DYNAMICLIGHTMAP_ON
#pragma multi_compile_fragment _ DEBUG_DISPLAY
#pragma multi_compile_fragment _ LOD_FADE_CROSSFADE
#endif
//--------------------------------------
// GPU Instancing
#pragma multi_compile_instancing
#pragma instancing_options renderinglayer
#pragma multi_compile _ DOTS_INSTANCING_ON
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/ShaderVariablesFunctions.hlsl"
#pragma vertex vert
#pragma fragment frag
#if defined(_COLORMODE_GRADIENT_TEXTURE)
TEXTURE2D(_ColorGradient);
SAMPLER(sampler_ColorGradient);
#endif
TEXTURE2D(_NoiseMap);
SAMPLER(sampler_NoiseMap);
CBUFFER_START(UnityPerMaterial)
float _FadeDistance, _WaterDepth;
half _LightContribution;
half _WaveFrequency, _WaveAmplitude, _WaveSpeed, _WaveDirection, _WaveNoise;
half _WaterClearness, _CrestSize, _CrestSharpness, _ShadowStrength;
half4 _CrestColor;
half4 _FoamColor;
half _FoamDepth, _FoamAmount, _FoamScale, _FoamSharpness, _FoamStretchX, _FoamStretchY, _FoamSpeed,
_FoamDirection, _FoamNoiseAmount, _RefractionFrequency, _RefractionAmplitude, _RefractionSpeed,
_RefractionScale, _FresnelAmount, _FresnelSharpness, _SunReflection;
/*
half _SpecularAmount;
half4 _SpecularColor;
*/
float4 _NoiseMap_ST;
// _COLORMODE_LINEAR:
half4 _ColorShallow, _ColorDeep;
// _COLORMODE_GRADIENT_TEXTURE:
float4 _ColorGradient_ST;
CBUFFER_END
struct VertexInput
{
float4 positionOS : POSITION;
float2 texcoord : TEXCOORD0;
float3 normalOS : NORMAL;
float4 tangentOS : TANGENT;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct VertexOutput
{
float4 positionHCS : SV_POSITION;
float3 positionWS : TEXCOORD6;
float2 uv : TEXCOORD0;
float4 screenPosition : TEXCOORD1;
float waveHeight : TEXCOORD2;
float3 normal : TEXCOORD3; // World space.
float3 viewDir : TEXCOORD4; // World space.
half fogFactor : TEXCOORD5;
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
float2 GradientNoise_Dir(float2 p)
{
// Permutation and hashing used in webgl-nosie goo.gl/pX7HtC
// 3d0a9085-1fec-441a-bba6-f1121cdbe3ba
p = p % 289;
float x = (34 * p.x + 1) * p.x % 289 + p.y;
x = (34 * x + 1) * x % 289;
x = frac(x / 41) * 2 - 1;
return normalize(float2(x - floor(x + 0.5), abs(x) - 0.5));
}
float GradientNoise(float2 UV, float Scale)
{
const float2 p = UV * Scale;
const float2 ip = floor(p);
float2 fp = frac(p);
const float d00 = dot(GradientNoise_Dir(ip), fp);
const float d01 = dot(GradientNoise_Dir(ip + float2(0, 1)), fp - float2(0, 1));
const float d10 = dot(GradientNoise_Dir(ip + float2(1, 0)), fp - float2(1, 0));
const float d11 = dot(GradientNoise_Dir(ip + float2(1, 1)), fp - float2(1, 1));
fp = fp * fp * fp * (fp * (fp * 6 - 15) + 10);
return lerp(lerp(d00, d01, fp.y), lerp(d10, d11, fp.y), fp.x) + 0.5;
}
inline float DepthFade(float2 uv, VertexOutput i)
{
const float is_ortho = unity_OrthoParams.w;
const float is_persp = 1.0 - unity_OrthoParams.w;
const float depth_packed = SampleSceneDepth(uv);
// Separately handles orthographic and perspective cameras.
const float scene_depth = lerp(_ProjectionParams.z, _ProjectionParams.y, depth_packed) * is_ortho +
LinearEyeDepth(SampleSceneDepth(uv), _ZBufferParams) * is_persp;
const float surface_depth = lerp(_ProjectionParams.z, _ProjectionParams.y, i.screenPosition.z) *
is_ortho + i.screenPosition.w * is_persp;
const float water_depth = scene_depth - surface_depth;
return saturate((water_depth - _FadeDistance) / _WaterDepth);
}
inline float SineWave(float3 pos, float offset)
{
return sin(
offset + _Time.z * _WaveSpeed + (pos.x * sin(offset + _WaveDirection * PI) + pos.z *
cos(offset + _WaveDirection * PI)) * _WaveFrequency);
}
inline float WaveHeight(float2 texcoord, float3 position)
{
float s = 0;
#if defined(_WAVEMODE_GRID)
#if defined(_NOISESOURCE_WORLD_SPACE)
float2 noise_uv = position.xz * _WaveFrequency;
#else // _NOISESOURCE_WORLD_SPACE
float2 noise_uv = texcoord * _WaveFrequency;
#endif // _NOISESOURCE_WORLD_SPACE
float noise01 = GradientNoise(noise_uv, 1.0);
float noise = (noise01 * 2.0 - 1.0) * _WaveNoise;
s = SineWave(position, noise);
#if defined(_WAVEMODE_GRID)
s *= SineWave(position, HALF_PI + noise);
#endif
#if defined(_WAVEMODE_POINTY)
s = 1.0 - abs(s);
#endif
#endif
return s;
}
inline void AdditionalLights(float3 WorldPosition, out half3 Color, out half Attenuation) {
Color = 0;
Attenuation = 0;
#ifdef _ADDITIONAL_LIGHTS
const half4 shadowMask = half4(1, 1, 1, 1);
const uint numAdditionalLights = GetAdditionalLightsCount();
for (uint lightI = 0; lightI < numAdditionalLights; lightI++) {
Light light = GetAdditionalLight(lightI, WorldPosition, shadowMask);
Color += light.color;
Attenuation += light.distanceAttenuation * light.shadowAttenuation;
}
Attenuation = saturate(Attenuation);
#endif
}
VertexOutput vert(VertexInput i)
{
#if defined(CURVEDWORLD_IS_INSTALLED) && !defined(CURVEDWORLD_DISABLED_ON)
#ifdef CURVEDWORLD_NORMAL_TRANSFORMATION_ON
CURVEDWORLD_TRANSFORM_VERTEX_AND_NORMAL(i.positionOS, i.normalOS, i.tangentOS)
#else
CURVEDWORLD_TRANSFORM_VERTEX(i.positionOS)
#endif
#endif
VertexOutput o = (VertexOutput)0;
UNITY_SETUP_INSTANCE_ID(i);
UNITY_TRANSFER_INSTANCE_ID(i, o);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
// Vertex animation.
const float3 originalPositionWS = TransformObjectToWorld(i.positionOS.xyz);
const float s = WaveHeight(i.texcoord, originalPositionWS);
o.waveHeight = s;
o.positionWS = originalPositionWS;
o.positionWS.y += s * _WaveAmplitude;
o.positionHCS = TransformWorldToHClip(o.positionWS);
o.screenPosition = ComputeScreenPos(o.positionHCS);
o.uv = i.texcoord;
{
// Normals.
const float3 viewDirWS = GetCameraPositionWS() - o.positionWS;
o.viewDir = viewDirWS;
const VertexNormalInputs normalInput = GetVertexNormalInputs(i.normalOS, i.tangentOS);
const float sample_distance = 0.01;
float3 pos_tangent = originalPositionWS + normalInput.tangentWS * sample_distance;
pos_tangent.y += WaveHeight(i.texcoord, pos_tangent) * _WaveAmplitude;
float3 pos_bitangent = originalPositionWS + normalInput.bitangentWS * sample_distance;
pos_bitangent.y += WaveHeight(i.texcoord, pos_bitangent) * _WaveAmplitude;
const float3 modified_tangent = pos_tangent - o.positionWS;
const float3 modified_bitangent = pos_bitangent - o.positionWS;
const float3 modified_normal = cross(modified_tangent, modified_bitangent);
o.normal = normalize(modified_normal);
}
const half fogFactor = ComputeFogFactor(o.positionHCS.z);
o.fogFactor = fogFactor;
return o;
}
half4 frag(VertexOutput i) : SV_TARGET
{
UNITY_SETUP_INSTANCE_ID(i);
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
// Refraction.
const float2 noise_uv_refraction = i.uv * _RefractionFrequency + _Time.zz * _RefractionSpeed;
const float noise01_refraction = GradientNoise(noise_uv_refraction, _RefractionScale);
const float noise11_refraction = noise01_refraction * 2.0f - 1.0f;
const float2 screen_uv = i.screenPosition.xy / i.screenPosition.w;
const float depth_fade_original = DepthFade(screen_uv, i);
float2 displaced_uv = screen_uv + noise11_refraction * _RefractionAmplitude * depth_fade_original;
float depth_fade = DepthFade(displaced_uv, i);
if (depth_fade <= 0.0f) // If above water surface.
{
displaced_uv = screen_uv;
depth_fade = DepthFade(displaced_uv, i);
}
const half3 scene_color = SampleSceneColor(displaced_uv);
half3 c = scene_color;
// Water depth.
half4 depth_color;
half4 color_shallow;
#if defined(_COLORMODE_LINEAR)
depth_color = lerp(_ColorShallow, _ColorDeep, depth_fade);
color_shallow = _ColorShallow;
#endif
#if defined(_COLORMODE_GRADIENT_TEXTURE)
float2 gradient_uv = float2(depth_fade, 0.5f);
depth_color = SAMPLE_TEXTURE2D(_ColorGradient, sampler_ColorGradient, gradient_uv);
color_shallow = SAMPLE_TEXTURE2D(_ColorGradient, sampler_ColorGradient, float2(0.0f, 0.5f));
#endif
c = lerp(depth_color.rgb, c, _WaterClearness * depth_color.a);
// Crest.
{
const half c_inv = 1.0f - _CrestSize;
c = lerp(c, _CrestColor.rgb,
smoothstep(c_inv, saturate(c_inv + (1.0f - _CrestSharpness)),
i.waveHeight) * _CrestColor.a);
}
// Foam.
#if !defined(_FOAMMODE_NONE)
float2 stretch_factor = float2(_FoamStretchX, _FoamStretchY);
float noise_foam_base;
#if defined(_FOAMMODE_TEXTURE)
const float2 rotated_uv = i.uv * cos(_FoamDirection * PI) +
float2(i.uv.y, -i.uv.x) * sin(_FoamDirection * PI);
const float2 noise_uv_foam = rotated_uv * 100.0f + _Time.zz * _FoamSpeed;
noise_foam_base = SAMPLE_TEXTURE2D(_NoiseMap, sampler_NoiseMap,
noise_uv_foam * stretch_factor / (_FoamScale * 100.0)).r;
#endif
#if defined(_FOAMMODE_GRADIENT_NOISE)
// This rotation is not exactly correct, but we're keeping it for backwards compatibility.
const float uv_angle = atan2(i.uv.y, i.uv.x);
const float cs = cos(uv_angle + _FoamDirection * PI);
const float sn = sin(uv_angle + _FoamDirection * PI);
const float2 rotated_uv = float2(i.uv.x * cs - i.uv.y * sn, i.uv.x * sn + i.uv.y * cs);
const float2 noise_uv_foam = rotated_uv * 100.0f + _Time.zz * _FoamSpeed;
noise_foam_base = GradientNoise(noise_uv_foam * stretch_factor, _FoamScale);
#endif
float foam_blur = 1.0 - _FoamSharpness + 1e-6;
float shore_fade = saturate(depth_fade / _FoamDepth);
float hard_foam_end = 0.1;
float soft_foam_end = hard_foam_end + foam_blur * 0.3;
float foam_shore = smoothstep(0.5 - foam_blur * 0.5, 0.5 + foam_blur * 0.5, noise_foam_base);
foam_shore = saturate(smoothstep(soft_foam_end, hard_foam_end, shore_fade) +
smoothstep(1, soft_foam_end, shore_fade) * foam_shore * _FoamNoiseAmount);
float foam_surface = smoothstep(noise_foam_base, noise_foam_base + foam_blur, _FoamAmount);
foam_surface = smoothstep(0.5 - foam_blur * 0.5, 0.5 + foam_blur * 0.5, foam_surface);
float foam = saturate(foam_shore + foam_surface);
c = lerp(c, _FoamColor.rgb, foam * _FoamColor.a);
#endif
// Shadows.
#ifndef _MAIN_LIGHT_SHADOWS
#define _MAIN_LIGHT_SHADOWS // Since URP 13 or 14 this is not defined by default.
#endif
#if defined(_MAIN_LIGHT_SHADOWS)
VertexPositionInputs vertexInput = (VertexPositionInputs)0;
vertexInput.positionWS = i.positionWS.xyz;
float4 shadowCoord = GetShadowCoord(vertexInput);
half shadowAttenutation = MainLightRealtimeShadow(shadowCoord);
c = lerp(c, c * color_shallow.rgb, _ShadowStrength * (1.0h - shadowAttenutation));
#endif
/*
// Specular.
{
const float3 viewDirWS = normalize(i.viewDir);
const float3 normalWS = normalize(i.normal);
const float3 lightDirWS = -GetMainLight().direction;
const float3 halfDirWS = normalize(viewDirWS + lightDirWS);
const float specular = pow(saturate(dot(normalWS, halfDirWS)), 1.0f);
c = lerp(c, c * _SpecularColor.rgb, specular * _SpecularAmount);
}
*/
c *= lerp(half3(1, 1, 1), _MainLightColor.rgb, _LightContribution);
#if defined(_ADDITIONAL_LIGHTS)
half3 lightColor;
half lightAttenuation;
AdditionalLights(i.positionWS, lightColor, lightAttenuation);
lightColor = lerp(half3(1, 1, 1), lightColor, _LightContribution);
c += lightColor * lightAttenuation;
#if !defined(_FOAMMODE_NONE)
c = lerp(c, _FoamColor.rgb * lightColor, foam * _FoamColor.a * lightAttenuation);
#endif
#endif
c = MixFog(c, i.fogFactor);
return half4(c, 1);
}
ENDHLSL
}
}
CustomEditor "FlatKitWaterEditor"
}