Game/Fishing2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

升级6.4.升级水，升级天气

Browse Source
This commit is contained in:
Bob.Song
2026-04-05 00:26:54 +08:00
parent 63bc9b5536
commit 5f7cbfb713
635 changed files with 34718 additions and 22567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

193
Packages/com.waveharmonic.crest/Runtime/Scripts/Generated/API.Generated.cs
View File

@@ -23,13 +23,9 @@ namespace WaveHarmonic.Crest
/// <summary>
/// Where to obtain water shape on CPU for physics / gameplay.
/// </summary>
[System.Obsolete("Please use QuerySource instead.")]
public CollisionSource CollisionSource { get => _CollisionSource; internal set => _CollisionSource = value; }
/// <summary>
/// Maximum number of wave queries that can be performed when using GPU queries.
/// </summary>
public int MaximumQueryCount => _MaximumQueryCount;
/// <summary>
/// Any water deeper than this will receive full wave strength.
/// </summary>
@@ -44,7 +40,12 @@ namespace WaveHarmonic.Crest
/// <remarks>
/// Set this to 2 to improve wave quality. In some cases like flowing rivers, this can make a substantial difference to visual stability. We recommend doubling the Resolution on the WaterRenderer component to preserve detail after making this change.
/// </remarks>
public float WaveResolutionMultiplier { get => _WaveResolutionMultiplier; set => _WaveResolutionMultiplier = value; }
public float WaveResolutionMultiplier { get => GetWaveResolutionMultiplier(); set => _WaveResolutionMultiplier = value; }
/// <summary>
/// The wave sampling method to determine quality and performance.
/// </summary>
public WaveSampling WaveSampling { get => _WaveSampling; set => _WaveSampling = value; }
}
}
@@ -321,6 +322,14 @@ namespace WaveHarmonic.Crest
/// </summary>
public UnityEngine.LayerMask Layers { get => _Layers; set => SetDirty(_Layers, _Layers = value); }
/// <summary>
/// Where the Depth Probe is placed.
/// </summary>
/// <remarks>
/// The default performs the best.
/// </remarks>
public Placement Placement { get => _Placement; set => _Placement = value; }
/// <summary>
/// Overrides global quality settings.
/// </summary>
@@ -424,6 +433,14 @@ namespace WaveHarmonic.Crest
/// Induce horizontal displacements to sharpen simulated waves.
/// </summary>
public float HorizontalDisplace { get => _HorizontalDisplace; set => _HorizontalDisplace = value; }
/// <summary>
/// Adds padding to water chunk bounds.
/// </summary>
/// <remarks>
/// Dynamic Waves displaces the surface which can push vertices outside of the chunk bounds leading to culling issues. This value adds padding to the chunk bounds to mitigate this.
/// </remarks>
public float VerticalDisplacementCullingContributions { get => _VerticalDisplacementCullingContributions; set => _VerticalDisplacementCullingContributions = value; }
}
}
@@ -661,6 +678,23 @@ namespace WaveHarmonic.Crest
{
partial class Lod
{
/// <summary>
/// Blurs the output.
/// </summary>
/// <remarks>
/// Enable if blurring is desired or intolerable artifacts are present.
/// The blur is optimized to only run on inner LODs and at lower scales.
/// </remarks>
public bool Blur { get => _Blur; set => SetDirty(_Blur, _Blur = value); }
/// <summary>
/// Number of blur iterations.
/// </summary>
/// <remarks>
/// Blur iterations are optimized to only run maximum iterations on the inner LODs.
/// </remarks>
public int BlurIterations { get => _BlurIterations; set => _BlurIterations = value; }
/// <summary>
/// Whether the simulation is enabled.
/// </summary>
@@ -697,6 +731,22 @@ namespace WaveHarmonic.Crest
}
}
namespace WaveHarmonic.Crest
{
partial class Lod<T>
{
/// <summary>
/// Maximum number of queries that can be performed when using GPU queries.
/// </summary>
public int MaximumQueryCount => _MaximumQueryCount;
/// <summary>
/// Where to obtain water data on CPU for physics / gameplay.
/// </summary>
public LodQuerySource QuerySource { get => _QuerySource; internal set => _QuerySource = value; }
}
}
namespace WaveHarmonic.Crest
{
partial class LodInput
@@ -752,6 +802,14 @@ namespace WaveHarmonic.Crest
{
partial class Meniscus
{
/// <summary>
/// Rules to exclude cameras from rendering the meniscus.
/// </summary>
/// <remarks>
/// These are exclusion rules, so for all cameras, select Nothing. These rules are applied on top of the Layer rules.
/// </remarks>
public WaterCameraExclusion CameraExclusions { get => _CameraExclusions; set => _CameraExclusions = value; }
/// <summary>
/// Whether the meniscus is enabled.
/// </summary>
@@ -942,6 +1000,14 @@ namespace WaveHarmonic.Crest
/// "Viewer" will reuse queries already performed by the Water Renderer
/// </remarks>
public QuerySource Source { get => _Source; set => _Source = value; }
/// <summary>
/// The viewer as the source of the queries.
/// </summary>
/// <remarks>
/// Only needs to be set if using multiple viewpoints on the Water Renderer.
/// </remarks>
public UnityEngine.Camera Viewer { get => _Viewer; set => _Viewer = value; }
}
}
@@ -1026,6 +1092,11 @@ namespace WaveHarmonic.Crest
{
partial class ShapeFFT
{
/// <summary>
/// Whether to apply the options shown when "Show Advanced Controls" is active.
/// </summary>
public bool ApplyAdvancedSpectrumControls { get => _ApplyAdvancedSpectrumControls; set => _ApplyAdvancedSpectrumControls = value; }
/// <summary>
/// Maximum amount a point on the surface will be displaced horizontally by waves from its rest position.
/// </summary>
@@ -1042,6 +1113,11 @@ namespace WaveHarmonic.Crest
/// </remarks>
public float MaximumVerticalDisplacement { get => _MaximumVerticalDisplacement; set => _MaximumVerticalDisplacement = value; }
/// <summary>
/// Whether to override automatic culling based on heuristics.
/// </summary>
public bool OverrideCulling { get => _OverrideCulling; set => _OverrideCulling = value; }
/// <summary>
/// Whether to use the wind turbulence on this component rather than the global wind turbulence.
/// </summary>
@@ -1116,6 +1192,14 @@ namespace WaveHarmonic.Crest
/// </remarks>
public bool EvaluateSpectrumAtRunTimeEveryFrame { get => _EvaluateSpectrumAtRunTimeEveryFrame; set => _EvaluateSpectrumAtRunTimeEveryFrame = value; }
/// <summary>
/// Whether the maximum possible vertical displacement is used for the Drop Detail Height Based On Waves calculation.
/// </summary>
/// <remarks>
/// This setting is ignored for global waves, as they always contribute. For local waves, only enable for large areas that are treated like global waves (eg a storm).
/// </remarks>
public bool IncludeInDropDetailHeightBasedOnWaves { get => _IncludeInDropDetailHeightBasedOnWaves; set => _IncludeInDropDetailHeightBasedOnWaves = value; }
/// <summary>
/// Whether to use the wind direction on this component rather than the global wind direction.
/// </summary>
@@ -1138,7 +1222,7 @@ namespace WaveHarmonic.Crest
/// <remarks>
/// Low resolutions are more efficient but can result in noticeable patterns in the shape.
/// </remarks>
public int Resolution { get => _Resolution; set => _Resolution = value; }
public int Resolution { get => GetResolution(); set => _Resolution = value; }
/// <summary>
/// How much these waves respect the shallow water attenuation.
@@ -1148,6 +1232,14 @@ namespace WaveHarmonic.Crest
/// </remarks>
public float RespectShallowWaterAttenuation { get => _RespectShallowWaterAttenuation; set => _RespectShallowWaterAttenuation = value; }
/// <summary>
/// Whether global waves is applied above or below sea level.
/// </summary>
/// <remarks>
/// Waves are faded out to avoid hard transitionds. They are fully faded by 1m from sea level.
/// </remarks>
public bool SeaLevelOnly { get => _SeaLevelOnly; set => _SeaLevelOnly = value; }
/// <summary>
/// The spectrum that defines the water surface shape.
/// </summary>
@@ -1273,6 +1365,14 @@ namespace WaveHarmonic.Crest
/// </remarks>
public bool AllowRenderQueueSorting { get => _AllowRenderQueueSorting; set => _AllowRenderQueueSorting = value; }
/// <summary>
/// Rules to exclude cameras from surface rendering.
/// </summary>
/// <remarks>
/// These are exclusion rules, so for all cameras, select Nothing. These rules are applied on top of the Layer rules.
/// </remarks>
public WaterCameraExclusion CameraExclusions { get => _CameraExclusions; set => _CameraExclusions = value; }
/// <summary>
/// Have the water surface cast shadows for albedo (both foam and custom).
/// </summary>
@@ -1296,6 +1396,14 @@ namespace WaveHarmonic.Crest
/// </summary>
public UnityEngine.Material Material { get => _Material; set => _Material = value; }
/// <summary>
/// Whether to support using the surface material with other renderers.
/// </summary>
/// <remarks>
/// Also requires enabling Custom Mesh on the material.
/// </remarks>
public bool SupportCustomRenderers { get => _SupportCustomRenderers; set => _SupportCustomRenderers = value; }
/// <summary>
/// How many frames to distribute the chunk bounds calculation.
/// </summary>
@@ -1351,8 +1459,17 @@ namespace WaveHarmonic.Crest
/// <remarks>
/// If disabled, then additionally ignore any camera that is not the view camera or our reflection camera. It will require managing culling masks of all cameras.
/// </remarks>
[System.Obsolete("Please use Camera Exclusion instead.")]
public bool AllCameras { get => _AllCameras; set => _AllCameras = value; }
/// <summary>
/// Rules to exclude cameras from rendering underwater.
/// </summary>
/// <remarks>
/// These are exclusion rules, so for all cameras, select Nothing. These rules are applied on top of the Layer rules.
/// </remarks>
public WaterCameraExclusion CameraExclusions { get => _CameraExclusions; set => _CameraExclusions = value; }
/// <summary>
/// Copying parameters each frame ensures underwater appearance stays consistent with the water surface.
/// </summary>
@@ -1369,6 +1486,11 @@ namespace WaveHarmonic.Crest
/// </remarks>
public float CullLimit { get => _CullLimit; set => _CullLimit = value; }
/// <summary>
/// Whether to enable culling of water chunks when below water.
/// </summary>
public bool EnableChunkCulling { get => _EnableChunkCulling; set => _EnableChunkCulling = value; }
/// <summary>
/// Whether the underwater effect is enabled.
/// </summary>
@@ -1506,6 +1628,7 @@ namespace WaveHarmonic.Crest
/// <summary>
/// Whether to allow MSAA.
/// </summary>
[System.Obsolete("MSAA for the planar reflection camera is no longer supported. This setting will be ignored.")]
public bool AllowMSAA { get => _AllowMSAA; set => _AllowMSAA = value; }
/// <summary>
@@ -1529,7 +1652,7 @@ namespace WaveHarmonic.Crest
/// <summary>
/// Disables shadows.
/// </summary>
public bool DisableShadows { get => _DisableShadows; set => _DisableShadows = value; }
public bool DisableShadows { get => _DisableShadows; set => SetDisableShadows(_DisableShadows, _DisableShadows = value); }
/// <summary>
/// Whether planar reflections are enabled.
@@ -1557,7 +1680,7 @@ namespace WaveHarmonic.Crest
/// <summary>
/// What side of the water surface to render planar reflections for.
/// </summary>
public WaterReflectionSide ReflectionSide { get => _Mode; set => _Mode = value; }
public WaterReflectionSide ReflectionSide { get => _Mode; set => SetReflectionSide(_Mode, _Mode = value); }
/// <summary>
/// Planar relfections using an oblique frustum for better performance.
@@ -1572,11 +1695,24 @@ namespace WaveHarmonic.Crest
/// </summary>
public float NonObliqueNearSurfaceThreshold { get => _NonObliqueNearSurfaceThreshold; set => _NonObliqueNearSurfaceThreshold = value; }
/// <summary>
/// Overscan amount to capture off-screen content.
/// </summary>
/// <remarks>
/// Renders the reflections at a larger viewport size to capture off-screen content when the surface reflects off-screen. This avoids a category of artifacts - especially when looking down. This can be expensive, as the value is a multiplier to the capture size.
/// </remarks>
public float Overscan { get => _Overscan; set => _Overscan = value; }
/// <summary>
/// Overrides global quality settings.
/// </summary>
public QualitySettingsOverride QualitySettingsOverride { get => _QualitySettingsOverride; set => _QualitySettingsOverride = value; }
/// <summary>
/// Renderer index for the reflection camera.
/// </summary>
public int RendererIndex { get => _RendererIndex; set => SetRendererIndex(_RendererIndex, _RendererIndex = value); }
/// <summary>
/// Whether to render to the viewer camera only.
/// </summary>
@@ -1649,6 +1785,14 @@ namespace WaveHarmonic.Crest
/// </remarks>
public UnityEngine.Camera Viewer { get => GetViewer(); set => _Camera = value; }
/// <summary>
/// Rules to exclude cameras from being a center-of-detail.
/// </summary>
/// <remarks>
/// These are exclusion rules, so for all cameras, select Nothing.
/// </remarks>
public WaterCameraExclusion CameraExclusions { get => _CameraExclusions; set => _CameraExclusions = value; }
/// <summary>
/// Have the water surface cast shadows for albedo (both foam and custom).
/// </summary>
@@ -1668,6 +1812,14 @@ namespace WaveHarmonic.Crest
/// </summary>
public ClipLod ClipLod => _ClipLod;
/// <summary>
/// The background rendering mode when a camera does not render.
/// </summary>
/// <remarks>
/// When switching between multiple cameras, simulations will not progress for cameras which do not render for that frame. This setting tells the system when it should continue to progress the simulations.
/// </remarks>
public WaterDataBackgroundMode DataBackgroundMode { get => _DataBackgroundMode; set => _DataBackgroundMode = value; }
/// <summary>
/// Water depth information used for shallow water, shoreline foam, wave attenuation, among others.
/// </summary>
@@ -1773,6 +1925,27 @@ namespace WaveHarmonic.Crest
/// </remarks>
public bool OverrideRenderHDR { get => _OverrideRenderHDR; set => _OverrideRenderHDR = value; }
#if d_UnityModuleWind
/// <summary>
/// Whether to override the given wind zone's wind direction.
/// </summary>
public bool OverrideWindZoneWindDirection { get => _OverrideWindZoneWindDirection; set => _OverrideWindZoneWindDirection = value; }
#endif
#if d_UnityModuleWind
/// <summary>
/// Whether to override the given wind zone's wind speed.
/// </summary>
public bool OverrideWindZoneWindSpeed { get => _OverrideWindZoneWindSpeed; set => _OverrideWindZoneWindSpeed = value; }
#endif
#if d_UnityModuleWind
/// <summary>
/// Whether to override the given wind zone's wind turbulence.
/// </summary>
public bool OverrideWindZoneWindTurbulence { get => _OverrideWindZoneWindTurbulence; set => _OverrideWindZoneWindTurbulence = value; }
#endif
/// <summary>
/// The portal renderer.
/// </summary>
@@ -1918,6 +2091,7 @@ namespace WaveHarmonic.Crest
/// </remarks>
public float WindTurbulence { get => GetWindTurbulence(); set => _WindTurbulence = value; }
#if d_UnityModuleWind
/// <summary>
/// Uses a provided WindZone as the source of global wind.
/// </summary>
@@ -1925,6 +2099,7 @@ namespace WaveHarmonic.Crest
/// It must be directional. Wind speed units are presumed to be in m/s.
/// </remarks>
public UnityEngine.WindZone WindZone { get => _WindZone; set => _WindZone = value; }
#endif
/// <summary>
/// Whether to enable motion vector support.

130
Packages/com.waveharmonic.crest/Runtime/Scripts/Generated/Documentation.Generated.cs
View File

@@ -29,11 +29,6 @@ namespace WaveHarmonic.Crest.Generated
{
enum CollisionLayers
{
/// <summary>
/// All layers.
/// </summary>
Everything,
/// <summary>
/// No extra layers (ie single layer).
/// </summary>
@@ -51,6 +46,11 @@ namespace WaveHarmonic.Crest.Generated
/// Extra displacement layer for visual displacement.
/// </summary>
Displacement,
/// <summary>
/// All layers.
/// </summary>
Everything,
}
}
@@ -123,6 +123,11 @@ namespace WaveHarmonic.Crest.Generated
/// </summary>
OnStart,
/// <summary>
/// Populates the DepthProbe every frame.
/// </summary>
EveryFrame,
/// <summary>
/// Requires manual updating via DepthProbe.Populate.
/// </summary>
@@ -288,6 +293,31 @@ namespace WaveHarmonic.Crest.Generated
}
namespace WaveHarmonic.Crest.Generated
{
enum LodQuerySource
{
/// <summary>
/// No query source.
/// </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 LodTextureFormatMode
@@ -385,6 +415,68 @@ namespace WaveHarmonic.Crest.Generated
}
namespace WaveHarmonic.Crest.Generated
{
enum WaterCameraExclusion
{
/// <summary>
/// No exclusion rules applied.
/// </summary>
Nothing,
/// <summary>
/// Exclude hidden cameras.
/// </summary>
/// <remarks>
/// Does not affect reflection cameras, as they are typically always hidden. Use the Reflection flag for them.
/// </remarks>
Hidden,
/// <summary>
/// Exclude reflection cameras.
/// </summary>
Reflection,
/// <summary>
/// Exclude cameras not tagged as MainCamera.
/// </summary>
NonMainCamera,
/// <summary>
/// Apply all exclusion rules.
/// </summary>
Everything,
}
}
namespace WaveHarmonic.Crest.Generated
{
enum WaterDataBackgroundMode
{
/// <summary>
/// Always progress simulations in the background when camera does not render.
/// </summary>
Always,
/// <summary>
/// Progress simulations in the background when camera is inactive (ie !isActiveAndEnabled).
/// </summary>
Inactive,
/// <summary>
/// Progress simulations in the background when camera is disabled (ie !enabled).
/// </summary>
Disabled,
/// <summary>
/// Never progress simulations in the background.
/// </summary>
Never,
}
}
namespace WaveHarmonic.Crest.Generated
{
enum WaterInjectionPoint
@@ -451,3 +543,31 @@ namespace WaveHarmonic.Crest.Generated
Clip,
}
}
namespace WaveHarmonic.Crest.Generated
{
enum WaveSampling
{
/// <summary>
/// Automatically chooses the other options as needed (512+ resolution needs precision).
/// </summary>
Automatic,
/// <summary>
/// Reduces samples by copying waves from higher LODs to lower LODs.
/// </summary>
/// <remarks>
/// Best for resolutions lower than 512.
/// </remarks>
Performance,
/// <summary>
/// Samples directly from the wave buffers to preserve wave quality.
/// </summary>
/// <remarks>
/// Needed for higher resolutions (512+). Higher LOD counts can also benefit with this enabled.
/// </remarks>
Precision,
}
}