STYLIZED POTIONS PACK

7. Timeline Animation

Animate potions dynamically using Unity's Timeline system. Works identically in both URP and Built-in!

7.1 Setup Timeline

Create and configure a Timeline sequence.

Timeline Creation

1. Create Timeline Asset

1. Select GameObject in Hierarchy
2. Window > Sequencing > Timeline
3. Click "Create" in Timeline window
4. Save as: [Name]_Timeline

2. Add Animation Track

1. Click "+" in Timeline window
2. Select "Animation Track"
3. Drag GameObject to track (binds automatically)

3. Record Animation

1. Click red Record button
2. Move playhead to desired time
3. Adjust properties in Inspector
4. Keyframes created automatically

Timeline window showing animation tracks for potion color transitions

7.2 Material Instances

Material Instances are required for Timeline to animate material properties.

Why Material Instances?

Creating Material Instances

Automatic Method (Recommended):

1. Select GameObject with Renderer
2. Find PotionTextureSetup component
3. Click "Prepare for Timeline" button
4. Material Instances created automatically

Manual Method:

1. Select GameObject in Hierarchy
2. Inspector > Renderer > Materials
3. Drag material from Project to material slot
4. Unity creates instance automatically if needed for Timeline

Material Instance Behavior

When Created with "Prepare for Timeline":

• Instances are saved with scene/prefab
• Persist after scene reload
• Can be animated in Timeline immediately
• "(Instance)" suffix appears in material name

In Play Mode:

• Instances work identically to Edit Mode
• Timeline can modify properties freely
• Changes are visible in real-time

Removing Material Instances

If you want to restore the original shared materials:

1. Select GameObject
2. Find PotionTextureSetup component
3. Click "Remove Instances" button
4. Original materials restored

7.3 MaterialIndexController Usage

Use MaterialIndexController to animate gradients independently per material.

Single Material (Optional)

For objects with only 1 material:

Without MaterialIndexController:

Timeline > Animation Track
Animate: Renderer > Material > _GradientIndex
Works in both URP and Built-in
⚠️ If you generate keys with this method and and the animations doesn't work, make a play/stop to fix it.

With MaterialIndexController:

Timeline > Animation Track  
Animate: MaterialIndexController > Index Material 0
(Provides cleaner inspector slider)
Identical in both pipelines

Multiple Materials (Required)

For objects with 2+ materials that need independent gradient animation:

Setup:

1. Add MaterialIndexController component
2. Create Material Instances (Prepare for Timeline)
3. Timeline > Animation Track
4. Animate:
   • Index Material 0 (Cork gradient)
   • Index Material 1 (Metal gradient)
   • Index Material 2 (Liquid gradient)
   • etc.

Animation Example

Health → Poison Transition:

Time 0s:
  Index Material 0 (Cork): 10 (Red cork)
  Index Material 1 (Liquid): 28 (Red liquid)

Time 2s:
  Index Material 0 (Cork): 15 (Green cork)
  Index Material 1 (Liquid): 42 (Green liquid)

Result: Color changes over 2 seconds 
Works identically in URP and Built-in!

(note, as you are animating a float value, you are not animating a smooth color transition, we recommend 
to select keys and r.click > both tangents > Constant to change from initial color to desired one, 
otherwise you will step into every index float between your initial color and the final one.) 

Timeline Animation Tips

Preview in Edit Mode:

• Timeline preview can be unreliable with Material Instances
• Always test in Play Mode for accurate results
• Same limitation in both URP and Built-in

8. Advanced Topics

8.1 Custom Gradients (LUT)

Add your own gradient colors to the LUT texture.

LUT Structure

Current LUT: 256x110 pixels

• Width (256px): Gradient transition (color spectrum)
• Height (110px): 110 different gradients (rows 0-109)

Adding New Gradients

Method 1: Modify Existing LUT

1. Open: Textures/LUT_textures/GradientLUT_256x110.tga
2. Image editor: Photoshop, GIMP, Krita, etc.
3. Add new row at top (add a 1px height) (increases height to 111px)
4. Paint gradient ONLY in that new pixel line: Left → Right (desired colors)
5. Save as .TGA/PNG file
6. Reimport to Unity
7. ⚠️ Update _GradientCount in ALL materials: 111
8. New gradient accessible at index 110
9. If you want to permanently save the 111 index count, you must edit the shaders default value from 110 to 111 (or more if you created new ones)

Method 2: Create New LUT

1. Create image: 256x[N] pixels (N = number of gradients)
2. Each row (px)= one gradient
3. Each gradient: 256 pixel horizontal transition
4. Create a new gradient from left to right
5. Save as .TGA/PNG
6. Import to Unity with correct settings
7. Update _GradientCount in all materials

LUT Texture Settings

Texture Type: Default (Color Texture)
Texture Shape 2D
sRGB: ON (for color accuracy)
Alpha Source: None
Advanced:
Non-Powe of 2: None ⚠️ CRITICAL
Generate Mip Maps: OFF ⚠️ CRITICAL
Wrap Mode: Clamp
Filter Mode: Point (no filter)
Max Size: Match texture dimensions
Resize: Mitchell
Format: Automatic
Compression: None

Gradient Design Tips

Stylistic Consistency:

• Match art style of existing gradients
• Consider color harmony across all gradients
• Test in various lighting conditions

Technical Requirements:

• Smooth transitions (avoid hard edges)
• 256 pixels wide minimum (can be wider)

Using Custom Gradients

1. Assign new LUT to material: _GradientTexture or _GradientTexture_LUT
2. Update _GradientCount to match new row count
3. Set _GradientIndex to new gradient row
4. Test across all material types
5. Works in both URP and Built-in automatically!

8.2 Custom 3D Models

Use your own 3D models with the potion shader system.

Model Requirements

Geometry:

• Low-poly recommended: 500-2000 tris (performance)
• Clean topology: Avoid ngons, overlapping faces
• Proper normals: Smooth where needed

UV Mapping:

• Channel 0 (UVMap): Required for texture projection
• Proper unwrapping: Minimal stretching
• 0-1 UV space: No negative or >1 UVs

Materials:

• One material slot per visual component
• Example: Cork, Metal, Glass, Liquid = 4 slots

Workflow

Step 1: Modeling (Blender/Maya/3ds Max)

1. Model bottle shape
2. Separate components: Cork, Glass, Liquid
3. UV unwrap each component
4. Export as FBX:
   • Apply modifiers
   • Triangulate
   • Y-up, -Z forward

Step 2: Unity Import

1. Import FBX to Unity
2. Model import settings:
   • ✓ Read/Write: ON (for liquid shader)
   • ✓ Generate Colliders: Optional

Step 3: Texture Creation

1. Bake AO/curvature to grayscale texture or directly handpaint textures 1 difusse/base color map
2. Hand-paint details in grayscale
3. Save as 1024x1024 .TGA
4. Import to Unity with proper settings (see 5.1)

Step 4: Material Assignment (Choose Pipeline)

For URP:

1. Create materials with URP shaders
2. Assign:
   • Cork, Metal, other materials you've created: Stylized Tint / Stylized Tint OP (URP)
   • Glass: Stylized Glass (URP)
   • Liquid: Liquid Effect (URP)
3. Assign textures and LUT
4. Set _GradientIndex

For Built-in:

1. Create materials with Built-in shaders
2. Assign:
   • Cork, Metal, other materials you've created: Stylized Tint / Stylized Tint OP (URP)
   • Glass: Stylized Glass (Built-in)
   • Liquid: Liquid Effect (Built-in)
3. Assign textures and LUT
4. Set _GradientIndex

Step 5: Script Setup

1. Add PotionTextureSetup to all meshes you have (assign grayscale texture)
2. Add Liquid.cs component to your Liquid material
3. Configure Fills ranges
4. Test wobble physics

Special Considerations

Liquid Mesh Shape:

Liquid Mesh Shape:

• Should match interior of bottle
• Slightly smaller than glass mesh (no z-fighting)
• Flat top surface for clean fill line

Glass Transparency:

• Avoid excessive overlap (sorting issues)
• Keep geometry simple
• Test from multiple angles

Cork/Cap:

• Can be separate GameObject (easy to hide/show)
• Add hinge joint for physics interaction

Testing Checklist

• ✓ Liquid fills from bottom to top correctly
• ✓ Wobble physics feel natural
• ✓ Gradient colors display properly
• ✓ Glass transparency sorts correctly
• ✓ Performance acceptable (draw calls, tris)
• ✓ Works in target pipeline (URP or Built-in)

Pipeline Note: Custom models work identically in URP and Built-in once appropriate materials are assigned.

8.3 MaterialPropertyBlock (MPB)

✅ Automatic - No Configuration Needed

MaterialPropertyBlock is already integrated into all scripts and works automatically. You don't need to enable, disable, or configure anything - it just works out of the box for optimal performance.

What is MaterialPropertyBlock?

MaterialPropertyBlock (MPB) is Unity's built-in system for:

• Overriding material properties per-renderer
• Without creating material copies
• Maintaining GPU Instancing batching
• Reducing draw calls significantly

Why This Matters for Performance

Without MPB:

• 100 potions with different colors = 100 material instances = 200-300 draw calls
• Each potion needs its own material copy (~5KB each)
• High memory usage and poor batching

With MPB (automatic in this package):

• 100 potions with different colors = 1 shared material = ~10-15 draw calls (GPU instanced)
• All potions share the same material (~5KB total)
• Excellent performance and memory efficiency

How This Package Uses MPB Automatically

Liquid.cs uses MPB to update liquid physics in real-time:

// Automatically updates wobble and fill without material copies
mpb.SetFloat("_WobbleX", wobbleAmountX);
mpb.SetFloat("_WobbleZ", wobbleAmountZ);
mpb.SetVector("_FillAmount", fillPosition);
renderer.SetPropertyBlock(mpb);

MaterialIndexController.cs uses MPB for gradient color changes:

// Automatically updates gradient index per object
mpb.SetFloat("_GradientIndex", currentIndex);
renderer.SetPropertyBlock(mpb, materialSlot);

PotionTextureSetup.cs uses MPB to assign textures:

// Automatically assigns grayscale texture per object
mpb.SetTexture("_GrayscaleTex", grayscaleTexture);
renderer.SetPropertyBlock(mpb);

Automatic Detection System

Smart Timeline Detection:

The scripts automatically detect if you're using Timeline animation and adapt accordingly:

• ✅ No Timeline: Uses MaterialPropertyBlock (best performance)
• ✅ Timeline Detected: Switches to Material Instances automatically
• ✅ Detection checks for "(Instance)" suffix in material names
• ✅ No manual configuration required

MPB vs Material Instances - Automatic Handling

Feature	MaterialPropertyBlock	Material Instances
Performance	✅ Best (GPU Instancing)	⚠️ Good (more draw calls)
Memory Usage	✅ Low (shared material)	⚠️ Higher (material copies)
Timeline Animation	❌ Not compatible	✅ Required
Runtime Changes	✅ Very efficient	✅ Works
Configuration	✅ Automatic (default)	✅ Automatic (when Timeline detected)

When Each System is Used

MaterialPropertyBlock (Default)

Automatically used when:

• No Material Instances detected
• Runtime gameplay (not Timeline animation)
• Scripts modify properties via code

Best for:

• Performance-critical scenarios
• Many objects with shared materials
• Runtime color/property changes

Material Instances (Timeline)

Automatically used when:

• "Prepare for Timeline" button clicked
• Material name contains "(Instance)"
• Timeline animation required

Best for:

• Timeline property animation
• Per-object persistent changes
• Keyframe-based animations

MPB Limitations (Technical Info)

While MPB is excellent for performance, it has some technical limitations:

• ❌ Cannot animate with Timeline directly (scripts detect this and switch automatically)
• ❌ Changes don't persist in Editor (only during Play Mode)
• ❌ Not visible in Material Inspector
• ⚠️ Harder to debug (no visual feedback in Inspector)

Solution: This package handles these limitations automatically by switching to Material Instances when Timeline is detected.

Pipeline Compatibility

MaterialPropertyBlock works identically in both render pipelines:

• ✅ Universal Render Pipeline (URP)
• ✅ Built-in Render Pipeline
• ✅ No code changes needed between pipelines
• ✅ GPU Instancing compatible in both
• ✅ Same performance benefits in both

Summary: You Don't Need to Do Anything

MaterialPropertyBlock is fully integrated and automatic:

• ✅ Works out of the box with zero configuration
• ✅ Provides best performance by default
• ✅ Automatically switches to Material Instances when Timeline is used
• ✅ Compatible with both URP and Built-in
• ✅ Just use the scripts normally - MPB handles optimization behind the scenes

8.4 Pipeline Migration

Switch between URP and Built-in without losing work.

URP → Built-in Migration

Step 1: Backup Project

1. Duplicate entire Unity project folder
2. Test migration on duplicate first

Step 2: Remove URP

1. Project Settings > Graphics
2. Remove URP Renderer asset
3. Set to Built-in Render Pipeline
4. Window > Package Manager
5. Remove Universal RP package

Step 3: Replace Materials

1. Find all materials using URP shaders
2. For each material:
   • Note current _GradientIndex and settings
   • Assign equivalent Built-in shader:
     • Stylized Tint → Stylized Tint (Built-in)
     • Stylized Tint OP → Stylized Tint OP (Built-in)
     • Stylized Glass → Stylized Glass (Built-in)
     • Liquid Effect → Liquid Effect (Built-in)
   • Reapply settings and gradient index

Step 4: Update Demo Scene

1. Use DemoScene_BuiltIn instead of DemoScene_URP
2. Install Post Processing Stack v2 if needed
3. Configure Post Process Profile

Step 5: Test

• ✓ All potions render correctly
• ✓ Liquid wobble works
• ✓ Timeline animations function
• ✓ Colors match previous URP version

Built-in → URP Migration

Step 1: Backup Project

1. Duplicate entire Unity project folder
2. Test migration on duplicate first

Step 2: Install URP

1. Window > Package Manager
2. Install "Universal RP"
3. Create URP Asset:
   • Right-click > Create > Rendering > URP Asset
4. Project Settings > Graphics
5. Assign URP Asset to Scriptable Render Pipeline Settings

Step 3: Replace Materials

1. Find all materials using Built-in shaders
2. For each material:
   • Note current _GradientIndex and settings
   • Assign equivalent URP shader:
     • Stylized Tint (Built-in) → Stylized Tint
     • Stylized Tint OP (Built-in) → Stylized Tint OP
     • Stylized Glass (Built-in) → Stylized Glass
     • Liquid Effect (Built-in) → Liquid Effect
   • Reapply settings and gradient index

Step 4: Update Demo Scene

1. Use DemoScene_URP instead of DemoScene_BuiltIn
2. Remove Post Processing Stack v2 components
3. Add Volume component for URP post-processing

Step 5: Test

• ✓ All potions render correctly
• ✓ Liquid wobble works
• ✓ Timeline animations function
• ✓ Colors match previous Built-in version

Property Name Mapping

When migrating, be aware of property name differences:

Liquid Effect Shader:

Built-in Property → URP Property
_LUTTex → _GradientTexture
_Tint → _BottomColor
_Line → _FoamWidth
_LineSmooth → _Foam_Smoothness
_Freq → _Frequency
_RimPower → _Rim_Power
_RimColor → _Rim_Color

Stylized Tint:

Built-in Property → URP Property
_GradientTexture → _GradientTexture_LUT
_Smoothness → _Smoothness_Glossy

Important: Scripts handle property name differences automatically. Manual adjustment only needed for material assets.

9. Use Cases & Examples

9.1 Health/Mana Potions

Create classic RPG potions with distinct colors using the gradient system.

Health Potion (Red)

Materials (Works in Both Pipelines):

• Cork: Index 28 (Cork_Red)
• Metal: Index 10-12 (Metal_IronDark, Metal_Steel, or Metal_SilverPolished)
• Glass: Index 30 (Gem_Ruby) with Alpha: 0.1-0.2 for red tint
• Liquid: Index 30 (Gem_Ruby) or Index 90 (Blood_Crimson)

Liquid Settings:

Top Color: Bright Red (#FF3030)
Bottom Color / Tint: Dark Red (#8B0000)
Foam Color: Pink (#FFB6C1)
Fill Amount: 0.8 (80% full)

Mana Potion (Blue)

Materials (Works in Both Pipelines):

• Cork: Index 25 (Cork_Light) or Index 26 (Cork_Dark)
• Metal: Index 12 (Metal_SilverPolished) or Index 19 (Metal_Platinum)
• Glass: Index 31 (Gem_Sapphire) with Alpha: 0.1-0.2 for blue tint
• Liquid: Index 31 (Gem_Sapphire) or Index 95 (Wraith_Blue)

Liquid Settings:

Top Color: Bright Blue (#00BFFF)
Bottom Color / Tint: Deep Blue (#000080)
Foam Color: Cyan (#00FFFF)
Fill Amount: 0.75 (75% full)
Rim Color: Electric Blue (glow effect)

Alternative Color Schemes

Implementation

Static Setup (In Editor):

1. Create prefab variant: Potion_Health_[Pipeline]
2. Assign materials with appropriate gradient indices
3. Configure liquid colors in Inspector
4. Set fill amount and alpha values
5. Save prefab

Runtime Switching (Via Script):

// Health potion setup
MaterialIndexController controller = GetComponent<MaterialIndexController>();
controller.indexMaterial0 = 28;  // Cork_Red (cork material)
controller.indexMaterial1 = 10;  // Metal_IronDark (metal cap)
controller.indexMaterial2 = 30;  // Gem_Ruby (glass with low alpha)
controller.indexMaterial3 = 30;  // Gem_Ruby (liquid)

// Mana potion setup
controller.indexMaterial0 = 25;  // Cork_Light
controller.indexMaterial1 = 12;  // Metal_SilverPolished
controller.indexMaterial2 = 31;  // Gem_Sapphire (glass with low alpha)
controller.indexMaterial3 = 31;  // Gem_Sapphire (liquid)

// Works identically in URP and Built-in!

9.2 Crafting System

Animate potion brewing process using Timeline with instant color changes and smooth fill animations.

Brewing Animation Sequence

Phase 1: Empty Bottle (0-2s)

Fill Amount: 0
Glass: Clear
Liquid: Any gradient (not visible when empty)

Phase 2: Base Ingredient Appears (2-4s)

Fill Amount: 0 → 0.3 (smooth animation)
Liquid Gradient: Index 60 (Grass_Dark - green base)
Timeline: Animate Fill Amount smoothly

Phase 3: Instant Color Change (4s exactly)

Fill Amount: 0.3 → 0.6 (smooth animation)
Liquid Gradient: Index 60 → Index 90 (INSTANT change at 4s)
Timeline: Use Constant interpolation for gradient
Effect: Ingredient reacts and changes color instantly

Phase 4: Final Product (6-8s)

Fill Amount: 0.6 → 0.9 (smooth animation)
Liquid Gradient: Index 90 (Blood_Crimson - health potion)
Emission: 0 → 1 (glowing effect)
Cork: Animate position down (seal bottle)

Timeline Setup (Correct Configuration)

Track 1 (Liquid.cs Component): Fill Amount
  Keyframe 0s:  0.0   [Linear interpolation OK]
  Keyframe 2s:  0.0   [Linear interpolation OK]
  Keyframe 4s:  0.3   [Linear interpolation OK]
  Keyframe 6s:  0.6   [Linear interpolation OK]
  Keyframe 8s:  0.9   [Linear interpolation OK]
  
  → Fill amount can use smooth linear interpolation

Track 2 (MaterialIndexController): Index Material 3 (Liquid)
  Keyframe 2s:  60 (Grass_Dark)      [CONSTANT interpolation]
  Keyframe 4s:  90 (Blood_Crimson)   [CONSTANT interpolation]
  
  → Gradient changes MUST use constant interpolation
  → Right-click each keyframe → Both Tangents → Constant

Track 3 (Cork Transform): Position Y
  Keyframe 6s:  0.5 (open position)
  Keyframe 8s:  0.2 (closed/sealed)
  
  → Cork movement can use smooth linear interpolation

4s: Index 60 [Default Linear]
6s: Index 90

Result: Flickers through 30 gradients (60→61→62...→90)

4s: Index 60 [Constant]
6s: Index 90

Result: Stays at 60, then instantly jumps to 90 at exactly 6s

9.3 Shop Display

Create attractive store displays with variety.

Display Layout

Shelf Arrangement:

• Row 1: Health potions (all red, different sizes)
• Row 2: Mana potions (all blue, different sizes)
• Row 3: Specialty potions (mixed colors)
• Row 4: Rare potions (glowing, unique colors)

Visual Variety:

• Different bottle shapes (10 models available)
• Different fill amounts (20%, 50%, 80%, 100%)
• Different cork colors (leathers, woods, bones)
• Different metal bands (gold, silver, bronze)

Lighting Setup

URP Lighting:

Directional Light:
  Type: Directional
  Intensity: 1.0
  Color: Warm white
  Angle: 45° from top

Spot Light (Rim):
  Type: Spot Light
  Intensity: 2.0
  Color: Blue/Cyan (magical feel)
  Range: Adjust per potion

Environment:
  Skybox: Custom or gradient
  Ambient Source: Skybox
  Reflection Probes: Bake for glass reflections

Built-in Lighting:

Directional Light:
  Type: Directional
  Intensity: 1.0
  Color: Warm white
  Angle: 45° from top

Spot Light (Rim):
  Type: Spot Light
  Intensity: 2.0
  Color: Blue/Cyan
  Range: Adjust per potion

Environment:
  Environment Lighting: Gradient
  Sky Color: Dark purple
  Horizon: Deep blue
  Ambient Mode: Skybox

Material Highlighting

Liquid Rim Glow:

Rim Color: Bright version of liquid color
Rim Intensity: 0.5-1.0

Cork/Metal Emission (Tint Materials Only):

Emission Color: Complementary to liquid
Emission Strength: 0.3-0.5

Performance Optimization

Batching:

• Use shared materials where possible
• MaterialPropertyBlock for color variations
• Static batching for non-moving potions
• Works in both URP and Built-in

Culling:

• Frustum culling: Automatic in both pipelines
• Occlusion culling: Bake for complex stores
• Camera far plane: Adjust based on store size

9.4 Post-Processing Setup

Add visual polish to your scenes.

URP Post-Processing

Setup:

1. Create Volume GameObject in scene
2. Add "Volume" component
3. Check "Is Global"
4. Create Volume Profile asset
5. Add Post-Processing effects

Recommended Effects:

Bloom:
  Intensity: 0.2-0.5
  Threshold: 1.0
  Scatter: 0.7
  Tint: Slight warm color

Vignette:
  Intensity: 0.3-0.4
  Smoothness: 0.4
  Rounded: OFF

Camera Setup:

Main Camera:
  ✓ Post Processing enabled (checked in Camera component)
  ✓ Anti-aliasing: FXAA or SMAA
  ✓ Render Post Processing: ON

Built-in Post-Processing

Prerequisites:

1. Install Post Processing Stack v2 via Package Manager (com.unity.postprocessing)

Setup:

1. Create Post-Processing Profile asset
   • Right-click > Create > Post-processing Profile
2. Configure effects in Profile
3. Create empty GameObject in scene
4. Add "Post-process Volume" component
5. Assign Profile to Volume
6. Check "Is Global"
7. Configure Camera

Recommended Effects:

Bloom:
  Intensity: 2-5
  Threshold: 1.0
  Soft Knee: 0.5
  Diffusion: 7

Vignette:
  Intensity: 0.3-0.4
  Smoothness: 0.4
  Rounded: OFF

Camera Setup:

Main Camera:
  Add "Post-process Layer" component
  Layer: Everything
  Anti-aliasing: FXAA or SMAA

Testing Post-Processing

• ✓ Bloom visible on glowing emission
• ✓ Vignette darkens edges naturally
• ✓ No performance issues
• ✓ Consistent look between pipelines

10. Troubleshooting & FAQ

10.1 Common Issues and Solutions

Liquid Not Moving / Wobble Not Working

Symptoms:

• Liquid surface is static
• No wobble when moving potion
• Fill amount doesn't change

Solutions:

Model import settings:
✓ Read/Write: Must be ON
Location: Inspector > Model > Meshes > Read/Write

Why: Liquid.cs needs mesh access to calculate fill position
Fix: Enable Read/Write, click Apply

Colors Look Wrong / Gradient Not Applied

Symptoms:

• Flat colors instead of gradients
• Banding/posterization
• Colors don't match gradient index

Solutions:

Grayscale texture:

Texture Shape 2D
sRGB: ON (for color accuracy)
Alpha Source: None
Advanced:
Non-Powe of 2: None ⚠️ CRITICAL
Generate Mip Maps: OFF ⚠️ CRITICAL
Wrap Mode: Clamp
Filter Mode: Point (no filter)
Max Size: Match texture dimensions
Resize: Mitchell
Format: Automatic
Compression: None

LUT texture:

Texture Shape 2D
sRGB: ON (for color accuracy)
Alpha Source: None
Advanced:
Non-Powe of 2: None ⚠️ CRITICAL
Generate Mip Maps: OFF ⚠️ CRITICAL
Wrap Mode: Clamp
Filter Mode: Point (no filter)
Max Size: Match texture dimensions
Resize: Mitchell
Format: Automatic
Compression: None

Fix: Reimport textures with correct settings

Glass/Liquid Rendering Issues

Symptoms:

• Glass renders on top of liquid
• Sorting issues with transparency
• Z-fighting/flickering

Solutions:

Glass material:
  Render Queue: Transparent (3000)
  
Liquid material:
  Render Queue: Transparent (3001) in URP
  Render Queue: Geometry in Built-in (with AlphaToMask)
  
Liquid should render AFTER glass in URP
Built-in uses different approach with alpha clipping

Fix: Manually set render queue if needed

Timeline Animation Not Working

Symptoms:

• Material properties don't animate
• Changes affect all objects together
• Animation doesn't show in Play Mode

Solutions:

Performance Issues / Low FPS

Symptoms:

• Frame rate drops
• Stuttering movement
• High draw call count

Solutions:

Window > Analysis > Frame Debugger
Check draw calls:
  - Each potion: 2-4 draw calls expected
  - 100+ draw calls: Problem

Fix: Use MaterialPropertyBlock instead of Material Instances
     (Only use Instances when Timeline animation needed)

Window > Analysis > Profiler
Check:
  - CPU: Liquid.cs Update() time
  - Rendering: Shader compilation
  - Memory: Material instance count

Fix based on bottleneck identified

Post-Processing Not Working

Symptoms (Built-in Only):

• No Bloom or Vignette visible
• Console errors about post-processing

Solutions:

Window > Package Manager
Search: "Post Processing"
Install: com.unity.postprocessing

URP: Post-processing built-in, no extra package needed

Material Preview Issues

Symptoms:

• Material thumbnails show UV patterns
• Grayscale texture visible in previews
• Messy project window

Solutions:

10.2 FAQ

11. Technical Specifications

11.1 Platform Compatibility

11.2 Performance Notes

Draw Calls per Potion

Polygon Count

• Minimum: 320 tris (Potion_03_ThinSmall)
• Maximum: 1152 tris (Potion_08_ThinNeckBig)
• Average: ~680 tris per potion

Memory Usage

Per Potion (MaterialPropertyBlock):

• Textures: ~2MB (1k grayscale + shared LUT)
• Mesh: ~50KB (with Read/Write enabled)
• Materials: Shared (minimal overhead)
• Total: ~2.05MB per unique potion type

11.3 Known Limitations

12 Support & Updates

12.1 Contact Information

Bug Reports

When reporting bugs, please include:

1. Unity version (exact build number)
2. Render pipeline (URP or Built-in)
3. Platform (Windows, Mac, WebGL, etc.)
4. Steps to reproduce
5. Error messages from Console
6. Screenshots or video if applicable
7. Whether issue occurs in both pipelines or just one

12.2 Roadmap

v1.1.0 (Q2 2026) - Unity 2022.3 LTS Support

• Full Unity 2022.3 LTS compatibility
• Liquid shader adaptations for 2022.3
• Compatibility testing across both pipelines
• Performance optimization
• Documentation updates

v1.2.0 (Q3 2026) - Content Expansion

• 4 new potion models (16 total)
• 40 new gradients (150 total)
• Additional props (example: shelves, ingredients, cauldron)
• New prefab variants
• Mobile optimization pass

v2.0.0 (Q4 2026 - If Successful)

• HDRP support (third pipeline!)
• Advanced liquid physics ** (splashing, dripping)
• Particle effects integration
• Documentation video tutorials
• Cross-pipeline material converter tool **

12.3 Changelog

v1.0.0 (November 2025) - Initial Release

13. License & Legal

13.1 Terms of Use

When you buy Stylized Potions Pack from the Unity Asset Store, you get a license to use it in your projects following Unity's standard Asset Store EULA (End User License Agreement).

✅ What You CAN Do

• Use in commercial projects - Games, apps, films, client work - all good!
• Modify everything - Change models, textures, shaders, scripts however you want
• Ship in your products - Include in published games, DLC, updates
• Use in unlimited projects - No per-project licensing
• Switch between pipelines - Convert freely between URP and Built-in
• Client/freelance work - Use for game dev services you provide

❌ What You CANNOT Do

• Resell the pack - Can't redistribute the asset package to others
• Share individual files - Can't distribute models, textures, or shaders separately
• Upload to other stores - Can't sell on other asset stores or marketplaces
• Use as template/tool - Can't make competing asset packs using this content
• Share with teammates - Each team member needs their own license

Team/Multi-Seat Licensing

Working with a team?

• Each developer working with the asset needs their own license
• One license = One developer, unlimited projects by that developer
• This follows Unity Asset Store's standard licensing

Full Legal Terms

The complete legal agreement is Unity's Asset Store EULA, available at:

https://unity.com/legal/as-terms

This summary is provided for convenience but does not replace the official EULA. When in doubt, the official Unity Asset Store EULA takes precedence.

13.2 Warranty Disclaimer

No Guarantees:

• No guarantee of compatibility with future Unity versions
• No guarantee of specific performance metrics
• No guarantee of bug-free operation
• No guarantee of platform compatibility beyond tested platforms
• No guarantee of compatibility with specific pipeline versions

User Responsibility:

• Test assets in your specific project before production use
• Backup projects before importing assets
• Verify compatibility with your target platforms
• Test in your chosen render pipeline (URP or Built-in)
• Read documentation before use

13.3 Credits & Attribution

Original Tutorial Credits

Tools Used

Development:

• Unity 6 (Game Engine)
• Blender (3D Modeling)
• Krita (Texturing)
• Visual Studio Code (Programming)
• Shader Graph (URP shaders)

Technologies:

• Universal Render Pipeline (URP)
• Built-in Render Pipeline
• Surface Shaders (Built-in)
• Shader Graph (URP)
• Timeline System
• MaterialPropertyBlock API
• Post Processing Stack v2 (Built-in)

Attribution (Optional)

While not required, we appreciate attribution if you choose to credit assets in your project:

"Stylized Potions Pack" by MesshingAround
Available on Unity Asset Store
Supports URP and Built-in Render Pipeline

Copyright

© 2025 MesshingAround. All rights reserved.

• Assets: Copyright MesshingAround
• Unity: Trademark of Unity Technologies
• Asset Store: Platform operated by Unity Technologies
• URP/Built-in: Unity rendering technologies