[Add] Synaptic AI Pro

https://assetstore.unity.com/packages/tools/generative-ai/synaptic-ai-pro-natural-language-control-for-unity-336030

Assets/Synaptic AI Pro/Shaders/Water/SynapticWater.shader

@@ -0,0 +1,406 @@
+Shader "Synaptic/Water"
+{
+    Properties
+    {
+        [Header(Water Color)]
+        _ShallowColor ("Shallow Color", Color) = (0.3, 0.8, 0.9, 0.6)
+        _DeepColor ("Deep Color", Color) = (0.1, 0.3, 0.5, 0.9)
+        _DepthMaxDistance ("Depth Max Distance", Float) = 5.0
+
+        [Header(Waves)]
+        _WaveSpeed ("Wave Speed", Float) = 1.0
+        _WaveStrength ("Wave Strength", Float) = 0.1
+        _WaveFrequency ("Wave Frequency", Float) = 1.0
+        _WaveDirectionA ("Wave Direction A", Vector) = (1, 0, 0, 0)
+        _WaveDirectionB ("Wave Direction B", Vector) = (0, 0, 1, 0)
+
+        [Header(Normal Map)]
+        _NormalMap ("Normal Map", 2D) = "bump" {}
+        _NormalStrength ("Normal Strength", Range(0, 2)) = 1.0
+        _NormalSpeed ("Normal Speed", Float) = 0.5
+        _NormalScale ("Normal Scale", Float) = 1.0
+
+        [Header(Reflection and Refraction)]
+        _ReflectionStrength ("Reflection Strength", Range(0, 1)) = 0.5
+        _RefractionStrength ("Refraction Strength", Range(0, 0.5)) = 0.1
+        _FresnelPower ("Fresnel Power", Range(0.5, 10)) = 5.0
+
+        [Header(Foam)]
+        _FoamColor ("Foam Color", Color) = (1, 1, 1, 1)
+        _FoamDistance ("Foam Distance", Float) = 0.5
+        _FoamCutoff ("Foam Cutoff", Range(0, 1)) = 0.5
+        _FoamSpeed ("Foam Speed", Float) = 1.0
+        _FoamScale ("Foam Scale", Float) = 10.0
+
+        [Header(Specular)]
+        _SpecularColor ("Specular Color", Color) = (1, 1, 1, 1)
+        _Smoothness ("Smoothness", Range(0, 1)) = 0.9
+    }
+
+    SubShader
+    {
+        PackageRequirements { "com.unity.render-pipelines.universal" }
+        Tags
+        {
+            "RenderType" = "Transparent"
+            "Queue" = "Transparent"
+            "RenderPipeline" = "UniversalPipeline"
+        }
+
+        Pass
+        {
+            Name "WaterURP"
+            Tags { "LightMode" = "UniversalForward" }
+
+            Blend SrcAlpha OneMinusSrcAlpha
+            ZWrite Off
+            Cull Back
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma multi_compile_fog
+            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareOpaqueTexture.hlsl"
+
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float3 normalOS : NORMAL;
+                float4 tangentOS : TANGENT;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 uv : TEXCOORD0;
+                float3 worldPos : TEXCOORD1;
+                float3 worldNormal : TEXCOORD2;
+                float3 worldTangent : TEXCOORD3;
+                float3 worldBitangent : TEXCOORD4;
+                float4 screenPos : TEXCOORD5;
+                float3 viewDir : TEXCOORD6;
+                float fogFactor : TEXCOORD7;
+            };
+
+            TEXTURE2D(_NormalMap);
+            SAMPLER(sampler_NormalMap);
+
+            CBUFFER_START(UnityPerMaterial)
+                float4 _ShallowColor;
+                float4 _DeepColor;
+                float _DepthMaxDistance;
+
+                float _WaveSpeed;
+                float _WaveStrength;
+                float _WaveFrequency;
+                float4 _WaveDirectionA;
+                float4 _WaveDirectionB;
+
+                float4 _NormalMap_ST;
+                float _NormalStrength;
+                float _NormalSpeed;
+                float _NormalScale;
+
+                float _ReflectionStrength;
+                float _RefractionStrength;
+                float _FresnelPower;
+
+                float4 _FoamColor;
+                float _FoamDistance;
+                float _FoamCutoff;
+                float _FoamSpeed;
+                float _FoamScale;
+
+                float4 _SpecularColor;
+                float _Smoothness;
+            CBUFFER_END
+
+            // Gerstner wave function
+            float3 GerstnerWave(float3 position, float2 direction, float steepness, float wavelength, float time)
+            {
+                float k = 2.0 * PI / wavelength;
+                float c = sqrt(9.8 / k);
+                float2 d = normalize(direction);
+                float f = k * (dot(d, position.xz) - c * time);
+                float a = steepness / k;
+
+                return float3(
+                    d.x * a * cos(f),
+                    a * sin(f),
+                    d.y * a * cos(f)
+                );
+            }
+
+            Varyings vert(Attributes IN)
+            {
+                Varyings OUT;
+
+                float3 posOS = IN.positionOS.xyz;
+                float time = _Time.y * _WaveSpeed;
+
+                // Apply Gerstner waves
+                float3 wave1 = GerstnerWave(posOS, _WaveDirectionA.xy, _WaveStrength, _WaveFrequency * 10.0, time);
+                float3 wave2 = GerstnerWave(posOS, _WaveDirectionB.xy, _WaveStrength * 0.5, _WaveFrequency * 7.0, time * 1.3);
+                float3 wave3 = GerstnerWave(posOS, float2(0.7, 0.7), _WaveStrength * 0.3, _WaveFrequency * 5.0, time * 0.8);
+
+                posOS += wave1 + wave2 + wave3;
+
+                OUT.worldPos = TransformObjectToWorld(posOS);
+                OUT.positionCS = TransformWorldToHClip(OUT.worldPos);
+                OUT.uv = IN.uv;
+                OUT.screenPos = ComputeScreenPos(OUT.positionCS);
+
+                // Calculate wave normal
+                float3 tangent = float3(1, 0, 0);
+                float3 bitangent = float3(0, 0, 1);
+
+                // Approximate normal from wave derivatives
+                float delta = 0.1;
+                float3 p1 = posOS + GerstnerWave(posOS + float3(delta, 0, 0), _WaveDirectionA.xy, _WaveStrength, _WaveFrequency * 10.0, time);
+                float3 p2 = posOS + GerstnerWave(posOS + float3(0, 0, delta), _WaveDirectionA.xy, _WaveStrength, _WaveFrequency * 10.0, time);
+
+                tangent = normalize(p1 - posOS);
+                bitangent = normalize(p2 - posOS);
+                float3 waveNormal = normalize(cross(bitangent, tangent));
+
+                OUT.worldNormal = TransformObjectToWorldNormal(waveNormal);
+                OUT.worldTangent = TransformObjectToWorldDir(IN.tangentOS.xyz);
+                OUT.worldBitangent = cross(OUT.worldNormal, OUT.worldTangent) * IN.tangentOS.w;
+
+                OUT.viewDir = GetWorldSpaceViewDir(OUT.worldPos);
+                OUT.fogFactor = ComputeFogFactor(OUT.positionCS.z);
+
+                return OUT;
+            }
+
+            // Simple noise for foam
+            float SimpleNoise(float2 uv)
+            {
+                return frac(sin(dot(uv, float2(12.9898, 78.233))) * 43758.5453);
+            }
+
+            float4 frag(Varyings IN) : SV_Target
+            {
+                float time = _Time.y;
+
+                // Sample normal map (dual layer for movement)
+                float2 normalUV1 = IN.worldPos.xz * _NormalScale + time * _NormalSpeed * float2(0.5, 0.3);
+                float2 normalUV2 = IN.worldPos.xz * _NormalScale * 0.8 - time * _NormalSpeed * float2(0.3, 0.5);
+
+                float3 normalTex1 = UnpackNormalScale(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, normalUV1), _NormalStrength);
+                float3 normalTex2 = UnpackNormalScale(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, normalUV2), _NormalStrength);
+                float3 normalTS = normalize(normalTex1 + normalTex2);
+
+                // Transform normal to world space
+                float3x3 TBN = float3x3(IN.worldTangent, IN.worldBitangent, IN.worldNormal);
+                float3 worldNormal = normalize(mul(normalTS, TBN));
+
+                // Screen UV
+                float2 screenUV = IN.screenPos.xy / IN.screenPos.w;
+
+                // Depth-based color
+                float depth = SampleSceneDepth(screenUV);
+                float linearDepth = LinearEyeDepth(depth, _ZBufferParams);
+                float surfaceDepth = LinearEyeDepth(IN.positionCS.z, _ZBufferParams);
+                float depthDifference = linearDepth - surfaceDepth;
+                float depthFactor = saturate(depthDifference / _DepthMaxDistance);
+
+                float4 waterColor = lerp(_ShallowColor, _DeepColor, depthFactor);
+
+                // Refraction
+                float2 refractionOffset = worldNormal.xz * _RefractionStrength;
+                float2 refractionUV = screenUV + refractionOffset;
+                float3 refractionColor = SampleSceneColor(refractionUV);
+
+                // Fresnel
+                float3 viewDir = normalize(IN.viewDir);
+                float fresnel = pow(1.0 - saturate(dot(viewDir, worldNormal)), _FresnelPower);
+
+                // Reflection (simple sky reflection approximation)
+                float3 reflectDir = reflect(-viewDir, worldNormal);
+                float3 reflectionColor = lerp(float3(0.5, 0.7, 0.9), float3(0.8, 0.9, 1.0), reflectDir.y * 0.5 + 0.5);
+
+                // Lighting
+                Light mainLight = GetMainLight();
+                float3 lightDir = mainLight.direction;
+
+                // Specular (GGX approximation)
+                float3 halfDir = normalize(lightDir + viewDir);
+                float NdotH = saturate(dot(worldNormal, halfDir));
+                float specular = pow(NdotH, _Smoothness * 256.0) * _Smoothness;
+                float3 specularColor = _SpecularColor.rgb * specular * mainLight.color;
+
+                // Foam
+                float foam = 0.0;
+                if (depthDifference < _FoamDistance)
+                {
+                    float foamNoise = SimpleNoise(IN.worldPos.xz * _FoamScale + time * _FoamSpeed);
+                    float foamFactor = 1.0 - saturate(depthDifference / _FoamDistance);
+                    foam = step(_FoamCutoff, foamNoise * foamFactor);
+                }
+
+                // Combine
+                float3 finalColor = lerp(refractionColor, waterColor.rgb, waterColor.a);
+                finalColor = lerp(finalColor, reflectionColor, fresnel * _ReflectionStrength);
+                finalColor += specularColor;
+                finalColor = lerp(finalColor, _FoamColor.rgb, foam);
+
+                // Apply fog
+                finalColor = MixFog(finalColor, IN.fogFactor);
+
+                float alpha = saturate(waterColor.a + fresnel * 0.3 + foam);
+
+                return float4(finalColor, alpha);
+            }
+            ENDHLSL
+        }
+    }
+
+    // Built-in Render Pipeline fallback
+    SubShader
+    {
+        Tags
+        {
+            "RenderType" = "Transparent"
+            "Queue" = "Transparent"
+        }
+
+        Pass
+        {
+            Name "WaterBuiltIn"
+
+            Blend SrcAlpha OneMinusSrcAlpha
+            ZWrite Off
+            Cull Back
+
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma multi_compile_fog
+
+            #include "UnityCG.cginc"
+            #include "Lighting.cginc"
+
+            struct appdata
+            {
+                float4 vertex : POSITION;
+                float3 normal : NORMAL;
+                float4 tangent : TANGENT;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct v2f
+            {
+                float4 pos : SV_POSITION;
+                float2 uv : TEXCOORD0;
+                float3 worldPos : TEXCOORD1;
+                float3 worldNormal : TEXCOORD2;
+                float3 viewDir : TEXCOORD3;
+                UNITY_FOG_COORDS(4)
+            };
+
+            sampler2D _NormalMap;
+            float4 _NormalMap_ST;
+
+            float4 _ShallowColor;
+            float4 _DeepColor;
+            float _WaveSpeed;
+            float _WaveStrength;
+            float _WaveFrequency;
+            float4 _WaveDirectionA;
+            float4 _WaveDirectionB;
+            float _NormalStrength;
+            float _NormalSpeed;
+            float _NormalScale;
+            float _FresnelPower;
+            float4 _SpecularColor;
+            float _Smoothness;
+            float4 _FoamColor;
+
+            // Gerstner wave
+            float3 GerstnerWave(float3 position, float2 direction, float steepness, float wavelength, float time)
+            {
+                float k = 2.0 * UNITY_PI / wavelength;
+                float c = sqrt(9.8 / k);
+                float2 d = normalize(direction);
+                float f = k * (dot(d, position.xz) - c * time);
+                float a = steepness / k;
+
+                return float3(
+                    d.x * a * cos(f),
+                    a * sin(f),
+                    d.y * a * cos(f)
+                );
+            }
+
+            v2f vert(appdata v)
+            {
+                v2f o;
+
+                float3 posOS = v.vertex.xyz;
+                float time = _Time.y * _WaveSpeed;
+
+                // Apply waves
+                float3 wave1 = GerstnerWave(posOS, _WaveDirectionA.xy, _WaveStrength, _WaveFrequency * 10.0, time);
+                float3 wave2 = GerstnerWave(posOS, _WaveDirectionB.xy, _WaveStrength * 0.5, _WaveFrequency * 7.0, time * 1.3);
+                posOS += wave1 + wave2;
+
+                o.worldPos = mul(unity_ObjectToWorld, float4(posOS, 1.0)).xyz;
+                o.pos = UnityObjectToClipPos(float4(posOS, 1.0));
+                o.uv = v.uv;
+                o.worldNormal = UnityObjectToWorldNormal(v.normal);
+                o.viewDir = normalize(_WorldSpaceCameraPos - o.worldPos);
+
+                UNITY_TRANSFER_FOG(o, o.pos);
+                return o;
+            }
+
+            fixed4 frag(v2f i) : SV_Target
+            {
+                float time = _Time.y;
+
+                // Normal map
+                float2 normalUV1 = i.worldPos.xz * _NormalScale + time * _NormalSpeed * float2(0.5, 0.3);
+                float2 normalUV2 = i.worldPos.xz * _NormalScale * 0.8 - time * _NormalSpeed * float2(0.3, 0.5);
+
+                float3 normal1 = UnpackNormal(tex2D(_NormalMap, normalUV1));
+                float3 normal2 = UnpackNormal(tex2D(_NormalMap, normalUV2));
+                float3 worldNormal = normalize(i.worldNormal + (normal1 + normal2) * _NormalStrength);
+
+                // Fresnel
+                float fresnel = pow(1.0 - saturate(dot(i.viewDir, worldNormal)), _FresnelPower);
+
+                // Base color
+                float4 waterColor = lerp(_ShallowColor, _DeepColor, fresnel);
+
+                // Specular
+                float3 lightDir = normalize(_WorldSpaceLightPos0.xyz);
+                float3 halfDir = normalize(lightDir + i.viewDir);
+                float spec = pow(saturate(dot(worldNormal, halfDir)), _Smoothness * 256.0);
+                float3 specular = _SpecularColor.rgb * spec * _LightColor0.rgb;
+
+                // Reflection approximation
+                float3 reflectColor = lerp(float3(0.5, 0.7, 0.9), float3(0.8, 0.9, 1.0), worldNormal.y * 0.5 + 0.5);
+
+                // Combine
+                float3 finalColor = waterColor.rgb;
+                finalColor = lerp(finalColor, reflectColor, fresnel * 0.5);
+                finalColor += specular;
+
+                UNITY_APPLY_FOG(i.fogCoord, finalColor);
+
+                return float4(finalColor, waterColor.a);
+            }
+            ENDCG
+        }
+    }
+
+    FallBack "Transparent/Diffuse"
+}

Assets/Synaptic AI Pro/Shaders/Water/SynapticWater.shader.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cb968a929f0b345cbb686b20d5f91a05
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 336030
+  packageName: Synaptic AI Pro - Natural Language Control for Unity
+  packageVersion: 1.2.23
+  assetPath: Assets/Synaptic AI Pro/Shaders/Water/SynapticWater.shader
+  uploadId: 920982

Assets/Synaptic AI Pro/Shaders/Water/SynapticWaterPro.shader.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 1310fcc8eeee9473aab068335ceacef6
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 336030
+  packageName: Synaptic AI Pro - Natural Language Control for Unity
+  packageVersion: 1.2.23
+  assetPath: Assets/Synaptic AI Pro/Shaders/Water/SynapticWaterPro.shader
+  uploadId: 920982