alexandru.diaconescu/ici_recycle_vr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
ici_recycle_vr/Assets/LiquidVolumePro/Scripts/LiquidVolume.cs
Diaconescu Andrei-Alexandru 19674bfe5d Am adaugat ICI Recycle
2025-05-26 12:54:36 +03:00

3702 lines
134 KiB
C#
Raw Permalink Blame History

/**************************************/
/* LIQUID VOLUME PRO 2 */
/* Created by Kronnect */
/**************************************/
// Enable floating point render textures
#define LIQUID_VOLUME_FP_RENDER_TEXTURES
// Displays sliced liquid volume
//#define DEBUG_SLICE
using UnityEngine;
using UnityEngine.Rendering;
using System;
using System.Collections.Generic;
using LiquidVolumeFX.MIConvexHull;
using System.Linq;
using Random = UnityEngine.Random;
using UnityEngine.XR;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace LiquidVolumeFX {
public enum TOPOLOGY {
Sphere = 0,
Cylinder = 1,
Cube = 2,
Irregular = 10
}
public enum DETAIL {
Simple = 0,
SimpleNoFlask = 1,
Default = 10,
DefaultNoFlask = 11,
Multiple = 50,
MultipleNoFlask = 51
}
public enum LEVEL_COMPENSATION {
None = 0,
Fast = 10,
Accurate = 20
}
public enum BuoyancyEffect {
Simple = 0,
PositionOnly = 1,
PositionAndRotation = 2
}
public static class DetailExtensions {
public static bool isMultiple(this DETAIL detail) {
return detail == DETAIL.Multiple || detail == DETAIL.MultipleNoFlask;
}
public static bool allowsRefraction(this DETAIL detail) {
return detail != DETAIL.DefaultNoFlask && detail != DETAIL.MultipleNoFlask;
}
public static bool usesFlask(this DETAIL detail) {
return detail == DETAIL.Simple || detail == DETAIL.Default || detail == DETAIL.Multiple;
}
}
[ExecuteInEditMode]
[HelpURL("https://kronnect.com/support")]
[AddComponentMenu("Effects/Liquid Volume")]
[DisallowMultipleComponent]
public partial class LiquidVolume : MonoBehaviour {
public static bool FORCE_GLES_COMPATIBILITY = false;
/// <summary>
/// Max number of layers for multiple style
/// </summary>
public const int MAX_LAYERS = 16;
[Serializable]
public struct LiquidLayer {
[HideInInspector] public string layerName;
public float amount;
[Tooltip("Density defines the order in which layers stack up. Two or more liquids with same density and miscible set to true will mix.")]
public float density;
public Color color;
[Tooltip("If miscible is set to true, this liquid will mix with any other with same density.")]
public bool miscible;
[Range(0, 1)]
public float murkiness;
public Color murkColor;
[Range(0.001f, 0.48f)]
public float scale;
[Range(0, 1), Tooltip("The viscosity determines the influence of global turbulence to this liquid. A value of 0 means sticky while a value of 1 means a very fluid substance.")]
public float viscosity;
[Range(0.001f, 10)]
public float adjustmentSpeed;
[Range(0, 1), Tooltip("Bubbles opacity.")]
public float bubblesOpacity;
[NonSerialized]
public float mixedAmount, mixedScale, mixedMurkiness;
[NonSerialized]
public Color mixedColor;
[NonSerialized]
public Color mixedColor2;
[NonSerialized]
public float mixedBubblesOpacity;
[HideInInspector]
public float baseLevel;
[HideInInspector]
public float currentBaseLevel;
[HideInInspector]
public float currentAmount;
[HideInInspector]
public Color currentColor;
[HideInInspector]
public float currentMurkiness;
[HideInInspector]
public Color currentColor2;
[HideInInspector]
public float currentBubblesOpacity;
public void SetDefaults(int layerIndex) {
amount = 0.1f;
density = 1f;
color = new Color(Random.value, Random.value, Random.value, 0.5f);
murkColor = new Color(0, 0, 0, 1f);
murkiness = 0.5f;
scale = 0.3f;
adjustmentSpeed = 1f;
viscosity = 1f;
bubblesOpacity = 1f;
layerName = "Layer " + layerIndex;
}
public void ResetCurrentStates() {
currentColor = color;
currentColor2 = murkColor;
currentMurkiness = murkiness;
currentAmount = amount;
currentBaseLevel = baseLevel;
currentBubblesOpacity = bubblesOpacity;
}
}
[SerializeField]
TOPOLOGY _topology = TOPOLOGY.Sphere;
public TOPOLOGY topology {
get { return _topology; }
set {
if (_topology != value) {
_topology = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
DETAIL _detail = DETAIL.Default;
public DETAIL detail {
get { return _detail; }
set {
if (_detail != value) {
_detail = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _level = 0.5f;
public float level {
get { return _level; }
set {
if (_level != value) {
if (_detail.isMultiple()) {
Debug.LogWarning("In multiple detail level, fill level is automatically determined by the amount/density values in each layer.");
return;
}
_level = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _levelMultiplier = 1f;
public float levelMultiplier {
get { return _levelMultiplier; }
set {
if (_levelMultiplier != value) {
_levelMultiplier = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
LiquidLayer[] _liquidLayers;
public LiquidLayer[] liquidLayers {
get { return _liquidLayers; }
set {
if (_liquidLayers != value) {
_liquidLayers = value;
lastLayerCount = 0;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 16)]
int _smoothContactSurface = 3;
public int smoothContactSurface {
get { return _smoothContactSurface; }
set {
if (_smoothContactSurface != value) {
_smoothContactSurface = value;
requireLayersUpdate = true;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _ditherStrength = 0.5f;
public float ditherStrength {
get { return _ditherStrength; }
set {
if (_ditherStrength != value) {
_ditherStrength = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.001f, 10)]
float _layersAdjustmentSpeed = 1f;
public float layersAdjustmentSpeed {
get { return _layersAdjustmentSpeed; }
set {
if (_layersAdjustmentSpeed != value) {
_layersAdjustmentSpeed = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _layersAdjustmentCompact = true;
public bool layersAdjustmentCompact {
get { return _layersAdjustmentCompact; }
set {
if (_layersAdjustmentCompact != value) {
_layersAdjustmentCompact = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Tooltip("Uses directional light color")]
bool _useLightColor;
public bool useLightColor {
get { return _useLightColor; }
set {
if (_useLightColor != value) {
_useLightColor = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Light _directionalLight;
public Light directionalLight {
get { return _directionalLight; }
set {
if (_directionalLight != value) {
_directionalLight = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[ColorUsage(true)]
Color _liquidColor1 = new Color(0, 1, 0, 0.1f);
public Color liquidColor1 {
get { return _liquidColor1; }
set {
if (_liquidColor1 != value) {
_liquidColor1 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.1f, 4.85f)]
float _liquidScale1 = 1f;
public float liquidScale1 {
get { return _liquidScale1; }
set {
if (_liquidScale1 != value) {
_liquidScale1 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[ColorUsage(true)]
Color _liquidColor2 = new Color(1, 0, 0, 0.3f);
public Color liquidColor2 {
get { return _liquidColor2; }
set {
if (_liquidColor2 != value) {
_liquidColor2 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(2f, 4.85f)]
float _liquidScale2 = 5f;
public float liquidScale2 {
get { return _liquidScale2; }
set {
if (_liquidScale2 != value) {
_liquidScale2 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _alpha = 1f;
public float alpha {
get { return _alpha; }
set {
if (_alpha != Mathf.Clamp01(value)) {
_alpha = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
[SerializeField]
[ColorUsage(true)]
Color _emissionColor = new Color(0, 0, 0);
public Color emissionColor {
get { return _emissionColor; }
set {
if (_emissionColor != value) {
_emissionColor = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _ditherShadows = true;
public bool ditherShadows {
get { return _ditherShadows; }
set {
if (_ditherShadows != value) {
_ditherShadows = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _murkiness = 1.0f;
public float murkiness {
get { return _murkiness; }
set {
if (_murkiness != value) {
_murkiness = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1f)]
float _turbulence1 = 0.5f;
public float turbulence1 {
get { return _turbulence1; }
set {
if (_turbulence1 != value) {
_turbulence1 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1f)]
float _turbulence2 = 0.2f;
public float turbulence2 {
get { return _turbulence2; }
set {
if (_turbulence2 != value) {
_turbulence2 = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _frecuency = 1f;
public float frecuency {
get { return _frecuency; }
set {
if (_frecuency != value) {
_frecuency = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0f, 2f)]
float _speed = 1f;
public float speed {
get { return _speed; }
set {
if (_speed != value) {
_speed = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 5f)]
float _sparklingIntensity = 0.1f;
public float sparklingIntensity {
get { return _sparklingIntensity; }
set {
if (_sparklingIntensity != value) {
_sparklingIntensity = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _sparklingAmount = 0.2f;
public float sparklingAmount {
get { return _sparklingAmount; }
set {
if (_sparklingAmount != value) {
_sparklingAmount = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10)]
float _deepObscurance = 2.0f;
public float deepObscurance {
get { return _deepObscurance; }
set {
if (_deepObscurance != value) {
_deepObscurance = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[ColorUsage(true)]
Color _foamColor = new Color(1, 1, 1, 0.65f);
public Color foamColor {
get { return _foamColor; }
set {
if (_foamColor != value) {
_foamColor = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.01f, 1f)]
float _foamScale = 0.2f;
public float foamScale {
get { return _foamScale; }
set {
if (_foamScale != value) {
_foamScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 0.1f)]
float _foamThickness = 0.04f;
public float foamThickness {
get { return _foamThickness; }
set {
if (_foamThickness != value) {
_foamThickness = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(-1, 1)]
float _foamDensity = 0.5f;
public float foamDensity {
get { return _foamDensity; }
set {
if (_foamDensity != value) {
_foamDensity = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(4, 100)]
float _foamWeight = 10f;
public float foamWeight {
get { return _foamWeight; }
set {
if (_foamWeight != value) {
_foamWeight = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _foamTurbulence = 1f;
public float foamTurbulence {
get { return _foamTurbulence; }
set {
if (_foamTurbulence != value) {
_foamTurbulence = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _foamVisibleFromBottom = true;
public bool foamVisibleFromBottom {
get { return _foamVisibleFromBottom; }
set {
if (_foamVisibleFromBottom != value) {
_foamVisibleFromBottom = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _smokeEnabled = true;
public bool smokeEnabled {
get { return _smokeEnabled; }
set {
if (_smokeEnabled != value) {
_smokeEnabled = value;
UpdateMaterialProperties();
}
}
}
[ColorUsage(true)]
[SerializeField]
Color _smokeColor = new Color(0.7f, 0.7f, 0.7f, 0.25f);
public Color smokeColor {
get { return _smokeColor; }
set {
if (_smokeColor != value) {
_smokeColor = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.01f, 1f)]
float _smokeScale = 0.25f;
public float smokeScale {
get { return _smokeScale; }
set {
if (_smokeScale != value) {
_smokeScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10f)]
float _smokeBaseObscurance = 2.0f;
public float smokeBaseObscurance {
get { return _smokeBaseObscurance; }
set {
if (_smokeBaseObscurance != value) {
_smokeBaseObscurance = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10f)]
float _smokeHeightAtten;
public float smokeHeightAtten {
get { return _smokeHeightAtten; }
set {
if (_smokeHeightAtten != value) {
_smokeHeightAtten = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 20f)]
float _smokeSpeed = 5.0f;
public float smokeSpeed {
get { return _smokeSpeed; }
set {
if (_smokeSpeed != value) {
_smokeSpeed = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _fixMesh;
public bool fixMesh {
get { return _fixMesh; }
set {
if (_fixMesh != value) {
_fixMesh = value;
UpdateMaterialProperties();
}
}
}
public Mesh originalMesh;
public Vector3 originalPivotOffset;
[SerializeField]
Vector3 _pivotOffset;
public Vector3 pivotOffset {
get { return _pivotOffset; }
set {
if (_pivotOffset != value) {
_pivotOffset = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _autoCloseMesh;
public bool autoCloseMesh {
get { return _autoCloseMesh; }
set {
if (_autoCloseMesh != value) {
_autoCloseMesh = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1.5f)]
float _upperLimit = 1.5f;
public float upperLimit {
get { return _upperLimit; }
set {
if (_upperLimit != value) {
_upperLimit = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(-1.5f, 1.5f)]
float _lowerLimit = -1.5f;
public float lowerLimit {
get { return _lowerLimit; }
set {
if (_lowerLimit != value) {
_lowerLimit = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
int _subMeshIndex = -1;
public int subMeshIndex {
get { return _subMeshIndex; }
set {
if (_subMeshIndex != value) {
_subMeshIndex = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Material _flaskMaterial;
public Material flaskMaterial {
get { return _flaskMaterial; }
set {
if (_flaskMaterial != value) {
_flaskMaterial = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _flaskThickness = 0.03f;
public float flaskThickness {
get { return _flaskThickness; }
set {
if (_flaskThickness != value) {
_flaskThickness = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _glossinessInternal = 0.3f;
public float glossinessInternal {
get { return _glossinessInternal; }
set {
if (_glossinessInternal != value) {
_glossinessInternal = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _scatteringEnabled = false;
public bool scatteringEnabled {
get { return _scatteringEnabled; }
set {
if (_scatteringEnabled != value) {
_scatteringEnabled = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(1, 16)]
int _scatteringPower = 5;
public int scatteringPower {
get { return _scatteringPower; }
set {
if (_scatteringPower != value) {
_scatteringPower = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10)]
float _scatteringAmount = 0.3f;
public float scatteringAmount {
get { return _scatteringAmount; }
set {
if (_scatteringAmount != value) {
_scatteringAmount = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _refractionBlur = true;
public bool refractionBlur {
get { return _refractionBlur; }
set {
if (_refractionBlur != value) {
_refractionBlur = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1)]
float _blurIntensity = 0.75f;
public float blurIntensity {
get { return _blurIntensity; }
set {
if (_blurIntensity != Mathf.Clamp01(value)) {
_blurIntensity = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
[SerializeField]
int _liquidRaySteps = 10;
public int liquidRaySteps {
get { return _liquidRaySteps; }
set {
if (_liquidRaySteps != value) {
_liquidRaySteps = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
int _foamRaySteps = 7;
public int foamRaySteps {
get { return _foamRaySteps; }
set {
if (_foamRaySteps != value) {
_foamRaySteps = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
int _smokeRaySteps = 5;
public int smokeRaySteps {
get { return _smokeRaySteps; }
set {
if (_smokeRaySteps != value) {
_smokeRaySteps = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Texture2D _bumpMap;
public Texture2D bumpMap {
get { return _bumpMap; }
set {
if (_bumpMap != value) {
_bumpMap = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 1f)]
float _bumpStrength = 1f;
public float bumpStrength {
get { return _bumpStrength; }
set {
if (_bumpStrength != value) {
_bumpStrength = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10f)]
float _bumpDistortionScale = 1f;
public float bumpDistortionScale {
get { return _bumpDistortionScale; }
set {
if (_bumpDistortionScale != value) {
_bumpDistortionScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Vector2 _bumpDistortionOffset;
public Vector2 bumpDistortionOffset {
get { return _bumpDistortionOffset; }
set {
if (_bumpDistortionOffset != value) {
_bumpDistortionOffset = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Texture2D _distortionMap;
public Texture2D distortionMap {
get { return _distortionMap; }
set {
if (_distortionMap != value) {
_distortionMap = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Texture2D _texture;
public Texture2D texture {
get { return _texture; }
set {
if (_texture != value) {
_texture = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Vector2
_textureScale = Vector2.one;
public Vector2 textureScale {
get { return _textureScale; }
set {
if (_textureScale != value) {
_textureScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Vector2
_textureOffset;
public Vector2 textureOffset {
get { return _textureOffset; }
set {
if (_textureOffset != value) {
_textureOffset = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 10f)]
float
_distortionAmount = 1f;
public float distortionAmount {
get { return _distortionAmount; }
set {
if (_distortionAmount != value) {
_distortionAmount = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _depthAware;
public bool depthAware {
get { return _depthAware; }
set {
if (_depthAware != value) {
_depthAware = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _depthAwareOffset;
public float depthAwareOffset {
get { return _depthAwareOffset; }
set {
if (_depthAwareOffset != value) {
_depthAwareOffset = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _irregularDepthDebug = false;
public bool irregularDepthDebug {
get { return _irregularDepthDebug; }
set {
if (_irregularDepthDebug != value) {
_irregularDepthDebug = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _depthAwareCustomPass;
public bool depthAwareCustomPass {
get { return _depthAwareCustomPass; }
set {
if (_depthAwareCustomPass != value) {
_depthAwareCustomPass = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _depthAwareCustomPassDebug = false;
public bool depthAwareCustomPassDebug {
get { return _depthAwareCustomPassDebug; }
set {
if (_depthAwareCustomPassDebug != value) {
_depthAwareCustomPassDebug = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0, 5f)]
float _doubleSidedBias = 0.001f;
public float doubleSidedBias {
get { return _doubleSidedBias; }
set {
if (_doubleSidedBias != value) {
_doubleSidedBias = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _backDepthBias;
public float backDepthBias {
get { return _backDepthBias; }
set {
if (value < 0) value = 0;
if (_backDepthBias != value) {
_backDepthBias = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
LEVEL_COMPENSATION _rotationLevelCompensation = LEVEL_COMPENSATION.None;
public LEVEL_COMPENSATION rotationLevelCompensation {
get { return _rotationLevelCompensation; }
set {
if (_rotationLevelCompensation != value) {
_rotationLevelCompensation = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _ignoreGravity;
public bool ignoreGravity {
get { return _ignoreGravity; }
set {
if (_ignoreGravity != value) {
_ignoreGravity = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _reactToForces;
public bool reactToForces {
get { return _reactToForces; }
set {
if (_reactToForces != value) {
_reactToForces = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Vector3 _extentsScale = Vector3.one;
public Vector3 extentsScale {
get { return _extentsScale; }
set {
if (_extentsScale != value) {
_extentsScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(1, 3)]
int _noiseVariation = 1;
public int noiseVariation {
get { return _noiseVariation; }
set {
if (_noiseVariation != value) {
_noiseVariation = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
bool _allowViewFromInside = false;
public bool allowViewFromInside {
get { return _allowViewFromInside; }
set {
if (_allowViewFromInside != value) {
_allowViewFromInside = value;
lastDistanceToCam = -1;
CheckInsideOut();
}
}
}
[SerializeField]
bool
_debugSpillPoint = false;
public bool debugSpillPoint {
get { return _debugSpillPoint; }
set {
if (_debugSpillPoint != value) {
_debugSpillPoint = value;
}
}
}
[SerializeField]
int
_renderQueue = 3001;
public int renderQueue {
get { return _renderQueue; }
set {
if (_renderQueue != value) {
_renderQueue = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
Cubemap _reflectionTexture;
public Cubemap reflectionTexture {
get { return _reflectionTexture; }
set {
if (_reflectionTexture != value) {
_reflectionTexture = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.1f, 5f)]
float _physicsMass = 1f;
public float physicsMass {
get { return _physicsMass; }
set {
if (_physicsMass != value) {
_physicsMass = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
[Range(0.0f, 0.2f)]
float _physicsAngularDamp = 0.02f;
public float physicsAngularDamp {
get { return _physicsAngularDamp; }
set {
if (_physicsAngularDamp != value) {
_physicsAngularDamp = value;
UpdateMaterialProperties();
}
}
}
#region Bubbles properties
[SerializeField]
int _bubblesAmount = 32;
public int bubblesAmount {
get { return _bubblesAmount; }
set {
if (_bubblesAmount != value) {
_bubblesAmount = value;
requireBubblesUpdate = true;
UpdateMaterialProperties();
}
}
}
[SerializeField, Range(1, 16)]
int _bubblesSizeMin = 2;
public int bubblesSizeMin {
get { return _bubblesSizeMin; }
set {
if (_bubblesSizeMin != value) {
_bubblesSizeMin = value;
requireBubblesUpdate = true;
UpdateMaterialProperties();
}
}
}
[SerializeField, Range(1, 16)]
int _bubblesSizeMax = 4;
public int bubblesSizeMax {
get { return _bubblesSizeMax; }
set {
if (_bubblesSizeMax != value) {
_bubblesSizeMax = value;
requireBubblesUpdate = true;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _bubblesScale = 3f;
public float bubblesScale {
get { return _bubblesScale; }
set {
if (_bubblesScale != value) {
_bubblesScale = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _bubblesBrightness = 1;
public float bubblesBrightness {
get { return _bubblesBrightness; }
set {
if (_bubblesBrightness != value) {
_bubblesBrightness = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
float _bubblesVerticalSpeed = 1;
public float bubblesVerticalSpeed {
get { return _bubblesVerticalSpeed; }
set {
if (_bubblesVerticalSpeed != value) {
_bubblesVerticalSpeed = value;
UpdateMaterialProperties();
}
}
}
[SerializeField]
int _bubblesSeed = 1;
public int bubblesSeed {
get { return _bubblesSeed; }
set {
if (_bubblesSeed != value) {
_bubblesSeed = value;
requireBubblesUpdate = true;
UpdateMaterialProperties();
}
}
}
#endregion
#region Point Light support
[Serializable]
public struct PointLightParams {
[HideInInspector]
public string name;
[NonSerialized]
public Vector3 localPosition;
[NonSerialized]
public Vector3 accel;
[NonSerialized]
public float nextTargetTime;
public Vector3 targetPos;
public bool randomTarget;
public Vector3 randomTargetCenter;
public float randomTargetRadius;
public float nextTargetInterval;
public float moveSpeed;
public float lightRange;
public float intensityMin, intensityMax;
public float intensitySpeed;
public Color color1, color2;
public float colorSpeed;
}
[SerializeField]
bool _pointLightsEnabled;
public bool pointLightsEnabled {
get { return _pointLightsEnabled; }
set {
if (_pointLightsEnabled != value) {
_pointLightsEnabled = value;
UpdateMaterialProperties();
}
}
}
public PointLightParams[] pointLightParams;
public float pointLightsScatteringAmount = 0.8f;
public float pointLightsIntensity = 1f;
public float pointLightInsideAtten;
#endregion
#if LIQUID_VOLUME_FP_RENDER_TEXTURES
public static bool useFPRenderTextures => true;
#else
public static bool useFPRenderTextures => false;
#endif
// ---- INTERNAL CODE ----
const int SHADER_KEYWORD_DEPTH_AWARE_INDEX = 0;
const int SHADER_KEYWORD_DEPTH_AWARE_CUSTOM_PASS_INDEX = 1;
const int SHADER_KEYWORD_IGNORE_GRAVITY_INDEX = 2;
const int SHADER_KEYWORD_NON_AABB_INDEX = 3;
const int SHADER_KEYWORD_TOPOLOGY_INDEX = 4;
const int SHADER_KEYWORD_REFRACTION_INDEX = 5;
const string SHADER_KEYWORD_DEPTH_AWARE = "LIQUID_VOLUME_DEPTH_AWARE";
const string SHADER_KEYWORD_DEPTH_AWARE_CUSTOM_PASS = "LIQUID_VOLUME_DEPTH_AWARE_PASS";
const string SHADER_KEYWORD_NON_AABB = "LIQUID_VOLUME_NON_AABB";
const string SHADER_KEYWORD_IGNORE_GRAVITY = "LIQUID_VOLUME_IGNORE_GRAVITY";
const string SHADER_KEYWORD_SPHERE = "LIQUID_VOLUME_SPHERE";
const string SHADER_KEYWORD_CUBE = "LIQUID_VOLUME_CUBE";
const string SHADER_KEYWORD_CYLINDER = "LIQUID_VOLUME_CYLINDER";
const string SHADER_KEYWORD_IRREGULAR = "LIQUID_VOLUME_IRREGULAR";
const string SHADER_KEYWORD_FP_RENDER_TEXTURE = "LIQUID_VOLUME_FP_RENDER_TEXTURES";
const string SHADER_KEYWORD_USE_REFRACTION = "LIQUID_VOLUME_USE_REFRACTION";
const string SPILL_POINT_GIZMO = "SpillPointGizmo";
[NonSerialized]
public Material liqMat;
Material liqMatSimple, liqMatDefaultNoFlask, liqMatMultipleNoFlask;
Mesh mesh;
[NonSerialized]
public Renderer mr;
readonly static List<Material> mrSharedMaterials = new List<Material>();
Vector3 lastPosition, lastScale;
Quaternion lastRotation;
string[] shaderKeywords;
bool camInside;
float lastDistanceToCam;
DETAIL currentDetail;
Vector4 turb, shaderTurb;
float turbulenceSpeed, murkinessSpeed, bubblesVerticalSpeedAcum;
float liquidLevelPos;
bool shouldUpdateMaterialProperties;
int currentNoiseVariation;
float levelMultipled;
// Multiple layers
Color[] layersTextureColors, layersTextureColors2, layersTextureColorsTemp;
Vector4[] layersProperties;
Texture2D layersPropertiesTex, layersColorsTex, layersColors2Tex;
Texture2D noise3DUnwrapped;
Texture3D[] noise3DTex;
Color[][] colors3D, colors3DWithBubbles;
Color[] layersColorsTexContents, layersColors2TexContents;
Color[] layersPropertiesTexContents;
float[] layersSum;
[NonSerialized]
public bool requireLayersUpdate;
[NonSerialized]
public bool requireBubblesUpdate;
int[] sortedLayers;
int sortedLayersCount;
int lastLayerCount;
bool immediate;
// Mesh info
Vector3[] verticesUnsorted, verticesSorted;
static Vector3[] rotatedVertices;
int[] verticesIndices;
float volumeRef, lastLevelVolumeRef;
// Physics
Vector3 prevVelocity, prev2Velocity, inertia, lastAvgVelocity;
float angularVelocity, angularInertia;
float turbulenceDueForces;
Quaternion liquidRot;
float prevThickness;
// Spill point debug
GameObject spillPointGizmo;
static string[] defaultContainerNames = {
"GLASS",
"CONTAINER",
"BOTTLE",
"POTION",
"FLASK",
"LIQUID"
};
// Point light effects
Color[] pointLightColorBuffer;
Vector4[] pointLightPositionBuffer;
int lastPointLightCount;
#region Gameloop events
void OnEnable() {
if (!gameObject.activeInHierarchy)
return;
levelMultipled = _level * _levelMultiplier;
turb.z = 1f;
turbulenceDueForces = 0f;
turbulenceSpeed = 1f;
liquidRot = transform.rotation;
currentDetail = _detail;
currentNoiseVariation = -1;
lastPosition = transform.position;
lastRotation = transform.rotation;
lastScale = transform.localScale;
prevThickness = _flaskThickness;
if (_depthAwareCustomPass && transform.parent == null) {
_depthAwareCustomPass = false;
}
InitLayers();
UpdateMaterialPropertiesNow();
PointLightsInitialize();
if (!Application.isPlaying) {
if (_detail.isMultiple()) {
requireLayersUpdate = true;
}
shouldUpdateMaterialProperties = true;
}
}
void Reset() {
// Try to assign propert topology based on mesh
if (mesh == null)
return;
if (mesh.vertexCount == 24) {
topology = TOPOLOGY.Cube;
} else {
Renderer renderer = GetComponent<Renderer>();
if (renderer == null) {
if (mesh.bounds.extents.y > mesh.bounds.extents.x) {
topology = TOPOLOGY.Cylinder;
}
} else if (renderer.bounds.extents.y > renderer.bounds.extents.x) {
topology = TOPOLOGY.Cylinder;
if (!Application.isPlaying) {
if (transform.rotation.eulerAngles != Vector3.zero && (mesh.bounds.extents.y <= mesh.bounds.extents.x || mesh.bounds.extents.y <= mesh.bounds.extents.z)) {
Debug.LogWarning("Intrinsic model rotation detected. Consider using the Bake Transform and/or Center Pivot options in Advanced section.");
}
}
}
}
}
void OnDestroy() {
RestoreOriginalMesh();
liqMat = null;
if (liqMatSimple != null) {
DestroyImmediate(liqMatSimple);
liqMatSimple = null;
}
if (liqMatDefaultNoFlask != null) {
DestroyImmediate(liqMatDefaultNoFlask);
liqMatDefaultNoFlask = null;
}
if (liqMatMultipleNoFlask != null) {
DestroyImmediate(liqMatMultipleNoFlask);
liqMatMultipleNoFlask = null;
}
if (noise3DTex != null) {
for (int k = 0; k < noise3DTex.Length; k++) {
Texture3D tex = noise3DTex[k];
if (tex != null && tex.name.Contains("Clone")) {
DestroyImmediate(tex);
noise3DTex[k] = null;
}
}
}
LiquidVolumeDepthPrePassRenderFeature.RemoveLiquidFromBackRenderers(this);
LiquidVolumeDepthPrePassRenderFeature.RemoveLiquidFromFrontRenderers(this);
}
void RenderObject() {
var act = gameObject.activeInHierarchy && enabled;
if (shouldUpdateMaterialProperties || !Application.isPlaying) {
shouldUpdateMaterialProperties = false;
UpdateMaterialPropertiesNow();
}
if (act && _allowViewFromInside) {
CheckInsideOut();
}
if (_detail.isMultiple()) {
AnimateLayers();
}
UpdateAnimations();
if (_pointLightsEnabled) {
UpdateLightEffects();
}
if (!act || _topology != TOPOLOGY.Irregular) {
LiquidVolumeDepthPrePassRenderFeature.RemoveLiquidFromBackRenderers(this);
} else if (_topology == TOPOLOGY.Irregular) {
LiquidVolumeDepthPrePassRenderFeature.AddLiquidToBackRenderers(this);
}
Transform parent = transform.parent;
if (parent != null) {
Renderer parentRenderer = GetComponentInParent<Renderer>();
if (!act || !_depthAwareCustomPass) {
LiquidVolumeDepthPrePassRenderFeature.RemoveLiquidFromFrontRenderers(this);
} else if (_depthAwareCustomPass) {
LiquidVolumeDepthPrePassRenderFeature.AddLiquidToFrontRenderers(this);
}
}
if (_debugSpillPoint) {
UpdateSpillPointGizmo();
}
#if UNITY_EDITOR
// Since Unity materials do not support color/vector arrays we need to submit them everytime to avoid losing the uniform values inside Unity Editor
if (_detail.isMultiple()) {
UploadMaterialArrays();
}
#endif
}
public void OnWillRenderObject() {
RenderObject();
}
void FixedUpdate() {
turbulenceSpeed += Time.deltaTime * 3f * _speed;
liqMat.SetFloat(ShaderParams.TurbulenceSpeed, turbulenceSpeed * 4f);
murkinessSpeed += Time.deltaTime * 0.05f * (shaderTurb.x + shaderTurb.y);
liqMat.SetFloat(ShaderParams.MurkinessSpeed, murkinessSpeed);
bubblesVerticalSpeedAcum += Time.deltaTime * _bubblesVerticalSpeed;
if (_detail.isMultiple()) {
UpdateBubblesProperties();
}
}
void UpdateBubblesProperties() {
if (_bubblesBrightness < 0)
_bubblesBrightness = 0;
liqMat.SetVector(ShaderParams.BubblesData, new Vector4(100f / (1f + _bubblesScale), bubblesVerticalSpeedAcum, _bubblesBrightness, 0));
}
void OnDidApplyAnimationProperties() { // support for animating property based fields
shouldUpdateMaterialProperties = true;
}
#endregion
#region Internal stuff
struct MeshCache {
public Vector3[] verticesSorted;
public Vector3[] verticesUnsorted;
public int[] indices;
}
static readonly Dictionary<Mesh, MeshCache> meshCache = new Dictionary<Mesh, MeshCache>();
public void ClearMeshCache() {
meshCache.Clear();
}
void ReadVertices() {
if (mesh == null)
return;
if (!meshCache.TryGetValue(mesh, out MeshCache meshData)) {
if (!mesh.isReadable) {
Debug.Log("Mesh " + mesh.name + " is not readable. Please select your mesh and enable the Read/Write Enabled option.");
}
verticesUnsorted = mesh.vertices;
verticesIndices = mesh.triangles;
int vertexCount = verticesUnsorted.Length;
if (verticesSorted == null || verticesSorted.Length != vertexCount) {
verticesSorted = new Vector3[vertexCount];
}
Array.Copy(verticesUnsorted, verticesSorted, vertexCount);
Array.Sort(verticesSorted, vertexComparer);
meshData.verticesUnsorted = verticesUnsorted;
meshData.indices = verticesIndices;
meshData.verticesSorted = verticesSorted;
if (meshCache.Count > 64) {
// Clear cache to avoid memory overrun
ClearMeshCache();
}
meshCache[mesh] = meshData;
} else {
verticesUnsorted = meshData.verticesUnsorted;
verticesIndices = meshData.indices;
verticesSorted = meshData.verticesSorted;
}
}
int vertexComparer(Vector3 v0, Vector3 v1) {
if (v1.y < v0.y) return -1;
if (v1.y > v0.y) return 1;
return 0;
}
void UpdateAnimations() {
// Check proper scale
switch (topology) {
case TOPOLOGY.Sphere:
if (transform.localScale.y != transform.localScale.x || transform.localScale.z != transform.localScale.x)
transform.localScale = new Vector3(transform.localScale.x, transform.localScale.x, transform.localScale.x);
break;
case TOPOLOGY.Cylinder:
if (transform.localScale.z != transform.localScale.x)
transform.localScale = new Vector3(transform.localScale.x, transform.localScale.y, transform.localScale.x);
break;
}
if (liqMat != null) {
Vector3 turbDir = Vector3.right;
Quaternion rot = transform.rotation;
if (_reactToForces) {
Quaternion instantRot = transform.rotation;
float dt = Time.smoothDeltaTime;
if (Application.isPlaying && dt > 0) {
Vector3 instantVelocity = (transform.position - lastPosition) / dt;
Vector3 avgVelocity = (prev2Velocity + prevVelocity + instantVelocity) / 3f;
prev2Velocity = prevVelocity;
prevVelocity = instantVelocity;
Vector3 instantAccel = (avgVelocity - lastAvgVelocity);
lastAvgVelocity = avgVelocity;
inertia += avgVelocity;
float accelMag = instantAccel.magnitude;
float force = Mathf.Max(accelMag / _physicsMass - _physicsAngularDamp, 0f);
angularInertia += force;
angularVelocity += angularInertia;
if (angularVelocity > 0) {
angularInertia -= Mathf.Abs(angularVelocity) * _physicsMass / 100f;
} else if (angularVelocity < 0) {
angularInertia += Mathf.Abs(angularVelocity) * _physicsMass / 100f;
}
float damp = 1f - _physicsAngularDamp;
angularInertia *= damp;
inertia *= damp;
float mag = Mathf.Clamp(angularVelocity, -90f, 90f);
if (inertia.x != 0 || inertia.z != 0) {
turbDir = inertia.normalized;
}
Vector3 axis = Vector3.Cross(turbDir, Vector3.down);
instantRot = Quaternion.AngleAxis(mag, axis);
float cinematic = Mathf.Abs(angularInertia) + Mathf.Abs(angularVelocity);
turbulenceDueForces = Mathf.Min(0.5f / _physicsMass, turbulenceDueForces + cinematic / 1000f);
turbulenceDueForces *= damp;
} else {
turbulenceDueForces = 0;
}
if (_topology == TOPOLOGY.Sphere) {
liquidRot = Quaternion.Lerp(liquidRot, instantRot, 0.1f);
rot = liquidRot;
}
} else if (turbulenceDueForces > 0) {
turbulenceDueForces *= 0.1f;
}
Matrix4x4 m = Matrix4x4.TRS(Vector3.zero, rot, Vector3.one);
liqMat.SetMatrix(ShaderParams.RotationMatrix, m.inverse);
if (_topology != TOPOLOGY.Sphere) {
float tx = turbDir.x;
turbDir.x += (turbDir.z - turbDir.x) * 0.25f;
turbDir.z += (tx - turbDir.z) * 0.25f;
}
turb.z = turbDir.x;
turb.w = turbDir.z;
}
bool hasRotated = transform.rotation != lastRotation;
if (_reactToForces || hasRotated || transform.position != lastPosition || transform.localScale != lastScale) {
UpdateLevels(hasRotated);
}
}
public void PointLightsRandomize() {
PointLightsInitialize(true);
}
void PointLightsInitialize(bool randomize = false) {
if (pointLightParams == null) {
pointLightParams = new PointLightParams[6];
randomize = true;
} else if (pointLightParams.Length > 6) {
Array.Resize<PointLightParams>(ref pointLightParams, 6);
}
if (!_pointLightsEnabled) {
UpdateLightEffects();
return;
}
if (randomize) {
for (int k = 0; k < pointLightParams.Length; k++) {
pointLightParams[k].localPosition = Vector3.zero;
pointLightParams[k].randomTargetCenter = new Vector3(0, -0.5f + _level * 0.5f, 0);
pointLightParams[k].color1 = new Color(Random.value, Random.value, Random.value);
pointLightParams[k].color2 = new Color(Random.value, Random.value, Random.value);
pointLightParams[k].colorSpeed = Random.Range(0.5f, 2f);
pointLightParams[k].intensityMin = Random.Range(0.5f, 1.5f);
pointLightParams[k].intensityMax = pointLightParams[k].intensityMin + Random.value * 1.5f;
pointLightParams[k].intensitySpeed = Random.Range(0.5f, 2f);
pointLightParams[k].lightRange = Random.Range(0.01f, 0.1f);
pointLightParams[k].moveSpeed = Random.value * 0.1f;
pointLightParams[k].accel = Vector3.zero;
pointLightParams[k].nextTargetInterval = 1f;
pointLightParams[k].randomTarget = true;
if (pointLightParams[k].randomTargetRadius == 0)
pointLightParams[k].randomTargetRadius = 0.4f;
SetNewLightTargetPos(k);
}
}
}
void SetNewLightTargetPos(int k) {
pointLightParams[k].targetPos = pointLightParams[k].randomTargetCenter + Random.insideUnitSphere * pointLightParams[k].randomTargetRadius;
pointLightParams[k].targetPos.x = Mathf.Clamp(pointLightParams[k].targetPos.x, -0.4f, 0.4f);
pointLightParams[k].targetPos.y = Mathf.Clamp(pointLightParams[k].targetPos.y, -0.4f, 0.4f);
pointLightParams[k].targetPos.z = Mathf.Clamp(pointLightParams[k].targetPos.z, -0.4f, 0.4f);
pointLightParams[k].nextTargetTime = Time.time + Random.value + pointLightParams[k].nextTargetInterval;
}
void UpdateLightEffects() {
#if UNITY_EDITOR
if (lastPointLightCount != pointLightParams.Length) {
lastPointLightCount = pointLightParams.Length;
}
for (int k = 0; k < pointLightParams.Length; k++) {
pointLightParams[k].name = "Light " + (k + 1);
}
#endif
// Animate lights
for (int k = 0; k < pointLightParams.Length; k++) {
Vector3 curPos = pointLightParams[k].localPosition;
if (pointLightParams[k].randomTarget && Time.time > pointLightParams[k].nextTargetTime) {
SetNewLightTargetPos(k);
}
Vector3 targetPos = pointLightParams[k].targetPos;
Vector3 accel = pointLightParams[k].accel;
float speed = pointLightParams[k].moveSpeed * Time.deltaTime;
accel.x += curPos.x < targetPos.x ? speed : -speed;
const float maxAccel = 5f;
if (accel.x > speed * maxAccel)
accel.x = speed * maxAccel;
else if (accel.x < speed * -maxAccel) {
accel.x = speed * -maxAccel;
}
accel.y += curPos.y < targetPos.y ? speed : -speed;
if (accel.y > speed * maxAccel)
accel.y = speed * maxAccel;
else if (accel.y < speed * -maxAccel) {
accel.y = speed * -maxAccel;
}
accel.z += curPos.z < targetPos.z ? speed : -speed;
if (accel.z > speed * maxAccel)
accel.z = speed * maxAccel;
else if (accel.z < speed * -maxAccel) {
accel.z = speed * -maxAccel;
}
pointLightParams[k].accel = accel;
curPos += pointLightParams[k].accel;
if (curPos.x < -0.5) {
curPos.x = -0.5f;
pointLightParams[k].accel.x = 0;
} else if (curPos.x > 0.5f) {
curPos.x = 0.5f;
pointLightParams[k].accel.x = 0;
}
if (curPos.y < -0.5) {
curPos.y = -0.5f;
pointLightParams[k].accel.y = 0;
} else if (curPos.y > 0.5f) {
curPos.y = 0.5f;
pointLightParams[k].accel.y = 0;
}
if (curPos.z < -0.5) {
curPos.z = -0.5f;
pointLightParams[k].accel.z = 0;
} else if (curPos.z > 0.5f) {
curPos.z = 0.5f;
pointLightParams[k].accel.z = 0;
}
pointLightParams[k].localPosition = curPos;
}
// Pass data to shader
if (pointLightColorBuffer == null || pointLightColorBuffer.Length != 6) {
pointLightColorBuffer = new Color[6];
}
if (pointLightPositionBuffer == null || pointLightPositionBuffer.Length != 6) {
pointLightPositionBuffer = new Vector4[6];
}
float range, multiplier;
for (int k = 0; k < 6; k++) {
range = multiplier = 0;
if (_pointLightsEnabled && k < pointLightParams.Length) {
Vector3 pos = transform.TransformPoint(pointLightParams[k].localPosition);
pointLightPositionBuffer[k] = pos;
range = pointLightParams[k].lightRange * pointLightsScatteringAmount / 25f; // note: 25 comes from Unity point light attenuation equation
float intensity = pointLightParams[k].intensityMin + Mathf.PingPong(Time.time * pointLightParams[k].intensitySpeed, pointLightParams[k].intensityMax - pointLightParams[k].intensityMin);
multiplier = pointLightsIntensity * intensity;
}
if (range > 0 && multiplier > 0) {
// Apply attenuation if light is affected by fog distance & falloff
Color pointLightColor = Color.Lerp(pointLightParams[k].color1, pointLightParams[k].color2, Mathf.PingPong(Time.time * pointLightParams[k].colorSpeed, 1f));
pointLightColorBuffer[k] = new Vector4(pointLightColor.r * multiplier, pointLightColor.g * multiplier, pointLightColor.b * multiplier, range);
} else {
pointLightColorBuffer[k] = Color.black;
}
}
if (liqMat != null) {
liqMat.SetFloat(ShaderParams.PointLightInsideAtten, pointLightInsideAtten);
liqMat.SetColorArray(ShaderParams.PointLightColorArray, pointLightColorBuffer);
liqMat.SetVectorArray(ShaderParams.PointLightPositionArray, pointLightPositionBuffer);
}
}
public void UpdateMaterialProperties() {
if (Application.isPlaying) {
shouldUpdateMaterialProperties = true;
} else {
UpdateMaterialPropertiesNow();
}
}
void UpdateMaterialPropertiesNow() {
if (!gameObject.activeInHierarchy)
return;
switch (_detail) {
case DETAIL.Simple:
case DETAIL.SimpleNoFlask:
if (liqMatSimple == null) {
liqMatSimple = Instantiate(Resources.Load<Material>("Materials/LiquidVolumeSimple")) as Material;
}
liqMat = liqMatSimple;
break;
case DETAIL.Multiple:
case DETAIL.MultipleNoFlask:
if (liqMatMultipleNoFlask == null) {
liqMatMultipleNoFlask = Instantiate(Resources.Load<Material>("Materials/LiquidVolumeMultipleNoFlask")) as Material;
}
liqMat = liqMatMultipleNoFlask;
break;
default:
if (liqMatDefaultNoFlask == null) {
liqMatDefaultNoFlask = Instantiate(Resources.Load<Material>("Materials/LiquidVolumeDefaultNoFlask")) as Material;
}
liqMat = liqMatDefaultNoFlask;
break;
}
if (_flaskMaterial == null) {
_flaskMaterial = Instantiate(Resources.Load<Material>("Materials/Flask"));
}
if (liqMat == null)
return;
CheckMeshDisplacement();
if (currentDetail != _detail) {
currentDetail = _detail;
requireLayersUpdate = true;
}
if (requireLayersUpdate && _detail.isMultiple()) {
UpdateLayersNow();
}
UpdateLevels();
if (mr == null)
return;
// Try to compute submesh index heuristically if this is the first time the liquid has been added to a multi-material mesh
mr.GetSharedMaterials(mrSharedMaterials);
int sharedMaterialsCount = mrSharedMaterials.Count;
if (_subMeshIndex < 0) {
for (int w = 0; w < defaultContainerNames.Length; w++) {
if (_subMeshIndex >= 0)
break;
for (int k = 0; k < sharedMaterialsCount; k++) {
if (mrSharedMaterials[k] != null && mrSharedMaterials[k] != _flaskMaterial && mrSharedMaterials[k].name.ToUpper().Contains(defaultContainerNames[w])) {
_subMeshIndex = k;
break;
}
}
}
}
if (_subMeshIndex < 0)
_subMeshIndex = 0;
if (sharedMaterialsCount > 1 && _subMeshIndex >= 0 && _subMeshIndex < sharedMaterialsCount) {
mrSharedMaterials[_subMeshIndex] = liqMat;
} else {
mrSharedMaterials.Clear();
mrSharedMaterials.Add(liqMat);
}
if (_flaskMaterial != null) {
bool shouldUseFlaskMaterial = _detail.usesFlask();
if (shouldUseFlaskMaterial && !mrSharedMaterials.Contains(_flaskMaterial)) {
// empty slot?
for (int k=0;k<mrSharedMaterials.Count;k++) {
if (mrSharedMaterials[k] == null) {
mrSharedMaterials[k] = _flaskMaterial;
shouldUseFlaskMaterial = false;
}
}
if (shouldUseFlaskMaterial) {
mrSharedMaterials.Add(_flaskMaterial);
}
} else if (!shouldUseFlaskMaterial && mrSharedMaterials.Contains(_flaskMaterial)) {
mrSharedMaterials.Remove(_flaskMaterial);
}
_flaskMaterial.renderQueue = _renderQueue + 1;
}
mr.sharedMaterials = mrSharedMaterials.ToArray();
liqMat.SetFloat(ShaderParams.DitherStrength, _ditherStrength);
liqMat.SetColor(ShaderParams.Color1, ApplyGlobalAlpha(_liquidColor1));
liqMat.SetColor(ShaderParams.Color2, ApplyGlobalAlpha(_liquidColor2));
liqMat.SetColor(ShaderParams.EmissionColor, _emissionColor);
if (_useLightColor && _directionalLight != null) {
Color lightColor = _directionalLight.color;
liqMat.SetColor(ShaderParams.LightColor, lightColor);
} else {
liqMat.SetColor(ShaderParams.LightColor, Color.white);
}
int scatteringPower = _scatteringPower;
float scatteringAmount = _scatteringAmount;
if (!_scatteringEnabled) {
scatteringPower = 0;
scatteringAmount = 0;
}
liqMat.SetVector(ShaderParams.GlossinessInt, new Vector4((1f - _glossinessInternal) * 96f + 1f, Mathf.Pow(2, scatteringPower), scatteringAmount, _glossinessInternal));
liqMat.SetFloat(ShaderParams.DoubleSidedBias, _doubleSidedBias);
liqMat.SetFloat(ShaderParams.BackDepthBias, -_backDepthBias);
liqMat.SetFloat(ShaderParams.Muddy, _murkiness);
liqMat.SetFloat(ShaderParams.Alpha, _alpha);
float alphaCombined = _alpha * Mathf.Clamp01((_liquidColor1.a + _liquidColor2.a) * 4f);
if (_ditherShadows) {
liqMat.SetFloat(ShaderParams.AlphaCombined, alphaCombined);
} else {
liqMat.SetFloat(ShaderParams.AlphaCombined, alphaCombined > 0 ? 1000f : 0f);
}
liqMat.SetFloat(ShaderParams.SparklingIntensity, _sparklingIntensity * 250.0f);
liqMat.SetFloat(ShaderParams.SparklingThreshold, 1.0f - _sparklingAmount);
liqMat.SetFloat(ShaderParams.DepthAtten, _deepObscurance);
Color smokeColor = ApplyGlobalAlpha(_smokeColor);
int smokeRaySteps = _smokeRaySteps;
if (!_smokeEnabled) {
smokeColor.a = 0;
smokeRaySteps = 1;
}
liqMat.SetColor(ShaderParams.SmokeColor, smokeColor);
liqMat.SetFloat(ShaderParams.SmokeAtten, _smokeBaseObscurance);
liqMat.SetFloat(ShaderParams.SmokeHeightAtten, _smokeHeightAtten);
liqMat.SetFloat(ShaderParams.SmokeSpeed, _smokeSpeed);
liqMat.SetFloat(ShaderParams.SmokeRaySteps, smokeRaySteps);
liqMat.SetFloat(ShaderParams.LiquidRaySteps, _liquidRaySteps);
liqMat.SetColor(ShaderParams.FoamColor, ApplyGlobalAlpha(_foamColor));
liqMat.SetFloat(ShaderParams.FoamRaySteps, _foamThickness > 0 ? _foamRaySteps : 1);
liqMat.SetFloat(ShaderParams.FoamDensity, _foamThickness > 0 ? _foamDensity : -1f);
liqMat.SetFloat(ShaderParams.FoamWeight, _foamWeight);
liqMat.SetFloat(ShaderParams.FoamBottom, _foamVisibleFromBottom ? 1f : 0f);
liqMat.SetFloat(ShaderParams.FoamTurbulence, _foamTurbulence);
switch (_detail) {
case DETAIL.Multiple:
case DETAIL.MultipleNoFlask:
UpdateBubblesProperties();
break;
}
if (_bubblesAmount < 0) {
_bubblesAmount = 0;
}
if (_noiseVariation != currentNoiseVariation || requireBubblesUpdate) {
requireBubblesUpdate = false;
currentNoiseVariation = _noiseVariation;
if (noise3DTex == null || noise3DTex.Length != 4) {
noise3DTex = new Texture3D[4];
}
if (noise3DTex[currentNoiseVariation] == null) {
noise3DTex[currentNoiseVariation] = Resources.Load<Texture3D>("Textures/Noise3D" + currentNoiseVariation.ToString());
}
Texture3D tex3d = noise3DTex[currentNoiseVariation];
if (tex3d != null) {
bool needsBubbleTextureUpdate = _bubblesAmount > 0 || (_bubblesAmount == 0 && tex3d != null && tex3d.name.Contains("Clone"));
if (needsBubbleTextureUpdate && _detail.isMultiple()) {
if (!tex3d.name.Contains("Clone")) {
tex3d = Instantiate(tex3d);
tex3d.hideFlags = HideFlags.DontSave;
noise3DTex[currentNoiseVariation] = tex3d;
}
if (colors3D == null || colors3D.Length != 4) {
colors3D = new Color[4][];
}
if (colors3D[currentNoiseVariation] == null) {
colors3D[currentNoiseVariation] = tex3d.GetPixels();
int length = colors3D[currentNoiseVariation].Length;
if (colors3DWithBubbles == null || colors3DWithBubbles.Length != 4) {
colors3DWithBubbles = new Color[4][];
}
if (colors3DWithBubbles[currentNoiseVariation] == null || colors3DWithBubbles[currentNoiseVariation].Length != length) {
colors3DWithBubbles[currentNoiseVariation] = new Color[length];
}
}
if (_bubblesAmount > 0 && _detail.isMultiple()) {
AddBubbles(tex3d);
} else {
ClearBubbles(tex3d);
}
}
liqMat.SetTexture(ShaderParams.NoiseTex, tex3d);
}
}
liqMat.renderQueue = _renderQueue;
UpdateInsideOut();
if (_topology == TOPOLOGY.Irregular) {
if (prevThickness != _flaskThickness) {
prevThickness = _flaskThickness;
}
}
}
Color ApplyGlobalAlpha(Color originalColor) {
return new Color(originalColor.r, originalColor.g, originalColor.b, originalColor.a * _alpha);
}
void GetRenderer() {
MeshFilter mf = GetComponent<MeshFilter>();
if (mf != null) {
mesh = mf.sharedMesh;
mr = GetComponent<MeshRenderer>();
} else {
SkinnedMeshRenderer smr = GetComponent<SkinnedMeshRenderer>();
if (smr != null) {
mesh = smr.sharedMesh;
mr = smr;
}
}
}
void UpdateLevels(bool updateShaderKeywords = true) {
_level = Mathf.Clamp01(_level);
levelMultipled = _level * _levelMultiplier;
if (liqMat == null)
return;
if (mesh == null) {
GetRenderer();
ReadVertices();
} else if (mr == null) {
GetRenderer();
}
if (mesh == null || mr == null) {
return;
}
Vector4 size = new Vector4(mesh.bounds.extents.x * 2f * transform.lossyScale.x, mesh.bounds.extents.y * 2f * transform.lossyScale.y, mesh.bounds.extents.z * 2f * transform.lossyScale.z, 0);
size.x *= _extentsScale.x;
size.y *= _extentsScale.y;
size.z *= _extentsScale.z;
float maxWidth = Mathf.Max(size.x, size.z);
Vector3 extents = _ignoreGravity ? new Vector3(size.x * 0.5f, size.y * 0.5f, size.z * 0.5f) : mr.bounds.extents;
extents *= (1f - _flaskThickness);
extents.x *= _extentsScale.x;
extents.y *= _extentsScale.y;
extents.z *= _extentsScale.z;
// Compensate levelpos with upperlimit
float rotationAdjustment;
if (_upperLimit < 1f && !_ignoreGravity) {
float y1 = transform.TransformPoint(Vector3.up * extents.y).y;
float y0 = transform.TransformPoint(Vector3.up * (extents.y * _upperLimit)).y;
rotationAdjustment = Mathf.Max(y0 - y1, 0);
} else {
rotationAdjustment = 0;
}
#if DEBUG_SLICE
float approxVolume = 0;
#endif
// Compensate rotation in cylindrical shapes where mesh height is on another scale than width
float thisLevel = levelMultipled;
if (_rotationLevelCompensation != LEVEL_COMPENSATION.None && !_ignoreGravity && thisLevel > 0) {
MeshVolumeCalcFunction volumeFunction;
int exitIterations;
if (_rotationLevelCompensation == LEVEL_COMPENSATION.Fast) {
volumeFunction = GetMeshVolumeUnderLevelFast;
exitIterations = 8;
} else {
volumeFunction = GetMeshVolumeUnderLevel;
exitIterations = 10;
}
Vector3 mrCenter = mr.bounds.center;
if (lastLevelVolumeRef != thisLevel) {
lastLevelVolumeRef = thisLevel;
if (_topology == TOPOLOGY.Cylinder) {
float r = size.x * 0.5f;
float h = size.y * thisLevel;
volumeRef = Mathf.PI * r * r * h; // perfect cylinder volume (optimization for performance reasons, ideally should go through normal mesh volume computation - the else part)
} else {
Quaternion q = transform.rotation;
transform.rotation = Quaternion.identity;
float tempExtentY = _ignoreGravity ? size.y * 0.5f : mr.bounds.extents.y;
tempExtentY *= (1f - _flaskThickness);
tempExtentY *= _extentsScale.y;
RotateVertices();
volumeRef = volumeFunction(thisLevel, mrCenter, tempExtentY);
transform.rotation = q;
}
}
RotateVertices();
float nearestLevel = thisLevel;
float minVolumeDiff = float.MaxValue;
float maxLevel = Mathf.Clamp01(thisLevel + 0.5f);
float minLevel = Mathf.Clamp01(thisLevel - 0.5f);
for (int i = 0; i < 12; i++) {
thisLevel = (minLevel + maxLevel) * 0.5f;
float volume = volumeFunction(thisLevel, mrCenter, extents.y);
float volumeDiff = Mathf.Abs(volumeRef - volume);
if (volumeDiff < minVolumeDiff) {
#if DEBUG_SLICE
approxVolume = volume;
#endif
minVolumeDiff = volumeDiff;
nearestLevel = thisLevel;
}
if (volume < volumeRef) {
minLevel = thisLevel;
} else {
if (i >= exitIterations)
break;
maxLevel = thisLevel;
}
}
thisLevel = nearestLevel * _levelMultiplier;
} else {
if (levelMultipled <= 0)
thisLevel = -0.001f; // ensure it's below the flask thickness
}
liquidLevelPos = mr.bounds.center.y - extents.y;
liquidLevelPos += extents.y * 2f * thisLevel + rotationAdjustment;
#if DEBUG_SLICE
Debug.Log("Ref: " + volumeRef + " Vol: " + approxVolume + " Level: " + thisLevel);
#endif
liqMat.SetFloat(ShaderParams.LevelPos, liquidLevelPos);
float upperLimit = mesh.bounds.extents.y * _extentsScale.y * _upperLimit;
liqMat.SetFloat(ShaderParams.UpperLimit, upperLimit);
float lowerLimit = mesh.bounds.extents.y * _extentsScale.y * _lowerLimit;
liqMat.SetFloat(ShaderParams.LowerLimit, lowerLimit);
float visibleLevel = (levelMultipled <= 0 || levelMultipled >= 1f) ? 0f : 1f;
UpdateTurbulence();
float foamPos = mr.bounds.center.y - extents.y + (rotationAdjustment + extents.y * 2.0f * (thisLevel + _foamThickness)) * visibleLevel;
liqMat.SetFloat(ShaderParams.FoamMaxPos, foamPos);
Vector4 thickness = new Vector4(1.0f - _flaskThickness, (1.0f - _flaskThickness * maxWidth / size.z), (1.0f - _flaskThickness * maxWidth / size.z), 0);
liqMat.SetVector(ShaderParams.FlaskThickness, thickness);
size.w = size.x * 0.5f * thickness.x;
size.x = Vector3.Distance(mr.bounds.max, mr.bounds.min);
liqMat.SetVector(ShaderParams.Size, size);
float scaleFactor = size.y * 0.5f * (1.0f - _flaskThickness * maxWidth / size.y);
liqMat.SetVector(ShaderParams.Scale, new Vector4(_smokeScale / scaleFactor, _foamScale / scaleFactor, _liquidScale1 / scaleFactor, _liquidScale2 / scaleFactor));
liqMat.SetVector(ShaderParams.Center, transform.position);
if (shaderKeywords == null || shaderKeywords.Length != 6) {
shaderKeywords = new string[6];
}
for (int k = 0; k < shaderKeywords.Length; k++) {
shaderKeywords[k] = null;
}
if (_detail.isMultiple()) {
liqMat.SetFloat(ShaderParams.SizeWorld, mr.bounds.size.y);
}
if (_depthAware) {
shaderKeywords[SHADER_KEYWORD_DEPTH_AWARE_INDEX] = SHADER_KEYWORD_DEPTH_AWARE;
liqMat.SetFloat(ShaderParams.DepthAwareOffset, _depthAwareOffset);
}
if (_depthAwareCustomPass) {
shaderKeywords[SHADER_KEYWORD_DEPTH_AWARE_CUSTOM_PASS_INDEX] = SHADER_KEYWORD_DEPTH_AWARE_CUSTOM_PASS;
}
if (_reactToForces && _topology == TOPOLOGY.Sphere) {
shaderKeywords[SHADER_KEYWORD_IGNORE_GRAVITY_INDEX] = SHADER_KEYWORD_IGNORE_GRAVITY;
} else if (_ignoreGravity) {
shaderKeywords[SHADER_KEYWORD_IGNORE_GRAVITY_INDEX] = SHADER_KEYWORD_IGNORE_GRAVITY;
} else if (transform.rotation.eulerAngles != Vector3.zero) {
shaderKeywords[SHADER_KEYWORD_NON_AABB_INDEX] = SHADER_KEYWORD_NON_AABB;
}
switch (_topology) {
case TOPOLOGY.Sphere:
shaderKeywords[SHADER_KEYWORD_TOPOLOGY_INDEX] = SHADER_KEYWORD_SPHERE;
break;
case TOPOLOGY.Cube:
shaderKeywords[SHADER_KEYWORD_TOPOLOGY_INDEX] = SHADER_KEYWORD_CUBE;
break;
case TOPOLOGY.Cylinder:
shaderKeywords[SHADER_KEYWORD_TOPOLOGY_INDEX] = SHADER_KEYWORD_CYLINDER;
break;
default:
shaderKeywords[SHADER_KEYWORD_TOPOLOGY_INDEX] = SHADER_KEYWORD_IRREGULAR;
break;
}
if (_refractionBlur && _detail.allowsRefraction()) {
liqMat.SetFloat(ShaderParams.FlaskBlurIntensity, _blurIntensity * (_refractionBlur ? 1f : 0f));
shaderKeywords[SHADER_KEYWORD_REFRACTION_INDEX] = SHADER_KEYWORD_USE_REFRACTION;
}
if (updateShaderKeywords) {
liqMat.shaderKeywords = shaderKeywords;
}
lastPosition = transform.position;
lastScale = transform.localScale;
lastRotation = transform.rotation;
}
void RotateVertices() {
int vertexCount = verticesUnsorted.Length;
if (rotatedVertices == null || rotatedVertices.Length != vertexCount) {
rotatedVertices = new Vector3[vertexCount];
}
for (int k = 0; k < vertexCount; k++) {
rotatedVertices[k] = transform.TransformPoint(verticesUnsorted[k]);
}
}
float SignedVolumeOfTriangle(Vector3 p1, Vector3 p2, Vector3 p3, Vector3 zeroPoint) {
// zero point can be useful to avoid floating point issues if mesh is at very distant positions but in general this can be omitted
p1.x -= zeroPoint.x; p1.y -= zeroPoint.y; p1.z -= zeroPoint.z;
p2.x -= zeroPoint.x; p2.y -= zeroPoint.y; p2.z -= zeroPoint.z;
p3.x -= zeroPoint.x; p3.y -= zeroPoint.y; p3.z -= zeroPoint.z;
float v321 = p3.x * p2.y * p1.z;
float v231 = p2.x * p3.y * p1.z;
float v312 = p3.x * p1.y * p2.z;
float v132 = p1.x * p3.y * p2.z;
float v213 = p2.x * p1.y * p3.z;
float v123 = p1.x * p2.y * p3.z;
float e = (1.0f / 6.0f) * (-v321 + v231 + v312 - v132 - v213 + v123);
return e;
}
delegate float MeshVolumeCalcFunction(float level01, Vector3 zeroPoint, float yExtent);
float GetMeshVolumeUnderLevelFast(float level01, Vector3 zeroPoint, float yExtent) {
float level = mr.bounds.center.y - yExtent;
level += yExtent * 2f * level01;
float vol = 0;
for (int k = 0; k < verticesIndices.Length; k += 3) {
Vector3 p1 = rotatedVertices[verticesIndices[k]];
Vector3 p2 = rotatedVertices[verticesIndices[k + 1]];
Vector3 p3 = rotatedVertices[verticesIndices[k + 2]];
if (p1.y > level) p1.y = level;
if (p2.y > level) p2.y = level;
if (p3.y > level) p3.y = level;
vol += SignedVolumeOfTriangle(p1, p2, p3, zeroPoint);
}
return Mathf.Abs(vol);
}
Vector3 ClampVertexToSlicePlane(Vector3 p, Vector3 q, float level) {
Vector3 qp = (q - p).normalized;
float h = p.y - level;
return p + qp * h / -qp.y;
}
#if DEBUG_SLICE
GameObject o;
#endif
readonly List<Vector3> verts = new List<Vector3>();
readonly List<Vector3> cutPoints = new List<Vector3>();
Vector3 cutPlaneCenter;
float GetMeshVolumeUnderLevel(float level01, Vector3 zeroPoint, float yExtent) {
float level = mr.bounds.center.y - yExtent;
level += yExtent * 2f * level01;
cutPlaneCenter = Vector3.zero;
cutPoints.Clear();
verts.Clear();
// Slice mesh
int indicesCount = verticesIndices.Length;
for (int k = 0; k < indicesCount; k += 3) {
Vector3 p1 = rotatedVertices[verticesIndices[k]];
Vector3 p2 = rotatedVertices[verticesIndices[k + 1]];
Vector3 p3 = rotatedVertices[verticesIndices[k + 2]];
if (p1.y > level && p2.y > level && p3.y > level) continue;
if (p1.y < level && p2.y > level && p3.y > level) {
p2 = ClampVertexToSlicePlane(p2, p1, level);
p3 = ClampVertexToSlicePlane(p3, p1, level);
cutPoints.Add(p2);
cutPoints.Add(p3);
cutPlaneCenter += p2;
cutPlaneCenter += p3;
} else if (p2.y < level && p1.y > level && p3.y > level) {
p1 = ClampVertexToSlicePlane(p1, p2, level);
p3 = ClampVertexToSlicePlane(p3, p2, level);
cutPoints.Add(p1);
cutPoints.Add(p3);
cutPlaneCenter += p1;
cutPlaneCenter += p3;
} else if (p3.y < level && p1.y > level && p2.y > level) {
p1 = ClampVertexToSlicePlane(p1, p3, level);
p2 = ClampVertexToSlicePlane(p2, p3, level);
cutPoints.Add(p1);
cutPoints.Add(p2);
cutPlaneCenter += p1;
cutPlaneCenter += p2;
} else if (p1.y > level && p2.y < level && p3.y < level) {
Vector3 p12 = ClampVertexToSlicePlane(p1, p2, level);
Vector3 p13 = ClampVertexToSlicePlane(p1, p3, level);
verts.Add(p12);
verts.Add(p2);
verts.Add(p3);
verts.Add(p13);
verts.Add(p12);
verts.Add(p3);
cutPoints.Add(p12);
cutPoints.Add(p13);
cutPlaneCenter += p12;
cutPlaneCenter += p13;
continue;
} else if (p2.y > level && p1.y < level && p3.y < level) {
Vector3 p21 = ClampVertexToSlicePlane(p2, p1, level);
Vector3 p23 = ClampVertexToSlicePlane(p2, p3, level);
verts.Add(p1);
verts.Add(p21);
verts.Add(p3);
verts.Add(p21);
verts.Add(p23);
verts.Add(p3);
cutPoints.Add(p21);
cutPoints.Add(p23);
cutPlaneCenter += p21;
cutPlaneCenter += p23;
continue;
} else if (p3.y > level && p1.y < level && p2.y < level) {
Vector3 p31 = ClampVertexToSlicePlane(p3, p1, level);
Vector3 p32 = ClampVertexToSlicePlane(p3, p2, level);
verts.Add(p31);
verts.Add(p1);
verts.Add(p2);
verts.Add(p32);
verts.Add(p31);
verts.Add(p2);
cutPoints.Add(p31);
cutPoints.Add(p32);
cutPlaneCenter += p31;
cutPlaneCenter += p32;
continue;
}
verts.Add(p1);
verts.Add(p2);
verts.Add(p3);
}
// close sliced mesh
int cutPointsCount = cutPoints.Count;
if (cutPoints.Count >= 3) {
cutPlaneCenter /= cutPointsCount;
cutPoints.Sort(PolygonSortOnPlane);
for (int k = 0; k < cutPointsCount; k++) {
Vector3 p1 = cutPoints[k];
Vector3 p2;
if (k == cutPointsCount - 1) {
p2 = cutPoints[0];
} else {
p2 = cutPoints[k + 1];
}
verts.Add(cutPlaneCenter);
verts.Add(p1);
verts.Add(p2);
}
}
// compute mesh volume
int vertCount = verts.Count;
float vol = 0;
for (int k = 0; k < vertCount; k += 3) {
vol += SignedVolumeOfTriangle(verts[k], verts[k + 1], verts[k + 2], zeroPoint);
}
#if DEBUG_SLICE
if (o == null) {
o = new GameObject("Sliced", typeof(MeshFilter), typeof(MeshRenderer));
}
Mesh mesh = new Mesh();
mesh.vertices = verts.ToArray();
int len = mesh.vertices.Length;
int[] inds = new int[len];
for (int k = 0; k < inds.Length; k++) {
inds[k] = k;
}
mesh.triangles = inds;
MeshFilter mf = o.GetComponent<MeshFilter>();
mf.mesh = mesh;
#endif
return Mathf.Abs(vol);
}
int PolygonSortOnPlane(Vector3 p1, Vector3 p2) {
float r1 = Mathf.Atan2(p1.x - cutPlaneCenter.x, p1.z - cutPlaneCenter.z);
float r2 = Mathf.Atan2(p2.x - cutPlaneCenter.x, p2.z - cutPlaneCenter.z);
if (r1 < r2) return -1;
if (r1 > r2) return 1;
return 0;
}
void UpdateTurbulence() {
if (liqMat == null)
return;
float visibleLevel = levelMultipled > 0 ? 1f: 0f; // (_level<=0 || _level>=1f) ? 0.1f: 1f; // commented out to allow animation even level is 0 or full
float isInsideContainer = (camInside && _allowViewFromInside) ? 0f : 1f;
turb.x = _turbulence1 * visibleLevel * isInsideContainer;
turb.y = Mathf.Max(_turbulence2, turbulenceDueForces) * visibleLevel * isInsideContainer;
shaderTurb = turb;
shaderTurb.z *= 3.1415927f * _frecuency * 4f;
shaderTurb.w *= 3.1415927f * _frecuency * 4f;
liqMat.SetVector(ShaderParams.Turbulence, shaderTurb);
}
void CheckInsideOut() {
Camera cam = Camera.current;
if (cam == null || mr == null) {
if (!_allowViewFromInside)
UpdateInsideOut();
return;
}
Vector3 currentCamPos = cam.transform.position + cam.transform.forward * cam.nearClipPlane;
float currentDistanceToCam = (currentCamPos - transform.position).sqrMagnitude;
if (currentDistanceToCam == lastDistanceToCam)
return;
lastDistanceToCam = currentDistanceToCam;
// Check if position is inside container
bool nowInside = false;
switch (_topology) {
case TOPOLOGY.Cube:
nowInside = PointInAABB(currentCamPos);
break;
case TOPOLOGY.Cylinder:
nowInside = PointInCylinder(currentCamPos);
break;
default:
float diam = mesh.bounds.extents.x * 2f;
nowInside = (currentCamPos - transform.position).sqrMagnitude < (diam * diam);
break;
}
if (nowInside != camInside) {
camInside = nowInside;
UpdateInsideOut();
}
}
bool PointInAABB(Vector3 point) {
point = transform.InverseTransformPoint(point);
Vector3 ext = mesh.bounds.extents;
if (point.x < ext.x && point.x > -ext.x &&
point.y < ext.y && point.y > -ext.y &&
point.z < ext.z && point.z > -ext.z) {
return true;
} else {
return false;
}
}
bool PointInCylinder(Vector3 point) {
point = transform.InverseTransformPoint(point);
Vector3 ext = mesh.bounds.extents;
if (point.x < ext.x && point.x > -ext.x &&
point.y < ext.y && point.y > -ext.y &&
point.z < ext.z && point.z > -ext.z) {
point.y = 0;
Vector3 currentPos = transform.position;
currentPos.y = 0;
return (point - currentPos).sqrMagnitude < ext.x * ext.x;
}
return false;
}
void UpdateInsideOut() {
if (liqMat == null)
return;
if (_allowViewFromInside && camInside) {
liqMat.SetInt(ShaderParams.CullMode, (int)CullMode.Front);
liqMat.SetInt(ShaderParams.ZTestMode, (int)CompareFunction.Always);
if (_flaskMaterial != null) {
_flaskMaterial.SetInt(ShaderParams.CullMode, (int)CullMode.Front);
_flaskMaterial.SetInt(ShaderParams.ZTestMode, (int)CompareFunction.Always);
}
} else {
liqMat.SetInt(ShaderParams.CullMode, (int)CullMode.Back);
liqMat.SetInt(ShaderParams.ZTestMode, (int)CompareFunction.LessEqual);
if (_flaskMaterial != null) {
_flaskMaterial.SetInt(ShaderParams.CullMode, (int)CullMode.Back);
_flaskMaterial.SetInt(ShaderParams.ZTestMode, (int)CompareFunction.LessEqual);
}
}
UpdateTurbulence();
}
#endregion
#region Public API
/// <summary>
/// Returns the vertical position in world space coordinates of the liquid surface
/// </summary>
/// <value>The get liquid surface Y position.</value>
public float liquidSurfaceYPosition {
get {
return liquidLevelPos;
}
}
/// <summary>
/// Changes the transform position and/or rotation of a floating object.
/// </summary>
public void MoveToLiquidSurface(Transform transform, BuoyancyEffect effect, Transform root = null, float dampen = 0.8f) {
Vector3 position = transform.position;
if (effect == BuoyancyEffect.Simple) {
position.y = liquidLevelPos;
transform.position = position;
return;
}
if (effect == BuoyancyEffect.PositionOnly) {
Vector4 shaderTurb = liqMat.GetVector(ShaderParams.Turbulence);
float sizeY = liqMat.GetVector(ShaderParams.Size).y;
float turbFactor = shaderTurb.y * 0.05f * sizeY * _foamTurbulence;
float turbulence1 = Mathf.Sin(transform.position.x * shaderTurb.z + transform.position.z * shaderTurb.w + turbulenceSpeed * 4f) * turbFactor;
float y1 = liquidLevelPos + turbulence1;
position.y = y1;
transform.position = position;
return;
}
// Position and rotation
if (effect == BuoyancyEffect.PositionAndRotation) {
if (root == null) {
Debug.LogError("No root specified when calling MoveToLiquidSurface(..). Usually the root is a parent object that receives the buoyancy position and rotation changes.");
}
Vector4 shaderTurb = liqMat.GetVector(ShaderParams.Turbulence);
Collider collider = transform.GetComponent<Collider>();
if (collider == null) {
Debug.LogError("No collider found in object used when calling MoveToLiquidSurface(..) of Liquid Volume.");
return;
}
float sizeY = liqMat.GetVector(ShaderParams.Size).y;
float turbFactor = shaderTurb.y * 0.05f * sizeY * _foamTurbulence;
Vector3 min = collider.bounds.min;
Vector3 max = collider.bounds.max;
float turbulence1 = Mathf.Sin(min.x * shaderTurb.z + min.z * shaderTurb.w + turbulenceSpeed * 4f) * turbFactor;
float turbulence2 = Mathf.Sin(max.x * shaderTurb.z + max.z * shaderTurb.w + turbulenceSpeed * 4f) * turbFactor;
float y1 = liquidLevelPos + turbulence1;
float y2 = liquidLevelPos + turbulence2;
position.y = (y1 + y2) * 0.5f;
root.transform.position = position;
Vector3 boundsCenter = collider.bounds.center;
Vector3 p1 = new Vector3(min.x - boundsCenter.x, y1, min.z - boundsCenter.z);
Vector3 p2 = new Vector3(max.x - boundsCenter.x, y2, max.z - boundsCenter.z);
Vector3 n = Vector3.Cross((p2 - p1).normalized, Vector3.back);
n.y = n.y < 0 ? -n.y : n.y;
Debug.DrawRay(transform.position, transform.position + n);
root.transform.up = Vector3.Lerp(root.transform.up, n, dampen);
}
}
/// <summary>
/// Computes approximate point where liquid starts pouring over the flask when it's rotated
/// </summary>
/// <returns><c>true</c>, if spill point is detected, <c>false</c> otherwise.</returns>
/// <param name="spillPosition">Returned spill position in world space coordinates.</param>
/// <param name="apertureStart">A value that determines where the aperture of the flask starts (0-1 where 0 is flask center and 1 is the very top).</param>
public bool GetSpillPoint(out Vector3 spillPosition, float apertureStart = 1f) {
float spillAmount;
return GetSpillPoint(out spillPosition, out spillAmount, apertureStart);
}
/// <summary>
/// Computes approximate point where liquid starts pouring over the flask when it's rotated
/// </summary>
/// <returns><c>true</c>, if spill point is detected, <c>false</c> otherwise.</returns>
/// <param name="spillPosition">Returned spill position in world space coordinates.</param>
/// <param name="spillAmount">A returned value that represent the amount of liquid spilt.</param>
/// <param name="apertureStart">A value that determines where the aperture of the flask starts (0-1 where 0 is flask center and 1 is the very top).</param>
public bool GetSpillPoint(out Vector3 spillPosition, out float spillAmount, float apertureStart = 1f) {
spillPosition = Vector3.zero;
spillAmount = 0;
if (mesh == null || verticesSorted == null || levelMultipled <= 0)
return false;
float maxy = float.MinValue;
for (int k = 0; k < verticesSorted.Length; k++) {
Vector3 vertex = verticesSorted[k];
if (vertex.y > maxy) {
maxy = vertex.y;
}
}
float clampy = maxy * apertureStart * 0.99f;
Vector3 vt = transform.position;
bool crossed = false;
float miny = float.MaxValue;
for (int k = 0; k < verticesSorted.Length; k++) {
Vector3 vertex = verticesSorted[k];
if (vertex.y < clampy)
break;
vertex = transform.TransformPoint(vertex);
if (vertex.y < liquidLevelPos && vertex.y < miny) {
miny = vertex.y;
vt = vertex;
crossed = true;
}
}
if (!crossed)
return false;
spillPosition = vt;
spillAmount = (liquidLevelPos - vt.y) / (mesh.bounds.extents.y * 2f * transform.localScale.y);
return true;
}
void UpdateSpillPointGizmo() {
if (!_debugSpillPoint) {
if (spillPointGizmo != null) {
DestroyImmediate(spillPointGizmo.gameObject);
spillPointGizmo = null;
}
return;
}
if (spillPointGizmo == null) {
Transform t = transform.Find(SPILL_POINT_GIZMO);
if (t != null) {
DestroyImmediate(t.gameObject);
}
spillPointGizmo = GameObject.CreatePrimitive(PrimitiveType.Sphere);
spillPointGizmo.name = SPILL_POINT_GIZMO;
spillPointGizmo.transform.SetParent(transform, true);
Collider collider = spillPointGizmo.GetComponent<Collider>();
if (collider != null)
DestroyImmediate(collider);
MeshRenderer mr = spillPointGizmo.GetComponent<MeshRenderer>();
if (mr != null) {
mr.sharedMaterial = Instantiate(mr.sharedMaterial); // to avoid Editor (non playing) warning
mr.sharedMaterial.hideFlags = HideFlags.DontSave;
mr.sharedMaterial.color = Color.yellow;
}
}
Vector3 spillPoint;
if (GetSpillPoint(out spillPoint, 1f)) {
spillPointGizmo.transform.position = spillPoint;
if (mesh != null) {
Vector3 size = mesh.bounds.extents * 0.2f;
float s = size.x > size.y ? size.x : size.z;
s = s > size.z ? s : size.z;
spillPointGizmo.transform.localScale = new Vector3(s, s, s);
} else {
spillPointGizmo.transform.localScale = new Vector3(0.05f, 0.05f, 0.05f);
}
spillPointGizmo.SetActive(true);
} else {
spillPointGizmo.SetActive(false);
}
}
/// <summary>
/// Applies current transform rotation and scale to the vertices and resets the transform rotation and scale to default values.
/// This operation makes the game object transform point upright as normal game objects and is required for Liquid Volume to work on imported models that comes with a rotation
/// </summary>
public void BakeRotation() {
if (transform.localRotation == transform.rotation) {
// nothing to do!
return;
}
MeshFilter mf = GetComponent<MeshFilter>();
Mesh mesh = mf.sharedMesh;
if (mesh == null) return;
mesh = Instantiate(mesh);
Vector3[] vertices = mesh.vertices;
Vector3 scale = transform.localScale;
Vector3 localPos = transform.localPosition;
transform.localScale = Vector3.one;
Transform parent = transform.parent;
if (parent != null) {
transform.SetParent(null, false);
}
for (int k = 0; k < vertices.Length; k++) {
vertices[k] = transform.TransformVector(vertices[k]);
}
mesh.vertices = vertices;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mf.sharedMesh = mesh;
// Ensure parent has no different rotation
if (parent != null) {
transform.SetParent(parent, false);
transform.localPosition = localPos;
}
transform.localRotation = Quaternion.Euler(0, 0, 0);
transform.localScale = scale;
RefreshMeshAndCollider();
}
/// <summary>
/// This operation computes the geometric center of all vertices and displaces them so the pivot is centered in the model
/// </summary>
public void CenterPivot() {
CenterPivot(Vector3.zero, false);
}
readonly List<Vertex> hullVertices = new List<Vertex>();
[SerializeField]
Mesh fixedMesh, closedMesh;
/// <summary>
/// This operation computes the geometric center of all vertices and displaces them so the pivot is centered in the model
/// </summary>
public void CenterPivot(Vector3 offset, bool closeMesh) {
MeshFilter mf = GetComponent<MeshFilter>();
Mesh mesh = mf.sharedMesh;
if (mesh == null) return;
mesh = Instantiate(mesh);
mesh.name = mf.sharedMesh.name; // keep original name to detect if user assigns a different mesh to meshfilter and discard originalMesh reference
Vector3[] vertices = mesh.vertices;
if (closeMesh) {
hullVertices.Clear();
for (int k = 0; k < vertices.Length; k++) {
hullVertices.Add(new Vertex(vertices[k]));
}
// Create hull
var result = ConvexHull.Create(hullVertices);
mesh.Clear();
mesh.vertices = result.Points.Select(x => x.ToVec()).ToArray();
var xxx = result.Points.ToList();
List<int> triangles = new List<int>();
foreach (var face in result.Faces) {
triangles.Add(xxx.IndexOf(face.Vertices[0]));
triangles.Add(xxx.IndexOf(face.Vertices[1]));
triangles.Add(xxx.IndexOf(face.Vertices[2]));
}
mesh.SetTriangles(triangles, 0);
mesh.RecalculateBounds();
vertices = mesh.vertices;
closedMesh = mesh;
}
Vector3 midPoint = Vector3.zero;
for (int k = 0; k < vertices.Length; k++) {
midPoint += vertices[k];
}
midPoint /= vertices.Length;
midPoint += offset;
for (int k = 0; k < vertices.Length; k++) {
vertices[k] -= midPoint;
}
mesh.vertices = vertices;
mesh.RecalculateBounds();
if (closeMesh) {
mesh.RecalculateNormals();
}
mf.sharedMesh = mesh;
fixedMesh = mesh;
Vector3 localScale = transform.localScale;
midPoint.x *= localScale.x;
midPoint.y *= localScale.y;
midPoint.z *= localScale.z;
transform.localPosition += midPoint;
RefreshMeshAndCollider();
}
public void RefreshMeshAndCollider() {
ClearMeshCache();
MeshCollider mc = GetComponent<MeshCollider>();
if (mc != null) {
Mesh oldMesh = mc.sharedMesh;
mc.sharedMesh = null;
mc.sharedMesh = oldMesh;
}
}
/// <summary>
/// Assigns a new layer density and optionally keep the same volume
/// </summary>
/// <param name="newDensity">New density.</param>
/// <param name="keepVolume">If set to <c>true</c> keep volume.</param>
public void SetLayerDensity(int layerIndex, float newDensity, bool keepVolume) {
if (layerIndex < 0 || _liquidLayers == null || layerIndex >= _liquidLayers.Length)
return;
float amount = _liquidLayers[layerIndex].amount;
if (keepVolume && _liquidLayers[layerIndex].density > 0) {
amount *= newDensity / _liquidLayers[layerIndex].density;
}
_liquidLayers[layerIndex].amount = amount;
_liquidLayers[layerIndex].density = newDensity;
}
#endregion
#region Multiple layers
void InitLayers() {
requireLayersUpdate = true;
lastLayerCount = -1;
if (_liquidLayers == null)
return;
for (int k = 0; k < _liquidLayers.Length; k++) {
_liquidLayers[k].ResetCurrentStates();
}
}
public void UpdateLayers(bool immediate = false) {
shouldUpdateMaterialProperties = true;
requireLayersUpdate = true;
lastLayerCount = _liquidLayers.Length;
if (immediate) {
this.immediate = true;
RenderObject();
}
}
void UpdateLayersNow() {
requireLayersUpdate = false;
if (_liquidLayers == null) {
_liquidLayers = new LiquidLayer[0];
} else if (_liquidLayers.Length > MAX_LAYERS) {
Array.Resize(ref _liquidLayers, MAX_LAYERS);
Debug.Log("Liquid layers max count exceeded. Capping to " + MAX_LAYERS + ".");
}
if (lastLayerCount >= 0 && lastLayerCount < _liquidLayers.Length) {
for (int k = lastLayerCount; k < _liquidLayers.Length; k++) {
_liquidLayers[k].SetDefaults(k);
}
}
lastLayerCount = _liquidLayers.Length;
if (sortedLayers == null || sortedLayers.Length < MAX_LAYERS) {
sortedLayers = new int[MAX_LAYERS];
}
// ensure proper values
for (int k = 0; k < _liquidLayers.Length; k++) {
_liquidLayers[k].amount = Mathf.Max(0, _liquidLayers[k].amount);
_liquidLayers[k].scale = Mathf.Clamp(_liquidLayers[k].scale, 0.001f, 0.48f);
_liquidLayers[k].murkiness = Mathf.Clamp01(_liquidLayers[k].murkiness);
if (_liquidLayers[k].adjustmentSpeed <= 0)
_liquidLayers[k].adjustmentSpeed = 1f;
if (_liquidLayers[k].density < 0.001f)
_liquidLayers[k].density = 0.001f;
}
// Sort & stack by density
sortedLayersCount = 0;
float currentDensity = float.MaxValue;
float baseLevel = 0;
for (int k = 0; k < _liquidLayers.Length; k++) {
float maxDensity = float.MinValue;
// Pick greater density first
for (int j = 0; j < _liquidLayers.Length; j++) {
float density = _liquidLayers[j].density;
if (density > maxDensity && density < currentDensity) {
maxDensity = density;
}
}
if (maxDensity == float.MinValue)
break;
// Place layers of the mix
for (int j = 0; j < _liquidLayers.Length; j++) {
if (_liquidLayers[j].density == maxDensity) {
_liquidLayers[j].baseLevel = baseLevel;
sortedLayers[sortedLayersCount++] = j;
baseLevel += _liquidLayers[j].amount / _liquidLayers[j].density;
}
}
currentDensity = maxDensity;
}
// Handle miscible layers
for (int k = 0; k < sortedLayersCount; k++) {
int i = sortedLayers[k];
if (_liquidLayers[i].miscible) {
LiquidLayer temp = new LiquidLayer();
int j = k;
float groupBaseLevel = _liquidLayers[i].baseLevel;
float groupDensity = _liquidLayers[i].density;
while (_liquidLayers[i].miscible && _liquidLayers[i].density == groupDensity) {
float amount = Mathf.Max(_liquidLayers[i].amount, 0.0001f);
temp.color += _liquidLayers[i].color * amount;
temp.murkColor += _liquidLayers[i].murkColor * amount;
temp.murkiness += _liquidLayers[i].murkiness * amount;
temp.scale += _liquidLayers[i].scale * amount;
temp.amount += amount;
if (++j >= sortedLayersCount)
break;
i = sortedLayers[j];
}
// Combine
for (int l = k; l < j; l++) {
i = sortedLayers[l];
_liquidLayers[i].mixedColor = temp.color / temp.amount;
_liquidLayers[i].mixedColor2 = temp.murkColor / temp.amount;
_liquidLayers[i].mixedMurkiness = temp.murkiness / temp.amount;
_liquidLayers[i].mixedScale = temp.scale / temp.amount;
_liquidLayers[i].mixedBubblesOpacity = temp.bubblesOpacity / temp.amount;
_liquidLayers[i].mixedAmount = temp.amount / groupDensity;
_liquidLayers[i].baseLevel = groupBaseLevel;
}
k = j - 1;
} else {
_liquidLayers[i].mixedColor = _liquidLayers[i].color;
_liquidLayers[i].mixedColor2 = _liquidLayers[i].murkColor;
_liquidLayers[i].mixedMurkiness = _liquidLayers[i].murkiness;
_liquidLayers[i].mixedScale = _liquidLayers[i].scale;
_liquidLayers[i].mixedBubblesOpacity = _liquidLayers[i].bubblesOpacity;
_liquidLayers[i].mixedAmount = Mathf.Clamp01(_liquidLayers[i].amount / _liquidLayers[i].density);
}
}
// Compact
for (int k = 0; k < sortedLayersCount - 1; k++) {
int i = sortedLayers[k];
int j = sortedLayers[k + 1];
float expectedBaseLevel = _liquidLayers[i].baseLevel + _liquidLayers[i].mixedAmount;
if (_liquidLayers[j].baseLevel > expectedBaseLevel) {
_liquidLayers[j].baseLevel = expectedBaseLevel;
}
}
AnimateLayers(true);
}
int layerComparer(LiquidLayer layer1, LiquidLayer layer2) {
return layer1.density.CompareTo(layer2.density);
}
void AnimateLayers(bool changes = false) {
if (Application.isPlaying) {
for (int j = 0; j < sortedLayersCount; j++) {
int k = sortedLayers[j];
if (_liquidLayers[k].currentBaseLevel != _liquidLayers[k].baseLevel || _liquidLayers[k].currentAmount != _liquidLayers[k].mixedAmount || _liquidLayers[k].currentMurkiness != _liquidLayers[k].mixedMurkiness || _liquidLayers[k].currentBubblesOpacity != _liquidLayers[k].mixedBubblesOpacity || _liquidLayers[k].currentColor != _liquidLayers[k].mixedColor || _liquidLayers[k].currentColor2 != _liquidLayers[k].mixedColor2) {
float t = Time.deltaTime * _layersAdjustmentSpeed * _liquidLayers[k].adjustmentSpeed;
if (t > 1f || immediate) {
t = 1f;
}
if (Similar(_liquidLayers[k].currentBaseLevel, _liquidLayers[k].baseLevel)) {
_liquidLayers[k].currentBaseLevel = _liquidLayers[k].baseLevel;
} else {
_liquidLayers[k].currentBaseLevel = Mathf.Lerp(_liquidLayers[k].currentBaseLevel, _liquidLayers[k].baseLevel, t);
}
if (Similar(_liquidLayers[k].currentAmount, _liquidLayers[k].mixedAmount)) {
_liquidLayers[k].currentAmount = _liquidLayers[k].mixedAmount;
} else {
_liquidLayers[k].currentAmount = Mathf.Lerp(_liquidLayers[k].currentAmount, _liquidLayers[k].mixedAmount, t);
}
if (Similar(_liquidLayers[k].currentMurkiness, _liquidLayers[k].mixedMurkiness)) {
_liquidLayers[k].currentMurkiness = _liquidLayers[k].mixedMurkiness;
} else {
_liquidLayers[k].currentMurkiness = Mathf.Lerp(_liquidLayers[k].currentMurkiness, _liquidLayers[k].mixedMurkiness, t);
}
if (Similar(ref _liquidLayers[k].currentColor, ref _liquidLayers[k].mixedColor)) {
_liquidLayers[k].currentColor = _liquidLayers[k].mixedColor;
} else {
_liquidLayers[k].currentColor = Color.Lerp(_liquidLayers[k].currentColor, _liquidLayers[k].mixedColor, t);
}
if (Similar(ref _liquidLayers[k].currentColor2, ref _liquidLayers[k].mixedColor2)) {
_liquidLayers[k].currentColor2 = _liquidLayers[k].mixedColor2;
} else {
_liquidLayers[k].currentColor2 = Color.Lerp(_liquidLayers[k].currentColor2, _liquidLayers[k].mixedColor2, t);
}
if (Similar(_liquidLayers[k].currentBubblesOpacity, _liquidLayers[k].mixedBubblesOpacity)) {
_liquidLayers[k].currentBubblesOpacity = _liquidLayers[k].mixedBubblesOpacity;
} else {
_liquidLayers[k].currentBubblesOpacity = Mathf.Lerp(_liquidLayers[k].currentBubblesOpacity, _liquidLayers[k].mixedBubblesOpacity, t);
}
changes = true;
}
}
if (changes) {
// Compact
if (_layersAdjustmentCompact) {
float currentBaseLevel = float.MinValue;
float expectedBaseLevel = 0;
for (int k = 0; k < _liquidLayers.Length; k++) {
// Get the minimum
float minCurrentBaseLevel = float.MaxValue;
int min = -1;
for (int j = 0; j < _liquidLayers.Length; j++) {
if (_liquidLayers[j].currentBaseLevel < minCurrentBaseLevel && _liquidLayers[j].currentBaseLevel > currentBaseLevel) {
minCurrentBaseLevel = _liquidLayers[j].currentBaseLevel;
min = j;
}
}
if (min < 0)
break;
if (k > 0) {
if (_liquidLayers[min].currentBaseLevel > expectedBaseLevel) {
_liquidLayers[min].currentBaseLevel = expectedBaseLevel;
}
}
expectedBaseLevel = _liquidLayers[min].currentBaseLevel + _liquidLayers[min].currentAmount;
currentBaseLevel = _liquidLayers[min].currentBaseLevel;
}
}
}
} else {
for (int j = 0; j < sortedLayersCount; j++) {
int k = sortedLayers[j];
if (_liquidLayers[k].currentBaseLevel != _liquidLayers[k].baseLevel || _liquidLayers[k].currentAmount != _liquidLayers[k].mixedAmount || _liquidLayers[k].currentMurkiness != _liquidLayers[k].mixedMurkiness || _liquidLayers[k].currentColor != _liquidLayers[k].mixedColor || _liquidLayers[k].currentColor2 != _liquidLayers[k].mixedColor2) {
_liquidLayers[k].currentBaseLevel = _liquidLayers[k].baseLevel;
_liquidLayers[k].currentAmount = _liquidLayers[k].mixedAmount;
_liquidLayers[k].currentColor = _liquidLayers[k].mixedColor;
_liquidLayers[k].currentColor2 = _liquidLayers[k].mixedColor2;
_liquidLayers[k].currentMurkiness = _liquidLayers[k].mixedMurkiness;
_liquidLayers[k].currentBubblesOpacity = _liquidLayers[k].mixedBubblesOpacity;
changes = true;
}
}
}
immediate = false;
if (changes) {
UpdateLayersProperties();
}
}
bool Similar(float a, float b) {
if (a < b) {
return (b - a) < 0.01f;
} else {
return (a - b) < 0.01f;
}
}
bool Similar(ref Color a, ref Color b) {
float dr, dg, db, da;
dr = a.r < b.r ? b.r - a.r : a.r - b.r;
if (dr > 0.01f)
return false;
dg = a.g < b.g ? b.g - a.g : a.g - b.g;
if (dg > 0.01f)
return false;
db = a.b < b.b ? b.b - a.b : a.b - b.b;
if (db > 0.01f)
return false;
da = a.a < b.a ? b.a - a.a : a.a - b.a;
return da < 0.01f;
}
void UpdateLayersProperties() {
if (_liquidLayers == null || sortedLayers == null || liqMat == null)
return;
const int LAYERS_RESOLUTION = 256;
if (layersTextureColors == null || layersTextureColors.Length != LAYERS_RESOLUTION) {
layersTextureColors = new Color[LAYERS_RESOLUTION];
}
if (layersTextureColors2 == null || layersTextureColors2.Length != LAYERS_RESOLUTION) {
layersTextureColors2 = new Color[LAYERS_RESOLUTION];
}
if (layersTextureColorsTemp == null || layersTextureColorsTemp.Length != LAYERS_RESOLUTION) {
layersTextureColorsTemp = new Color[LAYERS_RESOLUTION];
}
if (layersProperties == null || layersProperties.Length != LAYERS_RESOLUTION) {
layersProperties = new Vector4[LAYERS_RESOLUTION];
}
if (layersSum == null || layersSum.Length != LAYERS_RESOLUTION) {
layersSum = new float[LAYERS_RESOLUTION];
}
Color colorNull = new Color(0, 0, 0, 0);
Vector4 zero = Vector4.zero;
for (int j = 0; j < LAYERS_RESOLUTION; j++) {
layersTextureColors[j] = colorNull;
layersTextureColors2[j] = colorNull;
layersTextureColorsTemp[j] = colorNull;
layersProperties[j] = zero;
layersSum[j] = 0;
}
float level = 0;
for (int k = 0; k < sortedLayersCount; k++) {
float layerBaseLevel = _liquidLayers[k].currentBaseLevel;
float layerAmount = _liquidLayers[k].currentAmount;
if (layerAmount + layerBaseLevel > 1f) {
layerAmount = 1f - layerBaseLevel;
if (layerAmount < 0)
layerAmount = 0;
}
if (level < layerBaseLevel + layerAmount)
level = layerBaseLevel + layerAmount;
}
if (level != _level) {
_level = level;
UpdateLevels();
}
int y = 0, y_next = 0;
for (int i = 0; i < sortedLayersCount; i++) {
int k = sortedLayers[i];
Color layerColor = ApplyGlobalAlpha(_liquidLayers[k].currentColor);
Color layerColor2 = ApplyGlobalAlpha(_liquidLayers[k].currentColor2);
float alpha = layerColor.a;
layerColor *= alpha;
layerColor2 *= alpha;
float layerMurkiness = _liquidLayers[k].currentMurkiness * alpha;
float layerScale = _liquidLayers[k].mixedScale * 10.0f;
float layerBaseLevel = _liquidLayers[k].currentBaseLevel * _levelMultiplier;
float layerAmount = _liquidLayers[k].currentAmount * _levelMultiplier;
float layerTurbulence = _liquidLayers[k].viscosity * alpha;
float layerBubblesOpacity = _liquidLayers[k].bubblesOpacity * alpha;
y = (int)((levelMultipled - layerBaseLevel) * LAYERS_RESOLUTION);
y_next = (int)((levelMultipled - layerBaseLevel - layerAmount) * LAYERS_RESOLUTION);
for (int j = y_next; j < y; j++) {
if (j >= 0 && j < LAYERS_RESOLUTION) {
layersTextureColors[j] += layerColor;
layersTextureColors2[j] += layerColor2;
layersProperties[j].x += layerMurkiness;
layersProperties[j].y = layerScale > layersProperties[j].y ? layerScale : layersProperties[j].y;
layersProperties[j].z += layerTurbulence;
layersProperties[j].w += layerBubblesOpacity;
layersSum[j] += alpha;
}
}
}
int lastLayer = 0;
for (int j = 0; j < LAYERS_RESOLUTION; j++) {
float m = layersSum[j];
if (m > 0) {
layersTextureColors[j] /= m;
layersTextureColors2[j] /= m;
layersProperties[j].x /= m;
layersProperties[j].z /= m;
layersProperties[j].w /= m;
lastLayer = j;
}
}
// Copy last layer to fill gap when tilting liquid
if (!_ignoreGravity) {
for (int j = lastLayer + 1; j < LAYERS_RESOLUTION; j++) {
layersTextureColors[j] = layersTextureColors[lastLayer];
layersTextureColors2[j] = layersTextureColors2[lastLayer];
layersProperties[j] = layersProperties[lastLayer];
}
}
// Smooth contact surfaces
if (_smoothContactSurface > 0) {
for (int j = 0; j < LAYERS_RESOLUTION; j++) {
Color sum = colorNull;
int count = 0;
for (int k = j - _smoothContactSurface; k <= j + _smoothContactSurface; k++) {
if (k >= 0 && k < LAYERS_RESOLUTION) {
sum += layersTextureColors[k];
count++;
}
}
layersTextureColorsTemp[j] = sum / count;
}
// Blit colors back
for (int j = 0; j < LAYERS_RESOLUTION; j++) {
layersTextureColors[j] = layersTextureColorsTemp[j];
}
}
UploadMaterialArrays();
#if UNITY_WEBGL
SetLayersTextures();
#else
if (FORCE_GLES_COMPATIBILITY) {
SetLayersTextures();
}
#endif
}
void UploadMaterialArrays() {
liqMat.SetColorArray(ShaderParams.LayersColorArray, layersTextureColors);
liqMat.SetColorArray(ShaderParams.LayersColor2Array, layersTextureColors2);
liqMat.SetVectorArray(ShaderParams.LayersProperties, layersProperties);
}
void SetLayersTextures() {
if (layersPropertiesTex == null) {
layersPropertiesTex = new Texture2D(1, 256, TextureFormat.RGBAFloat, false, true);
layersPropertiesTex.filterMode = FilterMode.Point;
layersPropertiesTex.wrapMode = TextureWrapMode.Clamp;
}
if (layersColorsTex == null) {
layersColorsTex = new Texture2D(1, 256, TextureFormat.ARGB32, false);
layersColorsTex.filterMode = FilterMode.Point;
layersColorsTex.wrapMode = TextureWrapMode.Clamp;
}
if (layersPropertiesTexContents == null || layersPropertiesTexContents.Length < 256) {
layersPropertiesTexContents = new Color[256];
}
if (layersColorsTexContents == null || layersColorsTexContents.Length < 256) {
layersColorsTexContents = new Color[256];
}
if (layersColors2Tex == null) {
layersColors2Tex = new Texture2D(1, 256, TextureFormat.ARGB32, false);
layersColors2Tex.filterMode = FilterMode.Point;
layersColors2Tex.wrapMode = TextureWrapMode.Clamp;
}
if (layersColors2TexContents == null || layersColors2TexContents.Length < 256) {
layersColors2TexContents = new Color[256];
}
for (int k = 0; k < 256; k++) {
layersPropertiesTexContents[k].r = layersProperties[k].x;
layersPropertiesTexContents[k].g = layersProperties[k].y;
layersPropertiesTexContents[k].b = layersProperties[k].z;
layersPropertiesTexContents[k].a = layersProperties[k].w;
layersColorsTexContents[k] = layersTextureColors[k];
layersColors2TexContents[k] = layersTextureColors2[k];
}
layersPropertiesTex.SetPixels(layersPropertiesTexContents);
layersPropertiesTex.Apply();
liqMat.SetTexture(ShaderParams.LayersPropertiesTex, layersPropertiesTex);
layersColorsTex.SetPixels(layersColorsTexContents);
layersColorsTex.Apply();
liqMat.SetTexture(ShaderParams.LayersColorsTex, layersColorsTex);
layersColors2Tex.SetPixels(layersColors2TexContents);
layersColors2Tex.Apply();
liqMat.SetTexture(ShaderParams.LayersColors2Tex, layersColors2Tex);
}
public void Redraw() {
if (_liquidLayers != null) {
for (int k = 0; k < _liquidLayers.Length; k++) {
_liquidLayers[k].baseLevel = 0;
_liquidLayers[k].currentAmount = 0;
_liquidLayers[k].currentBaseLevel = 0;
}
requireLayersUpdate = true;
}
UpdateMaterialProperties();
}
#endregion
#region Mesh Displacement
void CheckMeshDisplacement() {
MeshFilter meshFilter = GetComponent<MeshFilter>();
if (meshFilter == null) {
originalMesh = null;
return;
}
Mesh currentMesh = meshFilter.sharedMesh;
if (currentMesh == null) {
if (_fixMesh) {
if (_autoCloseMesh && closedMesh != null) {
meshFilter.sharedMesh = closedMesh;
return;
} else if (!_autoCloseMesh && fixedMesh != null) {
meshFilter.sharedMesh = fixedMesh;
return;
} else if (originalMesh != null) {
meshFilter.sharedMesh = originalMesh;
}
} else {
originalMesh = null;
return;
}
currentMesh = meshFilter.sharedMesh;
}
if (!_fixMesh) {
RestoreOriginalMesh();
originalMesh = null;
return;
}
if (_autoCloseMesh && currentMesh == closedMesh) return;
if (!_autoCloseMesh && currentMesh == fixedMesh) return;
// Backup original mesh
if (originalMesh == null || !(originalMesh.name.Equals(currentMesh.name))) {
originalMesh = meshFilter.sharedMesh;
}
if (currentMesh != originalMesh) {
RestoreOriginalMesh();
}
Vector3 pos = transform.localPosition;
CenterPivot(_pivotOffset, _autoCloseMesh);
originalPivotOffset = transform.localPosition - pos;
}
void RestoreOriginalMesh() {
fixedMesh = closedMesh = null;
if (originalMesh == null) return;
MeshFilter meshFilter = GetComponent<MeshFilter>();
if (meshFilter == null) return;
meshFilter.sharedMesh = originalMesh;
transform.localPosition -= originalPivotOffset;
RefreshMeshAndCollider();
}
#endregion
#region Bubbles support
void AddBubbles(Texture3D tex) {
if (tex == null)
return;
if (_bubblesSizeMax < _bubblesSizeMin) {
_bubblesSizeMax = _bubblesSizeMin;
}
int size = tex.width;
Array.Copy(colors3D[currentNoiseVariation], colors3DWithBubbles[currentNoiseVariation], colors3DWithBubbles[currentNoiseVariation].Length);
Color[] colors = colors3DWithBubbles[currentNoiseVariation];
// Clear bubble buffer
for (int k = 0; k < colors.Length; k++) {
colors[k].g = 0.5f;
colors[k].b = 0.5f;
colors[k].a = 0.5f;
}
// Save current random state
Random.InitState(_bubblesSeed);
// Mark bubble positions
Vector3 nrm = Vector3.zero;
for (int k = 0; k < _bubblesAmount; k++) {
int bubbleSize = Random.Range(_bubblesSizeMin, _bubblesSizeMax + 1);
float bubbleSizeSqr = (float)(bubbleSize * bubbleSize);
int y = Random.Range(bubbleSize, size - bubbleSize);
int z = Random.Range(bubbleSize, size - bubbleSize);
int x = Random.Range(bubbleSize, size - bubbleSize);
for (int y2 = y - bubbleSize; y2 <= y + bubbleSize; y2++) {
float dy = y2 - y;
for (int z2 = z - bubbleSize; z2 <= z + bubbleSize; z2++) {
float dz = z2 - z;
for (int x2 = x - bubbleSize; x2 <= x + bubbleSize; x2++) {
float dx = x2 - x;
float dSqr = dy * dy + dz * dz + dx * dx;
float d = 1f - dSqr / bubbleSizeSqr;
if (d >= 0) {
float l = (float)System.Math.Sqrt(dSqr);
nrm.x = dx / l;
nrm.y = dy / l;
nrm.z = dz / l;
nrm.x = (nrm.x + 1f) * 0.5f;
nrm.y = (nrm.y + 1f) * 0.5f;
nrm.z = (nrm.z + 1f) * 0.5f;
int c = y2 * size * size + z2 * size + x2;
colors[c].g = nrm.x;
colors[c].b = nrm.y;
colors[c].a = nrm.z;
}
}
}
}
}
#if UNITY_WEBGL
bool useUnwrappedTexture = true;
#else
bool useUnwrappedTexture = FORCE_GLES_COMPATIBILITY;
#endif
if (useUnwrappedTexture) {
if (noise3DUnwrapped == null) {
noise3DUnwrapped = new Texture2D(size, size * size, TextureFormat.RGBA32, false, true);
}
noise3DUnwrapped.SetPixels(colors);
noise3DUnwrapped.Apply();
liqMat.SetTexture(ShaderParams.NoiseTexUnwrapped, noise3DUnwrapped);
}
// Push colors to texture
tex.SetPixels(colors);
tex.Apply();
}
void ClearBubbles(Texture3D tex) {
if (tex == null)
return;
Array.Copy(colors3D[currentNoiseVariation], colors3DWithBubbles[currentNoiseVariation], colors3DWithBubbles[currentNoiseVariation].Length);
Color[] colors = colors3DWithBubbles[currentNoiseVariation];
// Clear bubble buffer
for (int k = 0; k < colors.Length; k++) {
colors[k].g = 0.5f;
colors[k].b = 0.5f;
colors[k].a = 0.5f;
}
// Push colors to texture
tex.SetPixels(colors);
tex.Apply();
liqMat.SetTexture(ShaderParams.NoiseTexUnwrapped, null);
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink