[Unity] Wild Orchard Documentation

<aside>

CONTENTS

</aside>

Version: 1.0

Last Update: 04 June 2026

Introduction

What is Wild Orchard

Wild Orchard is a complete fruit-tree growth, seasonal, and harvesting framework for Unity, designed for farming sims, RPGs, survival, and open-world projects. Each pack provides high-quality, game-ready trees with multi-stage growth, four seasonal foliage states, smooth cross-fade transitions, and harvestable fruit pickups — ready to drop straight into your scenes.

Unlike static environment trees, every Wild Orchard tree has two independent axes of state: its growth stage (how far through its life it has matured) and its foliage state (what it is currently showing — bare branches, blossom, fruit, or leaf). Both are driven by a small, clean public API, so trees can be controlled by your day/night cycle, seasonal system, weather simulation, or direct player interaction.

Whether you're building a cozy farming sim with seasonal orchards, an RPG with foraging and resource gathering, or an open world to populate with living trees, Wild Orchard gives you everything you need: detailed LOD'd meshes, a wind-driven foliage shader, harvest FX, UI icons, and configurable prefabs with the growth and harvesting logic built in.

Core Features:

• 🌳 Two-Axis Tree State — Independent control over growth stage and seasonal foliage, so a young tree and a mature tree can each be in any season.
• 🍎 Four Foliage States — Bare, Blossom, Fruit, and Leaf, each with its own meshes and optional particle FX per growth stage.
• 🎬 Dithered Cross-Fades — Seasonal and growth transitions blend smoothly via a blue-noise dither fade rather than a hard mesh swap.
• 🧺 Configurable Harvesting — Each harvest spawns fruit pickups with per-stage min/max counts, randomised spawn points, and a drop-and-hover animation.
• 🍃 Wind System — A global, WindZone-driven foliage shader with leaf flutter and branch sway, visible in edit mode.
• 🎨 LOD'd, Instanced Meshes — Three LODs per variant with GPU-instancing-friendly materials.
• 🧩 Clean, Engine-Agnostic API — A handful of methods and three read-only properties cover essentially every gameplay scenario, with no dependency on a specific game framework.
• 🪵 Drop-in Prefabs & Demo Scene — A preconfigured demo scene shows the whole system running out of the box.

Contacting Support

Online Documentation - https://nv3d.notion.site/

If you encounter any issues or have questions not covered in this documentation you can contact Matt directly, or join our active Discord server for help, tips and community events.

✉️ [email protected]

🗨️ https://discord.gg/TQ7ADa8zFu

Pack Overview

The Wild Orchard Series is a growing collection of themed tree packs, all built on the same shared codebase, shader, and data structures. Every pack uses the identical FruitTree workflow described in this documentation — what changes between packs is the trees and art assets, not the logic. Adding a new pack to your project requires no additional scripting or setup.

About bundles

When you purchase a bundle, you’re granted access to the individual asset packs it includes. After completing your purchase, you’ll need to visit each product page listed in the bundle and claim them individually for free. Once claimed, each pack will be added to your Unity Asset Store library under My Assets.

This ensures you can download, import, and manage each pack independently, just as if you had purchased them separately.

<aside> ✅ Note All packs share the same scripts and shader. Once you've learned the workflow from one pack, every other pack works exactly the same way.

</aside>

🍎 Wild Orchard: Fruit Trees

The first pack in the series, four classic orchard fruit trees, each with five growth stages, four seasonal foliage states, and three LODs per variant.

Trees Included

• Apple
• Pear
• Cherry
• Plum

Coming Soon

Further packs (e.g. nut trees) are planned for the coming months. Each will slot into this section with its own tree list and included props, and will work with the same scripts and scenes you've already set up.

Requirements & Compatibility

Wild Orchard currently targets Unity 6.3 using the Universal Render Pipeline (URP).

<aside> ⚠️ Warning Wild Orchard is built exclusively for URP. There are no BiRP or HDRP switch packages, and the foliage shader is a URP Shader Graph. If your project uses a different pipeline, the materials will not render correctly.

</aside>

Getting Started

This section walks you through importing the pack, running the demo, and dropping your first tree into a scene.

<aside> ✅ Note You don't need advanced scripting knowledge to use Wild Orchard. Trees are prefab-driven and configured entirely through the Inspector. Scripting is only required when you wire trees into your own game systems (covered later in Integration).

</aside>

Import the Pack(s)

Running the Demo Scene

Placing A Tree in Your Scene

Core Concepts

This section establishes the mental model behind Wild Orchard. It's short, but reading it first will make everything in the Script Reference and Integration sections click into place.

The Two Axes: Growth Stage vs. Foliage State

Every Wild Orchard tree tracks two independent states:

1. Growth stage — Which stage of the tree's life is showing (e.g. sapling → young → mature). Each stage is its own set of meshes on the prefab. There are five stages in the Fruit Trees pack.
2. Foliage state — What the current growth stage is displaying: Bare, Blossom, Fruit, or Leaf. Every growth stage carries all four foliage groups.

These two axes are fully independent. A sapling can be in blossom; a mature tree can be bare. This is what lets a single tree express both how old it is and what season it is at the same time.

<aside> ✅ Note Growth stage is driven by SetGrowthStage / AdvanceGrowthStage. Foliage state is driven by SetFoliageState. They can be changed independently, or together in a single transition (see the two-argument overloads in Script Reference).

</aside>

The Four Foliage States

Cross-Fade Transitions

Switching foliage state or growth stage is not a hard mesh swap. Instead, the outgoing and incoming meshes blend using a dithered (blue-noise) alpha cross-fade: the outgoing mesh samples an inverted noise pattern while the incoming mesh samples the normal pattern, so their visible pixels are complementary and total coverage stays constant through the blend.

You don't need to manage any of this — it's handled internally by the FruitTree component and the foliage shader. The only things you'll typically touch are the two fade durations on the component (foliageFadeDuration and growthFadeDuration).

<aside> ✅ Note The cross-fade is driven by a _Fade shader property (and _Invert_Fade_Noise for the complementary mesh). These are set automatically. You only need to know about them if you fork and rename the shader properties.

</aside>

Tree Definition (ScriptableObject)

A Tree Definition is an authoring asset that describes a tree type — its identity, its per-stage growth profile, and its harvest rules. One Tree Definition is shared by every tree instance of the same species.

The split is deliberate:

• Tree Definition (the asset) holds data — fruit counts, harvest rules, fruit prefabs.
• The FruitTree component (on the prefab) holds per-instance scene wiring — which transform is which growth stage, where the fruit spawn points are.

This lets one Apple Tree Definition drive a hundred apple trees in a scene, while each tree keeps its own scene-graph bindings.

<aside> ⚠️ Warning The per-stage entries on the Tree Definition and the per-stage bindings on the FruitTree component are paired by index — stage 0 in one must correspond to stage 0 in the other. If the two arrays are different lengths, harvest and growth logic will fail on the unpaired stages, and the component will log a warning in the editor.

</aside>

Harvest

Harvest spawns fruit; it does not change the tree. Calling Harvest() spawns fruit pickups from the current stage's spawn points and then stops — it does not alter the growth stage or foliage state. What happens to the tree after a harvest (stay fruiting, fade to bare, etc.) is entirely up to the caller.

A harvest only produces fruit when all three of these are true (the CanHarvest property reflects exactly this):

1. Fruiting is enabled on the Tree Definition (fruitEnabled).
2. The tree's current foliage state matches the definition's harvestState (Fruit by default).
3. The current growth stage allows fruiting (canFruit on that stage's profile).

<aside> ✅ Note Check CanHarvest before calling Harvest() if you want to know whether a tree is ready (e.g. to show a prompt). Harvest() is also safe to call unconditionally.

</aside>

Script Reference

All scripts live in the NV3D.WildOrchard namespace. The only script you'll interact with directly in most projects is FruitTree; the rest are either data (TreeDefinition), spawned objects (FruitPickup), scene infrastructure (WindBinder), or a reference example (FruitTreeDemoDriver).

FruitTree.cs

TreeDefinition.cs (ScriptableObject)

FruitPickup.cs

WindBinder.cs

FruitTreeDemoDriver.cs