// <auto-generated/>

// Crest Water System
// Copyright © 2024 Wave Harmonic. All rights reserved.

namespace WaveHarmonic.Crest.Generated
{
    enum CollisionLayer
    {
        /// <summary>
        /// Include all displacement.
        /// </summary>
        Everything,

        /// <summary>
        /// Only include Animated Waves.
        /// </summary>
        AfterAnimatedWaves,

        /// <summary>
        /// Include Animated Waves and Dynamic Waves.
        /// </summary>
        AfterDynamicWaves,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum CollisionLayers
    {
        /// <summary>
        /// All layers.
        /// </summary>
        Everything,

        /// <summary>
        /// No extra layers (ie single layer).
        /// </summary>
        Nothing,

        /// <summary>
        /// Separate layer for dynamic waves.
        /// </summary>
        /// <remarks>
        /// Dynamic waves are normally combined together for efficiency. By enabling this layer, dynamic waves are combined and added in a separate pass.
        /// </remarks>
        DynamicWaves,

        /// <summary>
        /// Extra displacement layer for visual displacement.
        /// </summary>
        Displacement,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum CollisionSource
    {
        /// <summary>
        /// No collision source. Flat water.
        /// </summary>
        None,

        /// <summary>
        /// Uses AsyncGPUReadback to retrieve data from GPU to CPU.
        /// </summary>
        /// <remarks>
        /// This is the most optimal approach.
        /// </remarks>
        GPU,

        /// <summary>
        /// Computes data entirely on the CPU.
        /// </summary>
        CPU,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum DefaultClippingState
    {
        /// <summary>
        /// By default, nothing is clipped. Use clip inputs to remove water.
        /// </summary>
        NothingClipped,

        /// <summary>
        /// By default, everything is clipped. Use clip inputs to add water.
        /// </summary>
        EverythingClipped,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum DepthProbeMode
    {
        /// <summary>
        /// Update in real-time in accordance to refresh mode.
        /// </summary>
        RealTime,

        /// <summary>
        /// Baked in the editor.
        /// </summary>
        Baked,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum DepthProbeRefreshMode
    {
        /// <summary>
        /// Populates the DepthProbe in Start.
        /// </summary>
        OnStart,

        /// <summary>
        /// Requires manual updating via DepthProbe.Populate.
        /// </summary>
        ViaScripting,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum DisplacementPass
    {
        /// <summary>
        /// Displacement that is dependent on an LOD (eg waves).
        /// </summary>
        /// <remarks>
        /// Uses filtering to determine which LOD to write to.
        /// </remarks>
        LodDependent,

        /// <summary>
        /// Renders to all LODs.
        /// </summary>
        LodIndependent,

        /// <summary>
        /// Renders to all LODs, but as a separate pass.
        /// </summary>
        /// <remarks>
        /// Typically used to render visual displacement which does not affect collisions.
        /// </remarks>
        LodIndependentLast,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum FloatingObjectModel
    {
        /// <summary>
        /// A simple model which aligns the object with the wave normal.
        /// </summary>
        AlignNormal,

        /// <summary>
        /// A more advanced model which samples water at the probes positions.
        /// </summary>
        Probes,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum LodInputBlend
    {
        /// <summary>
        /// No blending. Overwrites.
        /// </summary>
        Off,

        /// <summary>
        /// Additive blending.
        /// </summary>
        Additive,

        /// <summary>
        /// Takes the minimum value.
        /// </summary>
        Minimum,

        /// <summary>
        /// Takes the maximum value.
        /// </summary>
        Maximum,

        /// <summary>
        /// Applies the inverse weight to the target.
        /// </summary>
        /// <remarks>
        /// Basically overwrites what is already in the simulation.
        /// </remarks>
        Alpha,

        /// <summary>
        /// Same as alpha except anything above zero will overwrite rather than blend.
        /// </summary>
        AlphaClip,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum LodInputMode
    {
        /// <summary>
        /// Unset is the serialization default.
        /// </summary>
        /// <remarks>
        /// This will be replaced with the default mode automatically. Unset can also be used if something is invalid.
        /// </remarks>
        Unset,

        /// <summary>
        /// Hand-painted data by the user.
        /// </summary>
        Paint,

        /// <summary>
        /// Driven by a user created spline.
        /// </summary>
        Spline,

        /// <summary>
        /// Attached 'Renderer' (mesh, particle or other) used to drive data.
        /// </summary>
        Renderer,

        /// <summary>
        /// Driven by a mathematical primitive such as a cube or sphere.
        /// </summary>
        Primitive,

        /// <summary>
        /// Covers the entire water area.
        /// </summary>
        Global,

        /// <summary>
        /// Data driven by a user provided texture.
        /// </summary>
        Texture,

        /// <summary>
        /// Renders geometry using a default material.
        /// </summary>
        Geometry,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum LodInputPrimitive
    {
        /// <summary>
        /// Spheroid.
        /// </summary>
        Sphere,

        /// <summary>
        /// Cuboid.
        /// </summary>
        Cube,

        /// <summary>
        /// Quad.
        /// </summary>
        Quad,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum LodTextureFormatMode
    {
        /// <summary>
        /// Uses the Texture Format property.
        /// </summary>
        Manual,

        /// <summary>
        /// Chooses a texture format for performance.
        /// </summary>
        Performance,

        /// <summary>
        /// Chooses a texture format for precision.
        /// </summary>
        /// <remarks>
        /// This format can reduce artifacts.
        /// </remarks>
        Precision,

        /// <summary>
        /// Chooses a texture format based on another.
        /// </summary>
        /// <remarks>
        /// For example, Dynamic Waves will match precision of Animated Waves.
        /// </remarks>
        Automatic,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum Placement
    {
        /// <summary>
        /// The component is in a fixed position.
        /// </summary>
        Fixed,

        /// <summary>
        /// The component follows the transform.
        /// </summary>
        Transform,

        /// <summary>
        /// The component follows the viewpoint.
        /// </summary>
        Viewpoint,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum QuerySource
    {
        /// <summary>
        /// This game object's transform.
        /// </summary>
        Transform,

        /// <summary>
        /// The viewer's transform.
        /// </summary>
        /// <remarks>
        /// The viewer is the main camera the system uses.
        /// </remarks>
        Viewer,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum ShorelineVolumeColorSource
    {
        /// <summary>
        /// No depth color.
        /// </summary>
        None,

        /// <summary>
        /// Depth color based on water depth.
        /// </summary>
        Depth,

        /// <summary>
        /// Depth color based on shoreline distance.
        /// </summary>
        Distance,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum WaterInjectionPoint
    {
        /// <summary>
        /// Renders in the default pass.
        /// </summary>
        /// <remarks>
        /// For the water surface, this will be determined by the material (opaque or transparent). This pass is controlled by Unity, and is not compatible with certain features like soft particles.
        /// </remarks>
        Default,

        /// <summary>
        /// Renders before the transparent pass.
        /// </summary>
        /// <remarks>
        /// This has advantages like being compatible with soft particles, refractive shaders, and possibly third-party fog.
        /// </remarks>
        BeforeTransparent,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum WaterReflectionSide
    {
        /// <summary>
        /// Both sides. Most expensive.
        /// </summary>
        Both,

        /// <summary>
        /// Above only. Typical for planar reflections.
        /// </summary>
        Above,

        /// <summary>
        /// Below only. For total internal reflections.
        /// </summary>
        Below,
    }
}


namespace WaveHarmonic.Crest.Generated
{
    enum WatertightHullMode
    {
        /// <summary>
        /// Use displacement to remove water.
        /// </summary>
        /// <remarks>
        /// Using displacement will also affect the underwater and can nest bouyant objects. Requires the displacement layer to be enabled.
        /// </remarks>
        Displacement,

        /// <summary>
        /// Clips the surface to remove water.
        /// </summary>
        /// <remarks>
        /// This option is more precise and can be submerged.
        /// </remarks>
        Clip,
    }
}