mobile-ai-agents 1.0.23

package/agents/react-native/performance-optimizer/example-input.md

@@ -0,0 +1,104 @@
+# Example Input — RN Performance Optimizer
+
+The `FeedScreen` below contains four intentional performance issues.
+
+---
+
+```
+RN_VERSION: 0.76
+ARCH: new
+FILE_PATH: src/screens/FeedScreen.tsx
+CODE:
+import React, { useState, useEffect, useContext } from 'react';
+import { FlatList, View, Text, TouchableOpacity, StyleSheet } from 'react-native';
+
+interface Post { id: string; title: string; body: string; liked: boolean; }
+const ThemeContext = React.createContext({ colors: { background: '#ffffff' } });
+
+const PostCard = ({ post, onLike, style }: { post: Post; onLike: () => void; style: object }) => (
+  <View style={[styles.card, style]}>
+    <Text style={styles.title}>{post.title}</Text>
+    <Text style={styles.body}>{post.body}</Text>
+    <TouchableOpacity onPress={onLike}>
+      <Text>{post.liked ? '❤️' : '🤍'} Like</Text>
+    </TouchableOpacity>
+  </View>
+);
+
+const fetchPosts = async (): Promise<Post[]> => [
+  { id: '1', title: 'Hello', body: 'First post', liked: false },
+  { id: '2', title: 'Second', body: 'Second post', liked: false },
+];
+const handleLike = (id: string) => console.log('Liked:', id);
+
+const FeedScreen = () => {
+  const [posts, setPosts] = useState<Post[]>([]);
+  const theme = useContext(ThemeContext);
+
+  useEffect(() => { fetchPosts().then(setPosts); }, []);
+
+  const renderItem = ({ item }: { item: Post }) => (
+    <PostCard
+      post={item}
+      onLike={() => handleLike(item.id)}
+      style={{ backgroundColor: theme.colors.background }}
+    />
+  );
+
+  return (
+    <FlatList
+      data={posts}
+      renderItem={renderItem}
+      keyExtractor={(item) => item.id}
+    />
+  );
+};
+
+const styles = StyleSheet.create({
+  card: { padding: 16, marginVertical: 8, borderRadius: 8 },
+  title: { fontSize: 16, fontWeight: 'bold' },
+  body:  { fontSize: 14, color: '#666' },
+});
+export default FeedScreen;
+```
+
+---
+
+## Issue Map
+
+1. `renderItem` is an inline function — recreated every `FeedScreen` re-render (HIGH)
+2. `{ backgroundColor: theme.colors.background }` is a new object every `renderItem` call (HIGH)
+3. `onLike={() => handleLike(item.id)}` inline per cell — breaks `PostCard` memoization (MEDIUM)
+4. `FlatList` missing `getItemLayout` — extra layout pass on every scroll (LOW)
+
+---
+
+## Variations
+
+### With Profiler Data
+```
+RN_VERSION: 0.74
+ARCH: old
+FILE_PATH: src/screens/ProductListScreen.tsx
+PROFILER_DATA:
+Component "ProductListScreen" rendered 24 times in 3 seconds.
+Component "ProductCard" rendered 480 times — 20 per ProductListScreen render.
+Longest render: 18ms (exceeded 16.6ms frame budget).
+CODE:
+[paste component]
+```
+
+### FlatList with Pagination
+```
+RN_VERSION: 0.76
+ARCH: new
+FILE_PATH: src/screens/OrderHistoryScreen.tsx
+CODE:
+<FlatList
+  data={orders}
+  renderItem={({ item }) => <OrderCard key={item.id} order={item} onPress={() => navigate(item.id)} />}
+  onEndReached={() => loadMore()}
+  onEndReachedThreshold={0.5}
+/>
+```
+Issues: `renderItem` inline, `onPress` inline per card, missing `keyExtractor`, missing `getItemLayout`, `onEndReached` threshold too aggressive for a paginated list.

package/agents/react-native/performance-optimizer/example-output.md

@@ -0,0 +1,132 @@
+# Example Output — RN Performance Optimizer
+
+Full agent response to the input in [`example-input.md`](example-input.md).
+
+---
+
+```
+PERFORMANCE AUDIT
+=================
+File: src/screens/FeedScreen.tsx
+Component: FeedScreen
+Architecture: New Architecture (JSI/Fabric)
+Issues Found: 4
+High Impact: 2  Medium Impact: 1  Low Impact: 1
+
+FINDINGS (ranked by impact)
+---------------------------
+
+[HIGH] renderItem recreated on every parent render
+  Impact      : Every state change in FeedScreen recreates renderItem, which gives FlatList
+                a new function reference. FlatList uses referential equality to bail out of
+                re-renders. A new reference on every render forces ALL visible PostCards
+                (typically 10–20 on screen) to re-render — even when the posts data hasn't changed.
+  Problem     : renderItem is an arrow function defined in the component body.
+                Arrow functions are never referentially stable across renders.
+  Refactored  :
+  ```tsx
+  const cardStyle = useMemo(
+    () => ({ backgroundColor: theme.colors.background }),
+    [theme.colors.background]
+  );
+
+  const renderItem = useCallback(
+    ({ item }: { item: Post }) => (
+      <PostCard
+        post={item}
+        onLike={() => handleLike(item.id)}  // see MEDIUM finding below
+        style={cardStyle}
+      />
+    ),
+    [cardStyle]
+  );
+  ```
+
+[HIGH] Inline style object — new object reference every renderItem call
+  Impact      : { backgroundColor: theme.colors.background } is a new object on every call.
+                Even with renderItem memoized, if cardStyle is inline, PostCard's style prop
+                changes on every render — defeating React.memo on PostCard (if applied).
+  Problem     : Objects created in JSX are never referentially equal between renders.
+  Refactored  :
+  ```tsx
+  const cardStyle = useMemo(
+    () => ({ backgroundColor: theme.colors.background }),
+    [theme.colors.background]
+  );
+  // Pass cardStyle (stable reference) to renderItem above
+  ```
+
+[MEDIUM] onLike inline closure captures item.id per cell
+  Impact      : () => handleLike(item.id) is a new function per item per render.
+                If PostCard is wrapped in React.memo, it still re-renders when its onLike
+                prop changes reference. With 20 items, that's 20 new function references
+                on every FeedScreen render.
+  Problem     : The item.id needs to reach handleLike, but the way to do it matters.
+  Refactored  :
+  ```tsx
+  // Pattern A: pass id as a stable prop, call handleLike inside PostCard
+  // PostCard receives: onLike: (id: string) => void; id: string
+  // Inside PostCard: <TouchableOpacity onPress={() => onLike(id)}>
+  // In FeedScreen: pass onLike={handleLike} — same stable reference every render
+
+  // Pattern B (simpler): wrap handleLike in useCallback
+  const stableHandleLike = useCallback((id: string) => handleLike(id), []);
+  // Then each cell still creates () => stableHandleLike(item.id), but the outer
+  // reference is stable — combine with Pattern A for best results.
+  ```
+
+[LOW] FlatList missing getItemLayout
+  Impact      : Without getItemLayout, FlatList cannot pre-calculate item positions.
+                This causes extra layout measurements on initial mount and when
+                scrollToIndex is called. With variable-height items it is unavoidable,
+                but if PostCard has a fixed height, this is a free optimization.
+  Problem     : FlatList must measure every rendered item to know total scroll height.
+  Refactored  :
+  ```tsx
+  const ITEM_HEIGHT = 88; // measure your PostCard — padding 16 + title 24 + body 20 + like 20 + margin 8
+  <FlatList
+    data={posts}
+    renderItem={renderItem}
+    keyExtractor={(item) => item.id}
+    getItemLayout={(_, index) => ({
+      length: ITEM_HEIGHT,
+      offset: ITEM_HEIGHT * index,
+      index,
+    })}
+  />
+  ```
+
+BRIDGE / JSI OVERHEAD
+---------------------
+Synchronous bridge calls detected: No
+  → No NativeModules calls detected in the render or event paths.
+
+ANIMATION SAFETY
+----------------
+Animations running on JS thread: No
+  → No Animated API usage detected in this file.
+
+FLATLIST / FLASHLIST AUDIT
+--------------------------
+Issues found: 2
+  → keyExtractor returns item.id — correct and stable. ✓
+  → getItemLayout missing — see LOW finding above.
+  → Consider FlashList (Shopify) for lists with 50+ posts — better recycling
+    and memory usage on New Architecture.
+
+ESTIMATED IMPROVEMENT
+---------------------
+Before: ~10–20 PostCard re-renders per FeedScreen state change
+After : ~0 PostCard re-renders for unrelated FeedScreen state changes
+Expected FPS gain: Sustained 60 FPS during scroll on mid-range devices (vs. potential
+                   drops on lower-end Android without the fixes).
+
+RECOMMENDED PROFILING STEPS
+----------------------------
+1. Open React DevTools → Profiler → Enable "Record why each component rendered"
+2. Scroll the feed, toggle a like — record 5 seconds
+3. Look for "Props changed" on PostCard — confirm it stops appearing for items
+   that weren't liked after applying useCallback + useMemo
+4. Enable "Highlight updates" in React DevTools to visually confirm only
+   newly loaded or liked posts cause a highlight during scroll
+```

package/agents/unity/shader-generator/README.md

@@ -0,0 +1,77 @@
+# Unity Shader Generator Agent
+
+> Describe a visual effect in plain English. Get a complete, compilable Unity `.shader` file — for URP, HDRP, or Built-in — with a Properties block, vertex/fragment stages, and a material setup guide.
+
+---
+
+## What This Agent Does
+
+Generates a complete Unity ShaderLab `.shader` file from a visual description:
+
+- Selects the correct render pipeline (URP: `HLSLPROGRAM` + URP includes; Built-in: `CGPROGRAM` + `UnityCG.cginc`; HDRP: HDRP ShaderLibrary)
+- Exposes all tweakable values as Material `Properties`
+- Applies mobile optimization rules when `TARGET: mobile` is specified (≤2 texture samples per fragment, `half` precision, no dynamic branching)
+- Uses `_Time.y` for time-based animation — never C# `Time.deltaTime`
+- Provides a step-by-step **Material Setup** guide for the Inspector
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| [`agent.md`](agent.md) | Input format, output format, full system prompt |
+| [`example-input.md`](example-input.md) | Holographic scanline effect description |
+| [`example-output.md`](example-output.md) | Complete URP `.shader` file |
+
+---
+
+## Quick Start
+
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: unlit
+TARGET_PLATFORM: mobile
+DESCRIPTION:
+[describe the visual effect]
+```
+
+---
+
+## Output Format
+
+````
+SHADER: <Name>
+FILE: <Shaders/Name.shader>
+RENDER_PIPELINE: <pipeline>
+MOBILE_FRIENDLY: Yes / No
+
+```hlsl
+<full .shader file>
+```
+
+PROPERTIES REFERENCE:
+MATERIAL SETUP:
+PERFORMANCE NOTES:
+KNOWN LIMITATIONS:
+````
+
+---
+
+## Supported Shader Types
+
+| Type | When to Use |
+|---|---|
+| `unlit` | UI effects, holograms, VFX, any effect that doesn't need lighting |
+| `lit` | PBR surfaces, characters, props that respond to scene lighting |
+| `surface` | Built-in pipeline only; abstracts lighting boilerplate |
+| `post-process` | Screen-space effects (bloom, color grade, dissolve) |
+
+---
+
+## Related Agents
+
+- [`agents/unreal/blueprint-advisor`](../../unreal/blueprint-advisor/) — UE equivalent for materials and Blueprint logic
+- `skills/unity/shader-review.md` — review an existing shader for mobile budget issues
+- `prompts/game-dev/shader-from-reference.md` — quick one-shot shader from a visual reference

package/agents/unity/shader-generator/agent.md

@@ -0,0 +1,270 @@
+# Agent 06 — Unity Shader Generator
+
+**Platform:** Unity (HLSL / ShaderLab / URP / HDRP)  
+**Category:** Game Development / UI & Design  
+**Complexity:** High
+
+---
+
+## Purpose
+
+Generates Unity-compatible HLSL shader code from a plain-English visual description. Supports the Built-in Render Pipeline, Universal Render Pipeline (URP), and High Definition Render Pipeline (HDRP). Produces a complete `.shader` file with vertex and fragment stages, property declarations, and a usage example.
+
+---
+
+## Input Format
+
+```
+UNITY_VERSION: <e.g. 6000.0 (Unity 6)>
+RENDER_PIPELINE: <builtin | urp | hdrp>
+SHADER_TYPE: <surface | unlit | lit | post-process>
+TARGET_PLATFORM: <mobile | desktop | console | all>
+DESCRIPTION:
+<Plain-English description of the visual effect. Include:
+  - Colors, gradients, or texture inputs
+  - Transparency / blend mode
+  - Animation or time-based effects
+  - Lighting requirements
+  - Performance constraints (mobile-friendly?)>
+```
+
+**Fields:**
+
+| Field | Required | Description |
+|---|---|---|
+| `UNITY_VERSION` | Yes | Determines URP/HDRP API version |
+| `RENDER_PIPELINE` | Yes | `builtin`, `urp`, or `hdrp` |
+| `SHADER_TYPE` | Yes | `surface`, `unlit`, `lit`, or `post-process` |
+| `TARGET_PLATFORM` | Yes | Affects complexity and instruction count |
+| `DESCRIPTION` | Yes | Natural language visual spec |
+
+---
+
+## Output Format
+
+````
+SHADER: <ShaderName>
+FILE: <Shaders/ShaderName.shader>
+RENDER_PIPELINE: <pipeline>
+MOBILE_FRIENDLY: Yes / No
+
+```hlsl
+<full ShaderLab .shader file content>
+```
+
+PROPERTIES REFERENCE:
+| Property | Type | Description |
+|---|---|---|
+| <_PropertyName> | <type> | <what it controls> |
+
+MATERIAL SETUP:
+<Step-by-step instructions for creating and assigning the material in Unity>
+
+PERFORMANCE NOTES:
+- <Instruction count estimate>
+- <Texture samples per fragment>
+- <Recommended LOD level>
+
+KNOWN LIMITATIONS:
+- <Edge cases, unsupported platforms, etc.>
+````
+
+---
+
+## System Prompt
+
+```
+You are a senior Unity graphics engineer with deep expertise in HLSL, ShaderLab, URP, HDRP, and the Built-in Render Pipeline. Your job is to generate a complete, working Unity shader from a plain-English description.
+
+Rules:
+1. Output a complete `.shader` file — including Shader name, Properties block, SubShader, Pass, vertex program, and fragment program. Do not output partial snippets.
+2. Match the specified render pipeline exactly:
+   - Built-in: use `CGPROGRAM` / `#include "UnityCG.cginc"`.
+   - URP: use `HLSLPROGRAM` / `#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"`.
+   - HDRP: use `HLSLPROGRAM` / `#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"`.
+3. For mobile target: keep texture samples ≤ 2, avoid dynamic branching, use `half` precision where possible.
+4. Include `_MainTex` as the primary texture property unless the shader is texture-free by design.
+5. Expose meaningful, tweakable properties in the Properties block.
+6. Add a `Fallback "Diffuse"` for Built-in shaders unless the effect requires no fallback.
+7. For animated effects, use `_Time.y` (seconds since startup) for time input — do not rely on `Time.deltaTime` from scripts.
+8. Comment non-obvious math in the shader code.
+9. Provide a material setup guide (which properties to set in the Inspector).
+10. Note mobile-friendliness and estimated instruction count.
+
+Output MUST follow the exact format specified.
+```
+
+---
+
+## Example
+
+### Input
+
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: unlit
+TARGET_PLATFORM: mobile
+DESCRIPTION:
+A holographic scanline effect for a UI panel. The panel should have a semi-transparent
+dark blue tint with horizontal scanlines scrolling upward over time. The scanline
+frequency and speed should be tweakable. A subtle edge glow (fresnel-like brightness
+at the top and bottom edges of the mesh) should be included. No lighting needed.
+```
+
+### Output
+
+````
+SHADER: HolographicScanline
+FILE: Shaders/HolographicScanline.shader
+RENDER_PIPELINE: URP
+MOBILE_FRIENDLY: Yes
+
+```hlsl
+Shader "Custom/HolographicScanline"
+{
+    Properties
+    {
+        _MainTex        ("Base Texture (optional)", 2D) = "white" {}
+        _TintColor      ("Tint Color", Color) = (0.05, 0.15, 0.4, 0.75)
+        _ScanlineFreq   ("Scanline Frequency", Range(10, 200)) = 60
+        _ScanlineSpeed  ("Scanline Scroll Speed", Range(0, 5)) = 1.2
+        _ScanlineBright ("Scanline Brightness", Range(0, 1)) = 0.15
+        _EdgeGlow       ("Edge Glow Intensity", Range(0, 2)) = 0.6
+        _EdgeFalloff    ("Edge Glow Falloff", Range(1, 10)) = 3.0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "RenderType" = "Transparent"
+            "Queue" = "Transparent"
+            "RenderPipeline" = "UniversalPipeline"
+        }
+
+        Blend SrcAlpha OneMinusSrcAlpha
+        ZWrite Off
+        Cull Back
+
+        Pass
+        {
+            Name "HolographicScanlinePass"
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv         : TEXCOORD0;
+            };
+
+            struct Varyings
+            {
+                float4 positionHCS : SV_POSITION;
+                float2 uv          : TEXCOORD0;
+                // y in object space, normalized 0..1 top-to-bottom for edge glow
+                float  normalizedY : TEXCOORD1;
+            };
+
+            TEXTURE2D(_MainTex);
+            SAMPLER(sampler_MainTex);
+
+            CBUFFER_START(UnityPerMaterial)
+                float4 _MainTex_ST;
+                half4  _TintColor;
+                half   _ScanlineFreq;
+                half   _ScanlineSpeed;
+                half   _ScanlineBright;
+                half   _EdgeGlow;
+                half   _EdgeFalloff;
+            CBUFFER_END
+
+            Varyings vert(Attributes IN)
+            {
+                Varyings OUT;
+                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
+                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
+                // Remap object-space y (-0.5..0.5) to 0..1
+                OUT.normalizedY = IN.positionOS.y + 0.5;
+                return OUT;
+            }
+
+            half4 frag(Varyings IN) : SV_Target
+            {
+                // Base texture (usually white / unused)
+                half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
+
+                // Scrolling scanlines: sine wave over UV.y + time
+                float scanlinePhase = IN.uv.y * _ScanlineFreq
+                                    - _Time.y * _ScanlineSpeed;
+                half scanline = sin(scanlinePhase * 3.14159) * 0.5 + 0.5;
+                scanline = pow(scanline, 4.0); // sharpen the line
+                scanline *= _ScanlineBright;
+
+                // Edge glow: bright at y=0 and y=1, dark in the middle
+                half edgeMask = 1.0 - abs(IN.normalizedY * 2.0 - 1.0);
+                edgeMask = 1.0 - pow(edgeMask, _EdgeFalloff);
+                half edgeGlow = edgeMask * _EdgeGlow;
+
+                // Combine
+                half4 col = _TintColor;
+                col.rgb += scanline + edgeGlow;
+                col.rgb *= texColor.rgb;
+                col.a = _TintColor.a * texColor.a;
+
+                return col;
+            }
+            ENDHLSL
+        }
+    }
+    FallBack Off
+}
+```
+
+PROPERTIES REFERENCE:
+| Property | Type | Description |
+|---|---|---|
+| _MainTex | Texture2D | Optional base texture; leave white for pure color effect |
+| _TintColor | Color (RGBA) | Base holographic tint; alpha controls overall transparency |
+| _ScanlineFreq | Float (10–200) | Number of scanlines visible across the mesh height |
+| _ScanlineSpeed | Float (0–5) | How fast scanlines scroll upward in units/second |
+| _ScanlineBright | Float (0–1) | Brightness contribution of the scanline highlight |
+| _EdgeGlow | Float (0–2) | Intensity of the top/bottom edge glow |
+| _EdgeFalloff | Float (1–10) | How quickly the edge glow falls off toward the center |
+
+MATERIAL SETUP:
+1. In the Project window, right-click → Create → Material.
+2. In the Inspector, set Shader to "Custom/HolographicScanline".
+3. Set _TintColor to (R:0.05, G:0.15, B:0.4, A:0.75) for the default blue holographic look.
+4. Set _ScanlineFreq to 80, _ScanlineSpeed to 1.5 for a readable scrolling effect.
+5. Apply the material to a UI RawImage or a world-space Quad mesh.
+6. Ensure the Canvas or MeshRenderer has "Allow HDR" disabled on mobile.
+
+PERFORMANCE NOTES:
+- Instruction count: ~18 ALU, 1 texture sample — well within mobile budget.
+- No dynamic branching; sin() is approximated by GPU hardware.
+- Uses `half` precision throughout — safe on Mali/Adreno GPUs.
+- Recommended LOD: 100 (default).
+
+KNOWN LIMITATIONS:
+- Edge glow assumes the mesh pivot is centered (positionOS.y ranges -0.5..0.5).
+  For non-centered meshes, adjust the normalizedY calculation.
+- No support for UI Stencil masking (requires additional Pass with Stencil block).
+- Scanlines are UV-based, not screen-space — they will stretch on non-square meshes.
+````
+
+---
+
+## Notes
+
+- For HDRP post-process effects, provide `SHADER_TYPE: post-process` and describe the screen-space effect.
+- Shader Graph alternative: the agent can describe the equivalent Shader Graph node setup if you prefer a visual editor — add `OUTPUT: shader-graph-nodes` to your input.
+- Tested with Unity 6, URP 17.x, HDRP 17.x.
+- Tested with: Claude Sonnet 4.6, GPT-4o.

package/agents/unity/shader-generator/example-input.md

@@ -0,0 +1,70 @@
+# Example Input — Unity Shader Generator
+
+---
+
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: unlit
+TARGET_PLATFORM: mobile
+DESCRIPTION:
+A holographic scanline effect for a UI panel. The panel should have a semi-transparent
+dark blue tint with horizontal scanlines scrolling upward over time. The scanline
+frequency and scroll speed should be tweakable. A subtle edge glow (brighter at the
+top and bottom edges of the mesh) should be included. No lighting needed.
+Mobile-friendly: ≤2 texture samples, half precision throughout.
+```
+
+---
+
+## What to Expect
+
+The agent produces a complete URP unlit `.shader` file. See [`example-output.md`](example-output.md).
+
+Generated file includes:
+- `_TintColor`, `_ScanlineFreq`, `_ScanlineSpeed`, `_ScanlineBright`, `_EdgeGlow`, `_EdgeFalloff` properties
+- URP `HLSLPROGRAM` with correct includes
+- `sin(_Time.y)` for the scanline scroll — no C# scripts needed
+- `half` precision throughout for mobile GPU compatibility
+- Blend mode: `SrcAlpha OneMinusSrcAlpha` for transparency
+- Material setup guide
+
+---
+
+## Variations
+
+### Rim / Fresnel glow (character outline)
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: lit
+TARGET_PLATFORM: desktop
+DESCRIPTION:
+A rim light / Fresnel glow for a sci-fi character. The character glows at silhouette edges
+where the surface normal faces away from the camera. The glow color and sharpness should
+be tweakable. The base albedo texture should show through. Needs to respond to scene lighting.
+```
+
+### Dissolve effect
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: unlit
+TARGET_PLATFORM: mobile
+DESCRIPTION:
+A dissolve effect using a noise texture. A threshold property controls how much of the
+surface is dissolved. Edges of the dissolve should glow with a configurable color and width.
+Uses clip() to discard dissolved fragments. One texture sample for the noise.
+```
+
+### Water surface
+```
+UNITY_VERSION: 6000.0
+RENDER_PIPELINE: urp
+SHADER_TYPE: lit
+TARGET_PLATFORM: desktop
+DESCRIPTION:
+A stylized water surface with two scrolling normal maps for wave detail, Fresnel reflection
+at grazing angles, foam at the shoreline (using a depth texture), and an adjustable water
+color. Should respond to directional light.
+```