Skip to content

Y
YGOProUnity_V2
Commit f21b0cad authored by 神楽坂玲奈's avatar 神楽坂玲奈
Browse files
Options

fix deckmanager tween

parent d5e4c383
Show whitespace changes
Inline Side-by-side
Showing with 16445 additions and 16 deletions
Assets/ArtSystem/deckManager/MonoCardInDeckManager.cs
View file @ f21b0cad
using UnityEngine; using UnityEngine;
using System.Collections; using System.Collections;
using System; using System;
using DG.Tweening;
public class MonoCardInDeckManager : MonoBehaviour { public class MonoCardInDeckManager : MonoBehaviour {
int loadedPicCode = 0; int loadedPicCode = 0;
...@@ -108,28 +109,31 @@ public class MonoCardInDeckManager : MonoBehaviour { ...@@ -108,28 +109,31 @@ public class MonoCardInDeckManager : MonoBehaviour {
} }
} }
public void tweenToVectorAndFall(Vector3 position,Vector3 rotation,float delay=0) public void tweenToVectorAndFall(Vector3 position,Vector3 rotation)
{ {
Rigidbody rigidbody = GetComponent<Rigidbody>(); Rigidbody rigidbody = GetComponent<Rigidbody>();
if (rigidbody != null) if (rigidbody != null)
{ {
rigidbody.Sleep(); rigidbody.Sleep();
} }
iTween.MoveTo(gameObject, iTween.Hash(
"delay", delay, transform.DOMove(position, 0.2f).OnComplete(physicalON);
"x", position.x, transform.DORotate(rotation, 0.15f);
"y", position.y, // iTween.MoveTo(gameObject, iTween.Hash(
"z", position.z, // "delay", delay,
"time", 0.2f, // "x", position.x,
"oncomplete", (Action)physicalON // "y", position.y,
)); // "z", position.z,
iTween.RotateTo(gameObject, iTween.Hash( // "time", 0.2f,
"delay", delay, // "oncomplete", (Action)physicalON
"x", rotation.x, // ));
"y", rotation.y, // iTween.RotateTo(gameObject, iTween.Hash(
"z", rotation.z, // "delay", delay,
"time", 0.15f // "x", rotation.x,
)); // "y", rotation.y,
// "z", rotation.z,
// "time", 0.15f
// ));
physicalOFF(); physicalOFF();
} }
......
Assets/Plugins/Demigiant.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8f722e4918e51b8499d59f1d1a2f0834
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTween.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a50bd9a009c8dfc4ebd88cc8101225a7
labels:
- iTween
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTween/DOTween.XML 0 → 100644
View file @ f21b0cad
This source diff could not be displayed because it is too large. You can view the blob instead.
Assets/Plugins/Demigiant/DOTween/DOTween.XML.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 34192c5e0d14aee43a0e86cc4823268a
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DOTween/DOTween.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4f007001a22b3d24dae350342c4d19c8
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTween/DOTween.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a811bde74b26b53498b4f6d872b09b6d
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 1
settings: {}
Editor:
enabled: 0
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTween/Editor.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: b27f58ae5d5c33a4bb2d1f4f34bd036d
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML 0 → 100644
View file @ f21b0cad
<?xml version="1.0"?>
<doc>
<assembly>
<name>DOTweenEditor</name>
</assembly>
<members>
<member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Start(System.Action)">
<summary>
Starts the update loop of tween in the editor. Has no effect during playMode.
</summary>
<param name="onPreviewUpdated">Eventual callback to call after every update</param>
</member>
<member name="M:DG.DOTweenEditor.DOTweenEditorPreview.Stop(System.Boolean)">
<summary>
Stops the update loop and clears the onPreviewUpdated callback.
</summary>
<param name="resetTweenTargets">If TRUE also resets the tweened objects to their original state</param>
</member>
<member name="M:DG.DOTweenEditor.DOTweenEditorPreview.PrepareTweenForPreview(DG.Tweening.Tween,System.Boolean,System.Boolean,System.Boolean)">
<summary>
Readies the tween for editor preview by setting its UpdateType to Manual plus eventual extra settings.
</summary>
<param name="t">The tween to ready</param>
<param name="clearCallbacks">If TRUE (recommended) removes all callbacks (OnComplete/Rewind/etc)</param>
<param name="preventAutoKill">If TRUE prevents the tween from being auto-killed at completion</param>
<param name="andPlay">If TRUE starts playing the tween immediately</param>
</member>
<member name="F:DG.DOTweenEditor.EditorVersion.Version">
<summary>Full major version + first minor version (ex: 2018.1f)</summary>
</member>
<member name="F:DG.DOTweenEditor.EditorVersion.MajorVersion">
<summary>Major version</summary>
</member>
<member name="F:DG.DOTweenEditor.EditorVersion.MinorVersion">
<summary>First minor version (ex: in 2018.1 it would be 1)</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.SetEditorTexture(UnityEngine.Texture2D,UnityEngine.FilterMode,System.Int32)">
<summary>
Checks that the given editor texture use the correct import settings,
and applies them if they're incorrect.
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.DOTweenSetupRequired">
<summary>
Returns TRUE if setup is required
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.AssetExists(System.String)">
<summary>
Returns TRUE if the file/directory at the given path exists.
</summary>
<param name="adbPath">Path, relative to Unity's project folder</param>
<returns></returns>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.ADBPathToFullPath(System.String)">
<summary>
Converts the given project-relative path to a full path,
with backward (\) slashes).
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.FullPathToADBPath(System.String)">
<summary>
Converts the given full path to a path usable with AssetDatabase methods
(relative to Unity's project folder, and with the correct Unity forward (/) slashes).
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.ConnectToSourceAsset``1(System.String,System.Boolean)">
<summary>
Connects to a <see cref="T:UnityEngine.ScriptableObject"/> asset.
If the asset already exists at the given path, loads it and returns it.
Otherwise, either returns NULL or automatically creates it before loading and returning it
(depending on the given parameters).
</summary>
<typeparam name="T">Asset type</typeparam>
<param name="adbFilePath">File path (relative to Unity's project folder)</param>
<param name="createIfMissing">If TRUE and the requested asset doesn't exist, forces its creation</param>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.GetAssemblyFilePath(System.Reflection.Assembly)">
<summary>
Full path for the given loaded assembly, assembly file included
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.AddGlobalDefine(System.String)">
<summary>
Adds the given global define if it's not already present
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.RemoveGlobalDefine(System.String)">
<summary>
Removes the given global define if it's present
</summary>
</member>
<member name="M:DG.DOTweenEditor.EditorUtils.HasGlobalDefine(System.String,System.Nullable{UnityEditor.BuildTargetGroup})">
<summary>
Returns TRUE if the given global define is present in all the <see cref="T:UnityEditor.BuildTargetGroup"/>
or only in the given <see cref="T:UnityEditor.BuildTargetGroup"/>, depending on passed parameters.<para/>
</summary>
<param name="id"></param>
<param name="buildTargetGroup"><see cref="T:UnityEditor.BuildTargetGroup"/>to use. Leave NULL to check in all of them.</param>
</member>
<member name="T:DG.DOTweenEditor.DOTweenDefines">
<summary>
Not used as menu item anymore, but as a utiity function
</summary>
</member>
</members>
</doc>
Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.XML.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 2e2c6224d345d9249acfa6e8ef40bb2d
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8f46310a8b0a8f04a92993c37c713243
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/DOTweenEditor.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 45d5034162d6cf04dbe46da84fc7d074
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 0
settings: {}
Editor:
enabled: 1
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTween/Editor/Imgs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 0034ebae0c2a9344e897db1160d71b6d
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/Imgs/DOTweenIcon.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8da095e39e9b4df488dfd436f81116d6
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 128
textureSettings:
filterMode: 1
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7051dba417b3d53409f2918f1ea4938d
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 256
textureSettings:
filterMode: 1
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Footer_dark.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 519694efe2bb2914788b151fbd8c01f4
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DOTween/Editor/Imgs/Header.jpg.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 78a59ca99f8987941adb61f9e14a06a7
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 512
textureSettings:
filterMode: 1
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DOTween/Modules.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 143604b8bad857d47a6f7cc7a533e2dc
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
#if true // MODULE_MARKER
using System;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#if UNITY_5 || UNITY_2017_1_OR_NEWER
using UnityEngine.Audio; // Required for AudioMixer
#endif
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenModuleAudio
{
#region Shortcuts
#region Audio
/// <summary>Tweens an AudioSource's volume to the given value.
/// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOFade(this AudioSource target, float endValue, float duration)
{
if (endValue < 0) endValue = 0;
else if (endValue > 1) endValue = 1;
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.volume, x => target.volume = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens an AudioSource's pitch to the given value.
/// Also stores the AudioSource as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOPitch(this AudioSource target, float endValue, float duration)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.pitch, x => target.pitch = x, endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#if UNITY_5 || UNITY_2017_1_OR_NEWER
#region AudioMixer (Unity 5 or Newer)
/// <summary>Tweens an AudioMixer's exposed float to the given value.
/// Also stores the AudioMixer as the tween's target so it can be used for filtered operations.
/// Note that you need to manually expose a float in an AudioMixerGroup in order to be able to tween it from an AudioMixer.</summary>
/// <param name="floatName">Name given to the exposed float to set</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOSetFloat(this AudioMixer target, string floatName, float endValue, float duration)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(()=> {
float currVal;
target.GetFloat(floatName, out currVal);
return currVal;
}, x=> target.SetFloat(floatName, x), endValue, duration);
t.SetTarget(target);
return t;
}
#region Operation Shortcuts
/// <summary>
/// Completes all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens completed
/// (meaning the tweens that don't have infinite loops and were not already complete)
/// </summary>
/// <param name="withCallbacks">For Sequences only: if TRUE also internal Sequence callbacks will be fired,
/// otherwise they will be ignored</param>
public static int DOComplete(this AudioMixer target, bool withCallbacks = false)
{
return DOTween.Complete(target, withCallbacks);
}
/// <summary>
/// Kills all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens killed.
/// </summary>
/// <param name="complete">If TRUE completes the tween before killing it</param>
public static int DOKill(this AudioMixer target, bool complete = false)
{
return DOTween.Kill(target, complete);
}
/// <summary>
/// Flips the direction (backwards if it was going forward or viceversa) of all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens flipped.
/// </summary>
public static int DOFlip(this AudioMixer target)
{
return DOTween.Flip(target);
}
/// <summary>
/// Sends to the given position all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens involved.
/// </summary>
/// <param name="to">Time position to reach
/// (if higher than the whole tween duration the tween will simply reach its end)</param>
/// <param name="andPlay">If TRUE will play the tween after reaching the given position, otherwise it will pause it</param>
public static int DOGoto(this AudioMixer target, float to, bool andPlay = false)
{
return DOTween.Goto(target, to, andPlay);
}
/// <summary>
/// Pauses all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens paused.
/// </summary>
public static int DOPause(this AudioMixer target)
{
return DOTween.Pause(target);
}
/// <summary>
/// Plays all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens played.
/// </summary>
public static int DOPlay(this AudioMixer target)
{
return DOTween.Play(target);
}
/// <summary>
/// Plays backwards all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens played.
/// </summary>
public static int DOPlayBackwards(this AudioMixer target)
{
return DOTween.PlayBackwards(target);
}
/// <summary>
/// Plays forward all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens played.
/// </summary>
public static int DOPlayForward(this AudioMixer target)
{
return DOTween.PlayForward(target);
}
/// <summary>
/// Restarts all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens restarted.
/// </summary>
public static int DORestart(this AudioMixer target)
{
return DOTween.Restart(target);
}
/// <summary>
/// Rewinds all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens rewinded.
/// </summary>
public static int DORewind(this AudioMixer target)
{
return DOTween.Rewind(target);
}
/// <summary>
/// Smoothly rewinds all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens rewinded.
/// </summary>
public static int DOSmoothRewind(this AudioMixer target)
{
return DOTween.SmoothRewind(target);
}
/// <summary>
/// Toggles the paused state (plays if it was paused, pauses if it was playing) of all tweens that have this target as a reference
/// (meaning tweens that were started from this target, or that had this target added as an Id)
/// and returns the total number of tweens involved.
/// </summary>
public static int DOTogglePause(this AudioMixer target)
{
return DOTween.TogglePause(target);
}
#endregion
#endregion
#endif
#endregion
}
}
#endif
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleAudio.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: b766d08851589514b97afb23c6f30a70
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
#if true // MODULE_MARKER
using System;
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
using DG.Tweening.Plugins;
using DG.Tweening.Plugins.Core.PathCore;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenModulePhysics
{
#region Shortcuts
#region Rigidbody
/// <summary>Tweens a Rigidbody's position to the given value.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOMove(this Rigidbody target, Vector3 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody's X position to the given value.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveX(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue, 0, 0), duration);
t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody's Y position to the given value.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveY(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, endValue, 0), duration);
t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody's Z position to the given value.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOMoveZ(this Rigidbody target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue), duration);
t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody's rotation to the given value.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="mode">Rotation mode</param>
public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DORotate(this Rigidbody target, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
{
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
t.SetTarget(target);
t.plugOptions.rotateMode = mode;
return t;
}
/// <summary>Tweens a Rigidbody's rotation so that it will look towards the given position.
/// Also stores the rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="towards">The position to look at</param><param name="duration">The duration of the tween</param>
/// <param name="axisConstraint">Eventual axis constraint for the rotation</param>
/// <param name="up">The vector that defines in which direction up is (default: Vector3.up)</param>
public static TweenerCore<Quaternion, Vector3, QuaternionOptions> DOLookAt(this Rigidbody target, Vector3 towards, float duration, AxisConstraint axisConstraint = AxisConstraint.None, Vector3? up = null)
{
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, towards, duration)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetLookAt);
t.plugOptions.axisConstraint = axisConstraint;
t.plugOptions.up = (up == null) ? Vector3.up : (Vector3)up;
return t;
}
#region Special
/// <summary>Tweens a Rigidbody's position to the given value, while also applying a jump effect along the Y axis.
/// Returns a Sequence instead of a Tweener.
/// Also stores the Rigidbody as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param>
/// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
/// <param name="numJumps">Total number of jumps</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Sequence DOJump(this Rigidbody target, Vector3 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
{
if (numJumps < 1) numJumps = 1;
float startPosY = 0;
float offsetY = -1;
bool offsetYSet = false;
Sequence s = DOTween.Sequence();
Tween yTween = DOTween.To(() => target.position, target.MovePosition, new Vector3(0, jumpPower, 0), duration / (numJumps * 2))
.SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
.SetLoops(numJumps * 2, LoopType.Yoyo)
.OnStart(() => startPosY = target.position.y);
s.Append(DOTween.To(() => target.position, target.MovePosition, new Vector3(endValue.x, 0, 0), duration)
.SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
).Join(DOTween.To(() => target.position, target.MovePosition, new Vector3(0, 0, endValue.z), duration)
.SetOptions(AxisConstraint.Z, snapping).SetEase(Ease.Linear)
).Join(yTween)
.SetTarget(target).SetEase(DOTween.defaultEaseType);
yTween.OnUpdate(() => {
if (!offsetYSet) {
offsetYSet = true;
offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
}
Vector3 pos = target.position;
pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
target.MovePosition(pos);
});
return s;
}
/// <summary>Tweens a Rigidbody's position through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody as the tween's target so it can be used for filtered operations.
/// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOPath.</para></summary>
/// <param name="path">The waypoints to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore<Vector3, Path, PathOptions> DOPath(
this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
)
{
if (resolution < 1) resolution = 1;
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, new Path(pathType, path, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
return t;
}
/// <summary>Tweens a Rigidbody's localPosition through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody as the tween's target so it can be used for filtered operations
/// <para>NOTE: to tween a rigidbody correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
/// <param name="path">The waypoint to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
this Rigidbody target, Vector3[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
)
{
if (resolution < 1) resolution = 1;
Transform trans = target.transform;
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
t.plugOptions.useLocalPosition = true;
return t;
}
// Used by path editor when creating the actual tween, so it can pass a pre-compiled path
internal static TweenerCore<Vector3, Path, PathOptions> DOPath(
this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
)
{
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, target.MovePosition, path, duration)
.SetTarget(target);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
return t;
}
internal static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
this Rigidbody target, Path path, float duration, PathMode pathMode = PathMode.Full3D
)
{
Transform trans = target.transform;
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), path, duration)
.SetTarget(target);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
t.plugOptions.useLocalPosition = true;
return t;
}
#endregion
#endregion
#endregion
}
}
#endif
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: dae9aa560b4242648a3affa2bfabc365
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
using System;
using DG.Tweening.Core;
using DG.Tweening.Plugins;
using DG.Tweening.Plugins.Core.PathCore;
using DG.Tweening.Plugins.Options;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenModulePhysics2D
{
#region Shortcuts
#region Rigidbody2D Shortcuts
/// <summary>Tweens a Rigidbody2D's position to the given value.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOMove(this Rigidbody2D target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody2D's X position to the given value.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveX(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(endValue, 0), duration);
t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody2D's Y position to the given value.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOMoveY(this Rigidbody2D target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.position, target.MovePosition, new Vector2(0, endValue), duration);
t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a Rigidbody2D's rotation to the given value.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DORotate(this Rigidbody2D target, float endValue, float duration)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.rotation, target.MoveRotation, endValue, duration);
t.SetTarget(target);
return t;
}
#region Special
/// <summary>Tweens a Rigidbody2D's position to the given value, while also applying a jump effect along the Y axis.
/// Returns a Sequence instead of a Tweener.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
/// <para>IMPORTANT: a rigidbody2D can't be animated in a jump arc using MovePosition, so the tween will directly set the position</para></summary>
/// <param name="endValue">The end value to reach</param>
/// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
/// <param name="numJumps">Total number of jumps</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Sequence DOJump(this Rigidbody2D target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
{
if (numJumps < 1) numJumps = 1;
float startPosY = 0;
float offsetY = -1;
bool offsetYSet = false;
Sequence s = DOTween.Sequence();
Tween yTween = DOTween.To(() => target.position, x => target.position = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
.SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
.SetLoops(numJumps * 2, LoopType.Yoyo)
.OnStart(() => startPosY = target.position.y);
s.Append(DOTween.To(() => target.position, x => target.position = x, new Vector2(endValue.x, 0), duration)
.SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
).Join(yTween)
.SetTarget(target).SetEase(DOTween.defaultEaseType);
yTween.OnUpdate(() => {
if (!offsetYSet) {
offsetYSet = true;
offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
}
Vector3 pos = target.position;
pos.y += DOVirtual.EasedValue(0, offsetY, yTween.ElapsedPercentage(), Ease.OutQuad);
target.MovePosition(pos);
});
return s;
}
/// <summary>Tweens a Rigidbody2D's position through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations.
/// <para>NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOPath.</para></summary>
/// <param name="path">The waypoints to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path (useless in case of Linear paths): higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore<Vector3, Path, PathOptions> DOPath(
this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
)
{
if (resolution < 1) resolution = 1;
int len = path.Length;
Vector3[] path3D = new Vector3[len];
for (int i = 0; i < len; ++i) path3D[i] = path[i];
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => target.position, x => target.MovePosition(x), new Path(pathType, path3D, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
return t;
}
/// <summary>Tweens a Rigidbody2D's localPosition through the given path waypoints, using the chosen path algorithm.
/// Also stores the Rigidbody2D as the tween's target so it can be used for filtered operations
/// <para>NOTE: to tween a Rigidbody2D correctly it should be set to kinematic at least while being tweened.</para>
/// <para>BEWARE: doesn't work on Windows Phone store (waiting for Unity to fix their own bug).
/// If you plan to publish there you should use a regular transform.DOLocalPath.</para></summary>
/// <param name="path">The waypoint to go through</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="pathType">The type of path: Linear (straight path), CatmullRom (curved CatmullRom path) or CubicBezier (curved with control points)</param>
/// <param name="pathMode">The path mode: 3D, side-scroller 2D, top-down 2D</param>
/// <param name="resolution">The resolution of the path: higher resolutions make for more detailed curved paths but are more expensive.
/// Defaults to 10, but a value of 5 is usually enough if you don't have dramatic long curves between waypoints</param>
/// <param name="gizmoColor">The color of the path (shown when gizmos are active in the Play panel and the tween is running)</param>
public static TweenerCore<Vector3, Path, PathOptions> DOLocalPath(
this Rigidbody2D target, Vector2[] path, float duration, PathType pathType = PathType.Linear,
PathMode pathMode = PathMode.Full3D, int resolution = 10, Color? gizmoColor = null
)
{
if (resolution < 1) resolution = 1;
int len = path.Length;
Vector3[] path3D = new Vector3[len];
for (int i = 0; i < len; ++i) path3D[i] = path[i];
Transform trans = target.transform;
TweenerCore<Vector3, Path, PathOptions> t = DOTween.To(PathPlugin.Get(), () => trans.localPosition, x => target.MovePosition(trans.parent == null ? x : trans.parent.TransformPoint(x)), new Path(pathType, path3D, resolution, gizmoColor), duration)
.SetTarget(target).SetUpdate(UpdateType.Fixed);
t.plugOptions.isRigidbody = true;
t.plugOptions.mode = pathMode;
t.plugOptions.useLocalPosition = true;
return t;
}
#endregion
#endregion
#endregion
}
}
#endif
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModulePhysics2D.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 230fe34542e175245ba74b4659dae700
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
#if true && (UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
using System;
using UnityEngine;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenModuleSprite
{
#region Shortcuts
#region SpriteRenderer
/// <summary>Tweens a SpriteRenderer's color to the given value.
/// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this SpriteRenderer target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Material's alpha color to the given value.
/// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this SpriteRenderer target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a SpriteRenderer's color using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this SpriteRenderer target, Gradient gradient, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.color = c.color;
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
#endregion
#region Blendables
#region SpriteRenderer
/// <summary>Tweens a SpriteRenderer's color to the given value,
/// in a way that allows other DOBlendableColor tweens to work together on the same target,
/// instead than fight each other as multiple DOColor would do.
/// Also stores the SpriteRenderer as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
public static Tweener DOBlendableColor(this SpriteRenderer target, Color endValue, float duration)
{
endValue = endValue - target.color;
Color to = new Color(0, 0, 0, 0);
return DOTween.To(() => to, x => {
Color diff = x - to;
to = x;
target.color += diff;
}, endValue, duration)
.Blendable().SetTarget(target);
}
#endregion
#endregion
#endregion
}
}
#endif
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleSprite.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 188918ab119d93148aa0de59ccf5286b
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
#if true && (UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER) // MODULE_MARKER
using System;
using System.Globalization;
using UnityEngine;
using UnityEngine.UI;
using DG.Tweening.Core;
using DG.Tweening.Core.Enums;
using DG.Tweening.Plugins.Options;
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenModuleUI
{
#region Shortcuts
#region CanvasGroup
/// <summary>Tweens a CanvasGroup's alpha color to the given value.
/// Also stores the canvasGroup as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOFade(this CanvasGroup target, float endValue, float duration)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.alpha, x => target.alpha = x, endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#region Graphic
/// <summary>Tweens an Graphic's color to the given value.
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this Graphic target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens an Graphic's alpha color to the given value.
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this Graphic target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#region Image
/// <summary>Tweens an Image's color to the given value.
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this Image target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens an Image's alpha color to the given value.
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this Image target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens an Image's fillAmount to the given value.
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach (0 to 1)</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOFillAmount(this Image target, float endValue, float duration)
{
if (endValue > 1) endValue = 1;
else if (endValue < 0) endValue = 0;
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fillAmount, x => target.fillAmount = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens an Image's colors using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this Image target, Gradient gradient, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.color = c.color;
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
#endregion
#region LayoutElement
/// <summary>Tweens an LayoutElement's flexibleWidth/Height to the given value.
/// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOFlexibleSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.flexibleWidth, target.flexibleHeight), x => {
target.flexibleWidth = x.x;
target.flexibleHeight = x.y;
}, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens an LayoutElement's minWidth/Height to the given value.
/// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOMinSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.minWidth, target.minHeight), x => {
target.minWidth = x.x;
target.minHeight = x.y;
}, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens an LayoutElement's preferredWidth/Height to the given value.
/// Also stores the LayoutElement as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOPreferredSize(this LayoutElement target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => new Vector2(target.preferredWidth, target.preferredHeight), x => {
target.preferredWidth = x.x;
target.preferredHeight = x.y;
}, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
#endregion
#region Outline
/// <summary>Tweens a Outline's effectColor to the given value.
/// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this Outline target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.effectColor, x => target.effectColor = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Outline's effectColor alpha to the given value.
/// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this Outline target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.effectColor, x => target.effectColor = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Outline's effectDistance to the given value.
/// Also stores the Outline as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOScale(this Outline target, Vector2 endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.effectDistance, x => target.effectDistance = x, endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#region RectTransform
/// <summary>Tweens a RectTransform's anchoredPosition to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPos(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition X to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosX(this RectTransform target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue, 0), duration);
t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition Y to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorPosY(this RectTransform target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, endValue), duration);
t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition3D to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3D(this RectTransform target, Vector3 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition3D X to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DX(this RectTransform target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(endValue, 0, 0), duration);
t.SetOptions(AxisConstraint.X, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition3D Y to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DY(this RectTransform target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, endValue, 0), duration);
t.SetOptions(AxisConstraint.Y, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchoredPosition3D Z to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOAnchorPos3DZ(this RectTransform target, float endValue, float duration, bool snapping = false)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.anchoredPosition3D, x => target.anchoredPosition3D = x, new Vector3(0, 0, endValue), duration);
t.SetOptions(AxisConstraint.Z, snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchorMax to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMax(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMax, x => target.anchorMax = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's anchorMin to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOAnchorMin(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.anchorMin, x => target.anchorMin = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's pivot to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivot(this RectTransform target, Vector2 endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's pivot X to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotX(this RectTransform target, float endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(endValue, 0), duration);
t.SetOptions(AxisConstraint.X).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's pivot Y to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOPivotY(this RectTransform target, float endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.pivot, x => target.pivot = x, new Vector2(0, endValue), duration);
t.SetOptions(AxisConstraint.Y).SetTarget(target);
return t;
}
/// <summary>Tweens a RectTransform's sizeDelta to the given value.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOSizeDelta(this RectTransform target, Vector2 endValue, float duration, bool snapping = false)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.sizeDelta, x => target.sizeDelta = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
/// <summary>Punches a RectTransform's anchoredPosition towards the given direction and then back to the starting one
/// as if it was connected to the starting position via an elastic.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="punch">The direction and strength of the punch (added to the RectTransform's current position)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="vibrato">Indicates how much will the punch vibrate</param>
/// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting position when bouncing backwards.
/// 1 creates a full oscillation between the punch direction and the opposite direction,
/// while 0 oscillates only between the punch and the start position</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOPunchAnchorPos(this RectTransform target, Vector2 punch, float duration, int vibrato = 10, float elasticity = 1, bool snapping = false)
{
return DOTween.Punch(() => target.anchoredPosition, x => target.anchoredPosition = x, punch, duration, vibrato, elasticity)
.SetTarget(target).SetOptions(snapping);
}
/// <summary>Shakes a RectTransform's anchoredPosition with the given values.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, float strength = 100, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
{
return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, true, fadeOut)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
}
/// <summary>Shakes a RectTransform's anchoredPosition with the given values.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength on each axis</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public static Tweener DOShakeAnchorPos(this RectTransform target, float duration, Vector2 strength, int vibrato = 10, float randomness = 90, bool snapping = false, bool fadeOut = true)
{
return DOTween.Shake(() => target.anchoredPosition, x => target.anchoredPosition = x, duration, strength, vibrato, randomness, fadeOut)
.SetTarget(target).SetSpecialStartupMode(SpecialStartupMode.SetShake).SetOptions(snapping);
}
#region Special
/// <summary>Tweens a RectTransform's anchoredPosition to the given value, while also applying a jump effect along the Y axis.
/// Returns a Sequence instead of a Tweener.
/// Also stores the RectTransform as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param>
/// <param name="jumpPower">Power of the jump (the max height of the jump is represented by this plus the final Y offset)</param>
/// <param name="numJumps">Total number of jumps</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Sequence DOJumpAnchorPos(this RectTransform target, Vector2 endValue, float jumpPower, int numJumps, float duration, bool snapping = false)
{
if (numJumps < 1) numJumps = 1;
float startPosY = 0;
float offsetY = -1;
bool offsetYSet = false;
// Separate Y Tween so we can elaborate elapsedPercentage on that insted of on the Sequence
// (in case users add a delay or other elements to the Sequence)
Sequence s = DOTween.Sequence();
Tween yTween = DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(0, jumpPower), duration / (numJumps * 2))
.SetOptions(AxisConstraint.Y, snapping).SetEase(Ease.OutQuad).SetRelative()
.SetLoops(numJumps * 2, LoopType.Yoyo)
.OnStart(()=> startPosY = target.anchoredPosition.y);
s.Append(DOTween.To(() => target.anchoredPosition, x => target.anchoredPosition = x, new Vector2(endValue.x, 0), duration)
.SetOptions(AxisConstraint.X, snapping).SetEase(Ease.Linear)
).Join(yTween)
.SetTarget(target).SetEase(DOTween.defaultEaseType);
s.OnUpdate(() => {
if (!offsetYSet) {
offsetYSet = true;
offsetY = s.isRelative ? endValue.y : endValue.y - startPosY;
}
Vector2 pos = target.anchoredPosition;
pos.y += DOVirtual.EasedValue(0, offsetY, s.ElapsedDirectionalPercentage(), Ease.OutQuad);
target.anchoredPosition = pos;
});
return s;
}
#endregion
#endregion
#region ScrollRect
/// <summary>Tweens a ScrollRect's horizontal/verticalNormalizedPosition to the given value.
/// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DONormalizedPos(this ScrollRect target, Vector2 endValue, float duration, bool snapping = false)
{
return DOTween.To(() => new Vector2(target.horizontalNormalizedPosition, target.verticalNormalizedPosition),
x => {
target.horizontalNormalizedPosition = x.x;
target.verticalNormalizedPosition = x.y;
}, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
/// <summary>Tweens a ScrollRect's horizontalNormalizedPosition to the given value.
/// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOHorizontalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
{
return DOTween.To(() => target.horizontalNormalizedPosition, x => target.horizontalNormalizedPosition = x, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
/// <summary>Tweens a ScrollRect's verticalNormalizedPosition to the given value.
/// Also stores the ScrollRect as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOVerticalNormalizedPos(this ScrollRect target, float endValue, float duration, bool snapping = false)
{
return DOTween.To(() => target.verticalNormalizedPosition, x => target.verticalNormalizedPosition = x, endValue, duration)
.SetOptions(snapping).SetTarget(target);
}
#endregion
#region Slider
/// <summary>Tweens a Slider's value to the given value.
/// Also stores the Slider as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static TweenerCore<float, float, FloatOptions> DOValue(this Slider target, float endValue, float duration, bool snapping = false)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.value, x => target.value = x, endValue, duration);
t.SetOptions(snapping).SetTarget(target);
return t;
}
#endregion
#region Text
/// <summary>Tweens a Text's color to the given value.
/// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this Text target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>
/// Tweens a Text's text from one integer to another, with options for thousands separators
/// </summary>
/// <param name="fromValue">The value to start from</param>
/// <param name="endValue">The end value to reach</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="addThousandsSeparator">If TRUE (default) also adds thousands separators</param>
/// <param name="culture">The <see cref="CultureInfo"/> to use (InvariantCulture if NULL)</param>
public static TweenerCore<int, int, NoOptions> DOCounter(
this Text target, int fromValue, int endValue, float duration, bool addThousandsSeparator = true, CultureInfo culture = null
){
int v = fromValue;
CultureInfo cInfo = !addThousandsSeparator ? null : culture ?? CultureInfo.InvariantCulture;
TweenerCore<int, int, NoOptions> t = DOTween.To(() => v, x => {
v = x;
target.text = addThousandsSeparator
? v.ToString("N0", cInfo)
: v.ToString();
}, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Text's alpha color to the given value.
/// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this Text target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Text's text to the given value.
/// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
/// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
/// otherwise all tags will be considered as normal text</param>
/// <param name="scrambleMode">The type of scramble mode to use, if any</param>
/// <param name="scrambleChars">A string containing the characters to use for scrambling.
/// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
/// Leave it to NULL (default) to use default ones</param>
public static TweenerCore<string, string, StringOptions> DOText(this Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
{
if (endValue == null) {
if (Debugger.logPriority > 0) Debugger.LogWarning("You can't pass a NULL string to DOText: an empty string will be used instead to avoid errors");
endValue = "";
}
TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
.SetTarget(target);
return t;
}
#endregion
#region Blendables
#region Graphic
/// <summary>Tweens a Graphic's color to the given value,
/// in a way that allows other DOBlendableColor tweens to work together on the same target,
/// instead than fight each other as multiple DOColor would do.
/// Also stores the Graphic as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
public static Tweener DOBlendableColor(this Graphic target, Color endValue, float duration)
{
endValue = endValue - target.color;
Color to = new Color(0, 0, 0, 0);
return DOTween.To(() => to, x => {
Color diff = x - to;
to = x;
target.color += diff;
}, endValue, duration)
.Blendable().SetTarget(target);
}
#endregion
#region Image
/// <summary>Tweens a Image's color to the given value,
/// in a way that allows other DOBlendableColor tweens to work together on the same target,
/// instead than fight each other as multiple DOColor would do.
/// Also stores the Image as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
public static Tweener DOBlendableColor(this Image target, Color endValue, float duration)
{
endValue = endValue - target.color;
Color to = new Color(0, 0, 0, 0);
return DOTween.To(() => to, x => {
Color diff = x - to;
to = x;
target.color += diff;
}, endValue, duration)
.Blendable().SetTarget(target);
}
#endregion
#region Text
/// <summary>Tweens a Text's color BY the given value,
/// in a way that allows other DOBlendableColor tweens to work together on the same target,
/// instead than fight each other as multiple DOColor would do.
/// Also stores the Text as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The value to tween to</param><param name="duration">The duration of the tween</param>
public static Tweener DOBlendableColor(this Text target, Color endValue, float duration)
{
endValue = endValue - target.color;
Color to = new Color(0, 0, 0, 0);
return DOTween.To(() => to, x => {
Color diff = x - to;
to = x;
target.color += diff;
}, endValue, duration)
.Blendable().SetTarget(target);
}
#endregion
#endregion
#endregion
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
public static class Utils
{
/// <summary>
/// Converts the anchoredPosition of the first RectTransform to the second RectTransform,
/// taking into consideration offset, anchors and pivot, and returns the new anchoredPosition
/// </summary>
public static Vector2 SwitchToRectTransform(RectTransform from, RectTransform to)
{
Vector2 localPoint;
Vector2 fromPivotDerivedOffset = new Vector2(from.rect.width * 0.5f + from.rect.xMin, from.rect.height * 0.5f + from.rect.yMin);
Vector2 screenP = RectTransformUtility.WorldToScreenPoint(null, from.position);
screenP += fromPivotDerivedOffset;
RectTransformUtility.ScreenPointToLocalPointInRectangle(to, screenP, null, out localPoint);
Vector2 pivotDerivedOffset = new Vector2(to.rect.width * 0.5f + to.rect.xMin, to.rect.height * 0.5f + to.rect.yMin);
return to.anchoredPosition + localPoint - pivotDerivedOffset;
}
}
}
}
#endif
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUI.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a060394c03331a64392db53a10e7f2d1
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
using System;
using UnityEngine;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
#if UNITY_2018_1_OR_NEWER && (NET_4_6 || NET_STANDARD_2_0)
using System.Threading.Tasks;
#endif
#pragma warning disable 1591
namespace DG.Tweening
{
/// <summary>
/// Shortcuts/functions that are not strictly related to specific Modules
/// but are available only on some Unity versions
/// </summary>
public static class DOTweenModuleUnityVersion
{
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1_OR_NEWER
#region Unity 4.3 or Newer
#region Material
/// <summary>Tweens a Material's color using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this Material target, Gradient gradient, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.color = c.color;
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
/// <summary>Tweens a Material's named color property using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param>
/// <param name="property">The name of the material property to tween (like _Tint or _SpecColor)</param>
/// <param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this Material target, Gradient gradient, string property, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.SetColor(property, c.color);
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, property, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
#endregion
#endregion
#endif
#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
#region Unity 5.3 or Newer
#region CustomYieldInstructions
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or complete.
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForCompletion(true);</code>
/// </summary>
public static CustomYieldInstruction WaitForCompletion(this Tween t, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForCompletion(t);
}
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or rewinded.
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForRewind();</code>
/// </summary>
public static CustomYieldInstruction WaitForRewind(this Tween t, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForRewind(t);
}
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed.
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForKill();</code>
/// </summary>
public static CustomYieldInstruction WaitForKill(this Tween t, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForKill(t);
}
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or has gone through the given amount of loops.
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForElapsedLoops(2);</code>
/// </summary>
/// <param name="elapsedLoops">Elapsed loops to wait for</param>
public static CustomYieldInstruction WaitForElapsedLoops(this Tween t, int elapsedLoops, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForElapsedLoops(t, elapsedLoops);
}
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed
/// or has reached the given time position (loops included, delays excluded).
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForPosition(2.5f);</code>
/// </summary>
/// <param name="position">Position (loops included, delays excluded) to wait for</param>
public static CustomYieldInstruction WaitForPosition(this Tween t, float position, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForPosition(t, position);
}
/// <summary>
/// Returns a <see cref="CustomYieldInstruction"/> that waits until the tween is killed or started
/// (meaning when the tween is set in a playing state the first time, after any eventual delay).
/// It can be used inside a coroutine as a yield.
/// <para>Example usage:</para><code>yield return myTween.WaitForStart();</code>
/// </summary>
public static CustomYieldInstruction WaitForStart(this Tween t, bool returnCustomYieldInstruction)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return null;
}
return new DOTweenCYInstruction.WaitForStart(t);
}
#endregion
#endregion
#endif
#if UNITY_2018_1_OR_NEWER
#region Unity 2018.1 or Newer
#region Material
/// <summary>Tweens a Material's named texture offset property with the given ID to the given value.
/// Also stores the material as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param>
/// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
/// <param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOOffset(this Material target, Vector2 endValue, int propertyID, float duration)
{
if (!target.HasProperty(propertyID)) {
if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
return null;
}
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureOffset(propertyID), x => target.SetTextureOffset(propertyID, x), endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Material's named texture scale property with the given ID to the given value.
/// Also stores the material as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param>
/// <param name="propertyID">The ID of the material property to tween (also called nameID in Unity's manual)</param>
/// <param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOTiling(this Material target, Vector2 endValue, int propertyID, float duration)
{
if (!target.HasProperty(propertyID)) {
if (Debugger.logPriority > 0) Debugger.LogMissingMaterialProperty(propertyID);
return null;
}
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.GetTextureScale(propertyID), x => target.SetTextureScale(propertyID, x), endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#region .NET 4.6 or Newer
#if (NET_4_6 || NET_STANDARD_2_0)
#region Async Instructions
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed or complete.
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.WaitForCompletion();</code>
/// </summary>
public static async Task AsyncWaitForCompletion(this Tween t)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active && !t.IsComplete()) await Task.Yield();
}
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed or rewinded.
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.AsyncWaitForRewind();</code>
/// </summary>
public static async Task AsyncWaitForRewind(this Tween t)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0)) await Task.Yield();
}
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed.
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.AsyncWaitForKill();</code>
/// </summary>
public static async Task AsyncWaitForKill(this Tween t)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active) await Task.Yield();
}
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed or has gone through the given amount of loops.
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.AsyncWaitForElapsedLoops();</code>
/// </summary>
/// <param name="elapsedLoops">Elapsed loops to wait for</param>
public static async Task AsyncWaitForElapsedLoops(this Tween t, int elapsedLoops)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active && t.CompletedLoops() < elapsedLoops) await Task.Yield();
}
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed or started
/// (meaning when the tween is set in a playing state the first time, after any eventual delay).
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.AsyncWaitForPosition();</code>
/// </summary>
/// <param name="position">Position (loops included, delays excluded) to wait for</param>
public static async Task AsyncWaitForPosition(this Tween t, float position)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active && t.position * (t.CompletedLoops() + 1) < position) await Task.Yield();
}
/// <summary>
/// Returns an async <see cref="Task"/> that waits until the tween is killed.
/// It can be used inside an async operation.
/// <para>Example usage:</para><code>await myTween.AsyncWaitForKill();</code>
/// </summary>
public static async Task AsyncWaitForStart(this Tween t)
{
if (!t.active) {
if (Debugger.logPriority > 0) Debugger.LogInvalidTween(t);
return;
}
while (t.active && !t.playedOnce) await Task.Yield();
}
#endregion
#endif
#endregion
#endregion
#endif
}
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ CLASSES █████████████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
#if UNITY_5_3_OR_NEWER || UNITY_2017_1_OR_NEWER
public static class DOTweenCYInstruction
{
public class WaitForCompletion : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active && !t.IsComplete();
}}
readonly Tween t;
public WaitForCompletion(Tween tween)
{
t = tween;
}
}
public class WaitForRewind : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active && (!t.playedOnce || t.position * (t.CompletedLoops() + 1) > 0);
}}
readonly Tween t;
public WaitForRewind(Tween tween)
{
t = tween;
}
}
public class WaitForKill : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active;
}}
readonly Tween t;
public WaitForKill(Tween tween)
{
t = tween;
}
}
public class WaitForElapsedLoops : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active && t.CompletedLoops() < elapsedLoops;
}}
readonly Tween t;
readonly int elapsedLoops;
public WaitForElapsedLoops(Tween tween, int elapsedLoops)
{
t = tween;
this.elapsedLoops = elapsedLoops;
}
}
public class WaitForPosition : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active && t.position * (t.CompletedLoops() + 1) < position;
}}
readonly Tween t;
readonly float position;
public WaitForPosition(Tween tween, float position)
{
t = tween;
this.position = position;
}
}
public class WaitForStart : CustomYieldInstruction
{
public override bool keepWaiting { get {
return t.active && !t.playedOnce;
}}
readonly Tween t;
public WaitForStart(Tween tween)
{
t = tween;
}
}
}
#endif
}
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUnityVersion.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 63c02322328255542995bd02b47b0457
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
using System;
using System.Reflection;
using UnityEngine;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Core.PathCore;
using DG.Tweening.Plugins.Options;
#pragma warning disable 1591
namespace DG.Tweening
{
/// <summary>
/// Utility functions that deal with available Modules.
/// Modules defines:
/// - DOTAUDIO
/// - DOTPHYSICS
/// - DOTPHYSICS2D
/// - DOTSPRITE
/// - DOTUI
/// Extra defines set and used for implementation of external assets:
/// - DOTWEEN_TMP ► TextMesh Pro
/// - DOTWEEN_TK2D ► 2D Toolkit
/// </summary>
public static class DOTweenModuleUtils
{
static bool _initialized;
#region Reflection
/// <summary>
/// Called via Reflection by DOTweenComponent on Awake
/// </summary>
#if UNITY_2018_1_OR_NEWER
[UnityEngine.Scripting.Preserve]
#endif
public static void Init()
{
if (_initialized) return;
_initialized = true;
DOTweenExternalCommand.SetOrientationOnPath += Physics.SetOrientationOnPath;
#if UNITY_EDITOR
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
UnityEditor.EditorApplication.playmodeStateChanged += PlaymodeStateChanged;
#else
UnityEditor.EditorApplication.playModeStateChanged += PlaymodeStateChanged;
#endif
#endif
}
#if UNITY_2018_1_OR_NEWER
#pragma warning disable
[UnityEngine.Scripting.Preserve]
// Just used to preserve methods when building, never called
static void Preserver()
{
Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
MethodInfo mi = typeof(MonoBehaviour).GetMethod("Stub");
}
#pragma warning restore
#endif
#endregion
#if UNITY_EDITOR
// Fires OnApplicationPause in DOTweenComponent even when Editor is paused (otherwise it's only fired at runtime)
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5 || UNITY_2017_1
static void PlaymodeStateChanged()
#else
static void PlaymodeStateChanged(UnityEditor.PlayModeStateChange state)
#endif
{
if (DOTween.instance == null) return;
DOTween.instance.OnApplicationPause(UnityEditor.EditorApplication.isPaused);
}
#endif
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
public static class Physics
{
// Called via DOTweenExternalCommand callback
public static void SetOrientationOnPath(PathOptions options, Tween t, Quaternion newRot, Transform trans)
{
#if true // PHYSICS_MARKER
if (options.isRigidbody) ((Rigidbody)t.target).rotation = newRot;
else trans.rotation = newRot;
#else
trans.rotation = newRot;
#endif
}
// Returns FALSE if the DOTween's Physics2D Module is disabled, or if there's no Rigidbody2D attached
public static bool HasRigidbody2D(Component target)
{
#if true // PHYSICS2D_MARKER
return target.GetComponent<Rigidbody2D>() != null;
#else
return false;
#endif
}
#region Called via Reflection
// Called via Reflection by DOTweenPathInspector
// Returns FALSE if the DOTween's Physics Module is disabled, or if there's no rigidbody attached
#if UNITY_2018_1_OR_NEWER
[UnityEngine.Scripting.Preserve]
#endif
public static bool HasRigidbody(Component target)
{
#if true // PHYSICS_MARKER
return target.GetComponent<Rigidbody>() != null;
#else
return false;
#endif
}
// Called via Reflection by DOTweenPath
#if UNITY_2018_1_OR_NEWER
[UnityEngine.Scripting.Preserve]
#endif
public static TweenerCore<Vector3, Path, PathOptions> CreateDOTweenPathTween(
MonoBehaviour target, bool tweenRigidbody, bool isLocal, Path path, float duration, PathMode pathMode
){
TweenerCore<Vector3, Path, PathOptions> t;
#if true // PHYSICS_MARKER
Rigidbody rBody = tweenRigidbody ? target.GetComponent<Rigidbody>() : null;
if (tweenRigidbody && rBody != null) {
t = isLocal
? rBody.DOLocalPath(path, duration, pathMode)
: rBody.DOPath(path, duration, pathMode);
} else {
t = isLocal
? target.transform.DOLocalPath(path, duration, pathMode)
: target.transform.DOPath(path, duration, pathMode);
}
#else
t = isLocal
? target.transform.DOLocalPath(path, duration, pathMode)
: target.transform.DOPath(path, duration, pathMode);
#endif
return t;
}
#endregion
}
}
}
Assets/Plugins/Demigiant/DOTween/Modules/DOTweenModuleUtils.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7bcaf917d9cf5b84090421a5a2abe42e
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTween/readme.txt 0 → 100644
View file @ f21b0cad
DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
// IMPORTANT!!! /////////////////////////////////////////////
// Upgrading DOTween from versions older than 1.2.000 ///////
// (or DOTween Pro older than 1.0.000) //////////////////////
-------------------------------------------------------------
If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (Pro version only)
// GET STARTED //////////////////////////////////////////////
- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
- In your code, add "using DG.Tweening" to each class where you want to use DOTween.
- You're ready to tween. Check out the links below for full documentation and license info.
// LINKS ///////////////////////////////////////////////////////
DOTween website (documentation, examples, etc): http://dotween.demigiant.com
DOTween license: http://dotween.demigiant.com/license.php
DOTween repository (Google Code): https://code.google.com/p/dotween/
Demigiant website (documentation, examples, etc): http://www.demigiant.com
// NOTES //////////////////////////////////////////////////////
- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences
\ No newline at end of file
Assets/Plugins/Demigiant/DOTween/readme.txt.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: fccfc62abf2eb0a4db614853430894fd
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: af55cfd0e7084ab4884c5a4f29b62d9f
labels:
- iTween
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenAnimation.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/12 15:55
using System;
using System.Collections.Generic;
using DG.Tweening.Core;
using UnityEngine;
#if true // UI_MARKER
using UnityEngine.UI;
#endif
#if false // TEXTMESHPRO_MARKER
using TMPro;
#endif
#pragma warning disable 1591
namespace DG.Tweening
{
/// <summary>
/// Attach this to a GameObject to create a tween
/// </summary>
[AddComponentMenu("DOTween/DOTween Animation")]
public class DOTweenAnimation : ABSAnimationComponent
{
public enum AnimationType
{
None,
Move, LocalMove,
Rotate, LocalRotate,
Scale,
Color, Fade,
Text,
PunchPosition, PunchRotation, PunchScale,
ShakePosition, ShakeRotation, ShakeScale,
CameraAspect, CameraBackgroundColor, CameraFieldOfView, CameraOrthoSize, CameraPixelRect, CameraRect,
UIWidthHeight
}
public enum TargetType
{
Unset,
Camera,
CanvasGroup,
Image,
Light,
RectTransform,
Renderer, SpriteRenderer,
Rigidbody, Rigidbody2D,
Text,
Transform,
tk2dBaseSprite,
tk2dTextMesh,
TextMeshPro,
TextMeshProUGUI
}
#region EVENTS - EDITOR-ONLY
/// <summary>Used internally by the editor</summary>
public static event Action<DOTweenAnimation> OnReset;
static void Dispatch_OnReset(DOTweenAnimation anim) { if (OnReset != null) OnReset(anim); }
#endregion
public bool targetIsSelf = true; // If FALSE allows to set the target manually
public GameObject targetGO = null; // Used in case targetIsSelf is FALSE
// If TRUE always uses the GO containing this DOTweenAnimation (and not the one containing the target) as DOTween's SetTarget target
public bool tweenTargetIsTargetGO = true;
public float delay;
public float duration = 1;
public Ease easeType = Ease.OutQuad;
public AnimationCurve easeCurve = new AnimationCurve(new Keyframe(0, 0), new Keyframe(1, 1));
public LoopType loopType = LoopType.Restart;
public int loops = 1;
public string id = "";
public bool isRelative;
public bool isFrom;
public bool isIndependentUpdate = false;
public bool autoKill = true;
public bool isActive = true;
public bool isValid;
public Component target;
public AnimationType animationType;
public TargetType targetType;
public TargetType forcedTargetType; // Used when choosing between multiple targets
public bool autoPlay = true;
public bool useTargetAsV3;
public float endValueFloat;
public Vector3 endValueV3;
public Vector2 endValueV2;
public Color endValueColor = new Color(1, 1, 1, 1);
public string endValueString = "";
public Rect endValueRect = new Rect(0, 0, 0, 0);
public Transform endValueTransform;
public bool optionalBool0;
public float optionalFloat0;
public int optionalInt0;
public RotateMode optionalRotationMode = RotateMode.Fast;
public ScrambleMode optionalScrambleMode = ScrambleMode.None;
public string optionalString;
bool _tweenCreated; // TRUE after the tweens have been created
int _playCount = -1; // Used when calling DOPlayNext
#region Unity Methods
void Awake()
{
if (!isActive || !isValid) return;
if (animationType != AnimationType.Move || !useTargetAsV3) {
// Don't create tweens if we're using a RectTransform as a Move target,
// because that will work only inside Start
CreateTween();
_tweenCreated = true;
}
}
void Start()
{
if (_tweenCreated || !isActive || !isValid) return;
CreateTween();
_tweenCreated = true;
}
void Reset()
{
Dispatch_OnReset(this);
}
void OnDestroy()
{
if (tween != null && tween.IsActive()) tween.Kill();
tween = null;
}
// Used also by DOTweenAnimationInspector when applying runtime changes and restarting
public void CreateTween()
{
// if (target == null) {
// Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target is NULL, because the animation was created with a DOTween Pro version older than 0.9.255. To fix this, exit Play mode then simply select this object, and it will update automatically", this.gameObject.name), this.gameObject);
// return;
// }
GameObject tweenGO = GetTweenGO();
if (target == null || tweenGO == null) {
if (targetIsSelf && target == null) {
// Old error caused during upgrade from DOTween Pro 0.9.255
Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target is NULL, because the animation was created with a DOTween Pro version older than 0.9.255. To fix this, exit Play mode then simply select this object, and it will update automatically", this.gameObject.name), this.gameObject);
} else {
// Missing non-self target
Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target/GameObject is unset: the tween will not be created.", this.gameObject.name), this.gameObject);
}
return;
}
if (forcedTargetType != TargetType.Unset) targetType = forcedTargetType;
if (targetType == TargetType.Unset) {
// Legacy DOTweenAnimation (made with a version older than 0.9.450) without stored targetType > assign it now
targetType = TypeToDOTargetType(target.GetType());
}
switch (animationType) {
case AnimationType.None:
break;
case AnimationType.Move:
if (useTargetAsV3) {
isRelative = false;
if (endValueTransform == null) {
Debug.LogWarning(string.Format("{0} :: This tween's TO target is NULL, a Vector3 of (0,0,0) will be used instead", this.gameObject.name), this.gameObject);
endValueV3 = Vector3.zero;
} else {
#if true // UI_MARKER
if (targetType == TargetType.RectTransform) {
RectTransform endValueT = endValueTransform as RectTransform;
if (endValueT == null) {
Debug.LogWarning(string.Format("{0} :: This tween's TO target should be a RectTransform, a Vector3 of (0,0,0) will be used instead", this.gameObject.name), this.gameObject);
endValueV3 = Vector3.zero;
} else {
RectTransform rTarget = target as RectTransform;
if (rTarget == null) {
Debug.LogWarning(string.Format("{0} :: This tween's target and TO target are not of the same type. Please reassign the values", this.gameObject.name), this.gameObject);
} else {
// Problem: doesn't work inside Awake (ararargh!)
endValueV3 = DOTweenModuleUI.Utils.SwitchToRectTransform(endValueT, rTarget);
}
}
} else
#endif
endValueV3 = endValueTransform.position;
}
}
switch (targetType) {
case TargetType.Transform:
tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
break;
case TargetType.RectTransform:
#if true // UI_MARKER
tween = ((RectTransform)target).DOAnchorPos3D(endValueV3, duration, optionalBool0);
#else
tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
#endif
break;
case TargetType.Rigidbody:
#if true // PHYSICS_MARKER
tween = ((Rigidbody)target).DOMove(endValueV3, duration, optionalBool0);
#else
tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
#endif
break;
case TargetType.Rigidbody2D:
#if true // PHYSICS2D_MARKER
tween = ((Rigidbody2D)target).DOMove(endValueV3, duration, optionalBool0);
#else
tween = ((Transform)target).DOMove(endValueV3, duration, optionalBool0);
#endif
break;
}
break;
case AnimationType.LocalMove:
tween = tweenGO.transform.DOLocalMove(endValueV3, duration, optionalBool0);
break;
case AnimationType.Rotate:
switch (targetType) {
case TargetType.Transform:
tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
break;
case TargetType.Rigidbody:
#if true // PHYSICS_MARKER
tween = ((Rigidbody)target).DORotate(endValueV3, duration, optionalRotationMode);
#else
tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
#endif
break;
case TargetType.Rigidbody2D:
#if true // PHYSICS2D_MARKER
tween = ((Rigidbody2D)target).DORotate(endValueFloat, duration);
#else
tween = ((Transform)target).DORotate(endValueV3, duration, optionalRotationMode);
#endif
break;
}
break;
case AnimationType.LocalRotate:
tween = tweenGO.transform.DOLocalRotate(endValueV3, duration, optionalRotationMode);
break;
case AnimationType.Scale:
switch (targetType) {
#if false // TK2D_MARKER
case TargetType.tk2dTextMesh:
tween = ((tk2dTextMesh)target).DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
break;
case TargetType.tk2dBaseSprite:
tween = ((tk2dBaseSprite)target).DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
break;
#endif
default:
tween = tweenGO.transform.DOScale(optionalBool0 ? new Vector3(endValueFloat, endValueFloat, endValueFloat) : endValueV3, duration);
break;
}
break;
#if true // UI_MARKER
case AnimationType.UIWidthHeight:
tween = ((RectTransform)target).DOSizeDelta(optionalBool0 ? new Vector2(endValueFloat, endValueFloat) : endValueV2, duration);
break;
#endif
case AnimationType.Color:
isRelative = false;
switch (targetType) {
case TargetType.Renderer:
tween = ((Renderer)target).material.DOColor(endValueColor, duration);
break;
case TargetType.Light:
tween = ((Light)target).DOColor(endValueColor, duration);
break;
#if true // SPRITE_MARKER
case TargetType.SpriteRenderer:
tween = ((SpriteRenderer)target).DOColor(endValueColor, duration);
break;
#endif
#if true // UI_MARKER
case TargetType.Image:
tween = ((Graphic)target).DOColor(endValueColor, duration);
break;
case TargetType.Text:
tween = ((Text)target).DOColor(endValueColor, duration);
break;
#endif
#if false // TK2D_MARKER
case TargetType.tk2dTextMesh:
tween = ((tk2dTextMesh)target).DOColor(endValueColor, duration);
break;
case TargetType.tk2dBaseSprite:
tween = ((tk2dBaseSprite)target).DOColor(endValueColor, duration);
break;
#endif
#if false // TEXTMESHPRO_MARKER
case TargetType.TextMeshProUGUI:
tween = ((TextMeshProUGUI)target).DOColor(endValueColor, duration);
break;
case TargetType.TextMeshPro:
tween = ((TextMeshPro)target).DOColor(endValueColor, duration);
break;
#endif
}
break;
case AnimationType.Fade:
isRelative = false;
switch (targetType) {
case TargetType.Renderer:
tween = ((Renderer)target).material.DOFade(endValueFloat, duration);
break;
case TargetType.Light:
tween = ((Light)target).DOIntensity(endValueFloat, duration);
break;
#if true // SPRITE_MARKER
case TargetType.SpriteRenderer:
tween = ((SpriteRenderer)target).DOFade(endValueFloat, duration);
break;
#endif
#if true // UI_MARKER
case TargetType.Image:
tween = ((Graphic)target).DOFade(endValueFloat, duration);
break;
case TargetType.Text:
tween = ((Text)target).DOFade(endValueFloat, duration);
break;
case TargetType.CanvasGroup:
tween = ((CanvasGroup)target).DOFade(endValueFloat, duration);
break;
#endif
#if false // TK2D_MARKER
case TargetType.tk2dTextMesh:
tween = ((tk2dTextMesh)target).DOFade(endValueFloat, duration);
break;
case TargetType.tk2dBaseSprite:
tween = ((tk2dBaseSprite)target).DOFade(endValueFloat, duration);
break;
#endif
#if false // TEXTMESHPRO_MARKER
case TargetType.TextMeshProUGUI:
tween = ((TextMeshProUGUI)target).DOFade(endValueFloat, duration);
break;
case TargetType.TextMeshPro:
tween = ((TextMeshPro)target).DOFade(endValueFloat, duration);
break;
#endif
}
break;
case AnimationType.Text:
#if true // UI_MARKER
switch (targetType) {
case TargetType.Text:
tween = ((Text)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
break;
}
#endif
#if false // TK2D_MARKER
switch (targetType) {
case TargetType.tk2dTextMesh:
tween = ((tk2dTextMesh)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
break;
}
#endif
#if false // TEXTMESHPRO_MARKER
switch (targetType) {
case TargetType.TextMeshProUGUI:
tween = ((TextMeshProUGUI)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
break;
case TargetType.TextMeshPro:
tween = ((TextMeshPro)target).DOText(endValueString, duration, optionalBool0, optionalScrambleMode, optionalString);
break;
}
#endif
break;
case AnimationType.PunchPosition:
switch (targetType) {
case TargetType.Transform:
tween = ((Transform)target).DOPunchPosition(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0);
break;
#if true // UI_MARKER
case TargetType.RectTransform:
tween = ((RectTransform)target).DOPunchAnchorPos(endValueV3, duration, optionalInt0, optionalFloat0, optionalBool0);
break;
#endif
}
break;
case AnimationType.PunchScale:
tween = tweenGO.transform.DOPunchScale(endValueV3, duration, optionalInt0, optionalFloat0);
break;
case AnimationType.PunchRotation:
tween = tweenGO.transform.DOPunchRotation(endValueV3, duration, optionalInt0, optionalFloat0);
break;
case AnimationType.ShakePosition:
switch (targetType) {
case TargetType.Transform:
tween = ((Transform)target).DOShakePosition(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0);
break;
#if true // UI_MARKER
case TargetType.RectTransform:
tween = ((RectTransform)target).DOShakeAnchorPos(duration, endValueV3, optionalInt0, optionalFloat0, optionalBool0);
break;
#endif
}
break;
case AnimationType.ShakeScale:
tween = tweenGO.transform.DOShakeScale(duration, endValueV3, optionalInt0, optionalFloat0);
break;
case AnimationType.ShakeRotation:
tween = tweenGO.transform.DOShakeRotation(duration, endValueV3, optionalInt0, optionalFloat0);
break;
case AnimationType.CameraAspect:
tween = ((Camera)target).DOAspect(endValueFloat, duration);
break;
case AnimationType.CameraBackgroundColor:
tween = ((Camera)target).DOColor(endValueColor, duration);
break;
case AnimationType.CameraFieldOfView:
tween = ((Camera)target).DOFieldOfView(endValueFloat, duration);
break;
case AnimationType.CameraOrthoSize:
tween = ((Camera)target).DOOrthoSize(endValueFloat, duration);
break;
case AnimationType.CameraPixelRect:
tween = ((Camera)target).DOPixelRect(endValueRect, duration);
break;
case AnimationType.CameraRect:
tween = ((Camera)target).DORect(endValueRect, duration);
break;
}
if (tween == null) return;
if (isFrom) {
((Tweener)tween).From(isRelative);
} else {
tween.SetRelative(isRelative);
}
GameObject setTarget = targetIsSelf || !tweenTargetIsTargetGO ? this.gameObject : targetGO;
tween.SetTarget(setTarget).SetDelay(delay).SetLoops(loops, loopType).SetAutoKill(autoKill)
.OnKill(()=> tween = null);
if (isSpeedBased) tween.SetSpeedBased();
if (easeType == Ease.INTERNAL_Custom) tween.SetEase(easeCurve);
else tween.SetEase(easeType);
if (!string.IsNullOrEmpty(id)) tween.SetId(id);
tween.SetUpdate(isIndependentUpdate);
if (hasOnStart) {
if (onStart != null) tween.OnStart(onStart.Invoke);
} else onStart = null;
if (hasOnPlay) {
if (onPlay != null) tween.OnPlay(onPlay.Invoke);
} else onPlay = null;
if (hasOnUpdate) {
if (onUpdate != null) tween.OnUpdate(onUpdate.Invoke);
} else onUpdate = null;
if (hasOnStepComplete) {
if (onStepComplete != null) tween.OnStepComplete(onStepComplete.Invoke);
} else onStepComplete = null;
if (hasOnComplete) {
if (onComplete != null) tween.OnComplete(onComplete.Invoke);
} else onComplete = null;
if (hasOnRewind) {
if (onRewind != null) tween.OnRewind(onRewind.Invoke);
} else onRewind = null;
if (autoPlay) tween.Play();
else tween.Pause();
if (hasOnTweenCreated && onTweenCreated != null) onTweenCreated.Invoke();
}
#endregion
#region Public Methods
// These methods are here so they can be called directly via Unity's UGUI event system
public override void DOPlay()
{
DOTween.Play(this.gameObject);
}
public override void DOPlayBackwards()
{
DOTween.PlayBackwards(this.gameObject);
}
public override void DOPlayForward()
{
DOTween.PlayForward(this.gameObject);
}
public override void DOPause()
{
DOTween.Pause(this.gameObject);
}
public override void DOTogglePause()
{
DOTween.TogglePause(this.gameObject);
}
public override void DORewind()
{
_playCount = -1;
// Rewind using Components order (in case there are multiple animations on the same property)
DOTweenAnimation[] anims = this.gameObject.GetComponents<DOTweenAnimation>();
for (int i = anims.Length - 1; i > -1; --i) {
Tween t = anims[i].tween;
if (t != null && t.IsInitialized()) anims[i].tween.Rewind();
}
// DOTween.Rewind(this.gameObject);
}
/// <summary>
/// Restarts the tween
/// </summary>
public override void DORestart()
{ DORestart(false); }
/// <summary>
/// Restarts the tween
/// </summary>
/// <param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
/// Set it to TRUE when spawning the same DOTweenAnimation in different positions (like when using a pooling system)</param>
public override void DORestart(bool fromHere)
{
_playCount = -1;
if (tween == null) {
if (Debugger.logPriority > 1) Debugger.LogNullTween(tween); return;
}
if (fromHere && isRelative) ReEvaluateRelativeTween();
DOTween.Restart(this.gameObject);
}
public override void DOComplete()
{
DOTween.Complete(this.gameObject);
}
public override void DOKill()
{
DOTween.Kill(this.gameObject);
tween = null;
}
#region Specifics
public void DOPlayById(string id)
{
DOTween.Play(this.gameObject, id);
}
public void DOPlayAllById(string id)
{
DOTween.Play(id);
}
public void DOPauseAllById(string id)
{
DOTween.Pause(id);
}
public void DOPlayBackwardsById(string id)
{
DOTween.PlayBackwards(this.gameObject, id);
}
public void DOPlayBackwardsAllById(string id)
{
DOTween.PlayBackwards(id);
}
public void DOPlayForwardById(string id)
{
DOTween.PlayForward(this.gameObject, id);
}
public void DOPlayForwardAllById(string id)
{
DOTween.PlayForward(id);
}
public void DOPlayNext()
{
DOTweenAnimation[] anims = this.GetComponents<DOTweenAnimation>();
while (_playCount < anims.Length - 1) {
_playCount++;
DOTweenAnimation anim = anims[_playCount];
if (anim != null && anim.tween != null && !anim.tween.IsPlaying() && !anim.tween.IsComplete()) {
anim.tween.Play();
break;
}
}
}
public void DORewindAndPlayNext()
{
_playCount = -1;
DOTween.Rewind(this.gameObject);
DOPlayNext();
}
public void DORewindAllById(string id)
{
_playCount = -1;
DOTween.Rewind(id);
}
public void DORestartById(string id)
{
_playCount = -1;
DOTween.Restart(this.gameObject, id);
}
public void DORestartAllById(string id)
{
_playCount = -1;
DOTween.Restart(id);
}
/// <summary>
/// Returns the tweens created by this DOTweenAnimation, in the same order as they appear in the Inspector (top to bottom)
/// </summary>
public List<Tween> GetTweens()
{
// return DOTween.TweensByTarget(this.gameObject);
List<Tween> result = new List<Tween>();
DOTweenAnimation[] anims = this.GetComponents<DOTweenAnimation>();
foreach (DOTweenAnimation anim in anims) result.Add(anim.tween);
return result;
}
#endregion
#region Internal (also used by Inspector)
public static TargetType TypeToDOTargetType(Type t)
{
string str = t.ToString();
int dotIndex = str.LastIndexOf(".");
if (dotIndex != -1) str = str.Substring(dotIndex + 1);
if (str.IndexOf("Renderer") != -1 && (str != "SpriteRenderer")) str = "Renderer";
//#if true // PHYSICS_MARKER
// if (str == "Rigidbody") str = "Transform";
//#endif
//#if true // PHYSICS2D_MARKER
// if (str == "Rigidbody2D") str = "Transform";
//#endif
#if true // UI_MARKER
// if (str == "RectTransform") str = "Transform";
if (str == "RawImage" || str == "Graphic") str = "Image"; // RawImages/Graphics are managed like Images for DOTweenAnimation (color and fade use Graphic target anyway)
#endif
return (TargetType)Enum.Parse(typeof(TargetType), str);
}
// Editor preview system
/// <summary>
/// Previews the tween in the editor. Only for DOTween internal usage: don't use otherwise.
/// </summary>
public Tween CreateEditorPreview()
{
if (Application.isPlaying) return null;
CreateTween();
return tween;
}
#endregion
#endregion
#region Private
// Returns the gameObject whose target component should be animated
GameObject GetTweenGO()
{
return targetIsSelf ? this.gameObject : targetGO;
}
// Re-evaluate relative position of path
void ReEvaluateRelativeTween()
{
GameObject tweenGO = GetTweenGO();
if (tweenGO == null) {
Debug.LogWarning(string.Format("{0} :: This DOTweenAnimation's target/GameObject is unset: the tween will not be created.", this.gameObject.name), this.gameObject);
return;
}
if (animationType == AnimationType.Move) {
((Tweener)tween).ChangeEndValue(tweenGO.transform.position + endValueV3, true);
} else if (animationType == AnimationType.LocalMove) {
((Tweener)tween).ChangeEndValue(tweenGO.transform.localPosition + endValueV3, true);
}
}
#endregion
}
public static class DOTweenAnimationExtensions
{
// // Doesn't work on Win 8.1
// public static bool IsSameOrSubclassOf(this Type t, Type tBase)
// {
// return t.IsSubclassOf(tBase) || t == tBase;
// }
public static bool IsSameOrSubclassOf<T>(this Component t)
{
return t is T;
}
}
}
Assets/Plugins/Demigiant/DOTweenPro/DOTweenAnimation.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4d0390bd8b8ffd640b34fe25065ff1df
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenDeAudio.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/27 19:02
//
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if false // MODULE_MARKER
#endif
Assets/Plugins/Demigiant/DOTweenPro/DOTweenDeAudio.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 1d1aa01bacf85c04ea18116651a7f0db
timeCreated: 1587116610
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenDeUnityExtended.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/27 19:02
//
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if false // MODULE_MARKER
#endif
Assets/Plugins/Demigiant/DOTweenPro/DOTweenDeUnityExtended.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 0a0cc3e90c4a6ea41bb14d7f35c577c3
timeCreated: 1587116610
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenPro.XML 0 → 100644
View file @ f21b0cad
<?xml version="1.0"?>
<doc>
<assembly>
<name>DOTweenPro</name>
</assembly>
<members>
<member name="M:DG.Tweening.Core.ABSAnimationComponent.DORestart">
<summary>
Restarts the tween
</summary>
</member>
<member name="M:DG.Tweening.Core.ABSAnimationComponent.DORestart(System.Boolean)">
<summary>
Restarts the tween
</summary>
<param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param>
</member>
<member name="T:DG.Tweening.DOTweenPath">
<summary>
Attach this to a GameObject to create and assign a path to it
</summary>
</member>
<member name="E:DG.Tweening.DOTweenPath.OnReset">
<summary>Used internally by the editor</summary>
</member>
<member name="M:DG.Tweening.DOTweenPath.DORestart">
<summary>
Restarts the tween
</summary>
</member>
<member name="M:DG.Tweening.DOTweenPath.DORestart(System.Boolean)">
<summary>
Restarts the tween
</summary>
<param name="fromHere">If TRUE, re-evaluates the tween's start and end values from its current position.
Set it to TRUE when spawning the same DOTweenPath in different positions (like when using a pooling system)</param>
</member>
<member name="M:DG.Tweening.DOTweenPath.GetDrawPoints">
<summary>
Returns a list of points that are used to draw the path inside the editor.
</summary>
</member>
<member name="T:DG.Tweening.Plugins.SpiralPlugin">
<summary>
Tweens a Vector3 along a spiral.
EndValue represents the direction of the spiral
</summary>
</member>
<member name="T:DG.Tweening.SpiralMode">
<summary>
Spiral tween mode
</summary>
</member>
<member name="F:DG.Tweening.SpiralMode.Expand">
<summary>The spiral motion will expand outwards for the whole the tween</summary>
</member>
<member name="F:DG.Tweening.SpiralMode.ExpandThenContract">
<summary>The spiral motion will expand outwards for half the tween and then will spiral back to the starting position</summary>
</member>
</members>
</doc>
Assets/Plugins/Demigiant/DOTweenPro/DOTweenPro.XML.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: db7d7ef84c388bc4fbc3835d31a15306
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenPro.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d719ed2e2c87eae4e8dd520e2df659c1
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenPro.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: aa0b1eebb5db27a419fa4564bbe5c9c5
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 1
settings: {}
Editor:
enabled: 0
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenProShortcuts.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2018/07/13
using System;
using DG.Tweening.Core;
using DG.Tweening.Plugins;
using UnityEngine;
#pragma warning disable 1591
namespace DG.Tweening
{
public static class DOTweenProShortcuts
{
static DOTweenProShortcuts()
{
// Create stub instances of custom plugins, in order to allow IL2CPP to understand they must be included in the build
#pragma warning disable 219
SpiralPlugin stub = new SpiralPlugin();
#pragma warning restore 219
}
#region Shortcuts
#region Transform
/// <summary>Tweens a Transform's localPosition in a spiral shape.
/// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
/// <param name="duration">The duration of the tween</param>
/// <param name="axis">The axis around which the spiral will rotate</param>
/// <param name="mode">The type of spiral movement</param>
/// <param name="speed">Speed of the rotations</param>
/// <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param>
/// <param name="depth">Indicates how much the tween should move along the spiral's axis</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOSpiral(
this Transform target, float duration, Vector3? axis = null, SpiralMode mode = SpiralMode.Expand,
float speed = 1, float frequency = 10, float depth = 0, bool snapping = false
) {
if (Mathf.Approximately(speed, 0)) speed = 1;
if (axis == null || axis == Vector3.zero) axis = Vector3.forward;
TweenerCore<Vector3, Vector3, SpiralOptions> t = DOTween.To(SpiralPlugin.Get(), () => target.localPosition, x => target.localPosition = x, (Vector3)axis, duration)
.SetTarget(target);
t.plugOptions.mode = mode;
t.plugOptions.speed = speed;
t.plugOptions.frequency = frequency;
t.plugOptions.depth = depth;
t.plugOptions.snapping = snapping;
return t;
}
#endregion
#if true // PHYSICS_MARKER
#region Rigidbody
/// <summary>Tweens a Rigidbody's position in a spiral shape.
/// Also stores the transform as the tween's target so it can be used for filtered operations</summary>
/// <param name="duration">The duration of the tween</param>
/// <param name="axis">The axis around which the spiral will rotate</param>
/// <param name="mode">The type of spiral movement</param>
/// <param name="speed">Speed of the rotations</param>
/// <param name="frequency">Frequency of the rotation. Lower values lead to wider spirals</param>
/// <param name="depth">Indicates how much the tween should move along the spiral's axis</param>
/// <param name="snapping">If TRUE the tween will smoothly snap all values to integers</param>
public static Tweener DOSpiral(
this Rigidbody target, float duration, Vector3? axis = null, SpiralMode mode = SpiralMode.Expand,
float speed = 1, float frequency = 10, float depth = 0, bool snapping = false
) {
if (Mathf.Approximately(speed, 0)) speed = 1;
if (axis == null || axis == Vector3.zero) axis = Vector3.forward;
TweenerCore<Vector3, Vector3, SpiralOptions> t = DOTween.To(SpiralPlugin.Get(), () => target.position, target.MovePosition, (Vector3)axis, duration)
.SetTarget(target);
t.plugOptions.mode = mode;
t.plugOptions.speed = speed;
t.plugOptions.frequency = frequency;
t.plugOptions.depth = depth;
t.plugOptions.snapping = snapping;
return t;
}
#endregion
#endif
#endregion
}
}
Assets/Plugins/Demigiant/DOTweenPro/DOTweenProShortcuts.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 1c3190a1a1c53f449926f6d5542b4ce5
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/27 19:02
//
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if false // MODULE_MARKER
using System;
using System.Globalization;
using System.Collections.Generic;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
using TMPro;
using Object = UnityEngine.Object;
namespace DG.Tweening
{
public enum TMPSkewSpanMode
{
/// <summary>Applies the skew as-is (like normal skew works): the longer the text-span the higher the last character will be</summary>
Default,
/// <summary>Applies the skew scaled by the size of the text-span: the max skew/displacement will be the given skew factor</summary>
AsMaxSkewFactor
}
/// <summary>
/// Methods that extend TMP_Text objects and allow to directly create and control tweens from their instances.
/// </summary>
public static class ShortcutExtensionsTMPText
{
#region Colors
/// <summary>Tweens a TextMeshPro's color to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this TMP_Text target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's faceColor to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFaceColor(this TMP_Text target, Color32 endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.faceColor, x => target.faceColor = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's outlineColor to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOOutlineColor(this TMP_Text target, Color32 endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.outlineColor, x => target.outlineColor = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's glow color to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="useSharedMaterial">If TRUE will use the fontSharedMaterial instead than the fontMaterial</param>
public static TweenerCore<Color, Color, ColorOptions> DOGlowColor(this TMP_Text target, Color endValue, float duration, bool useSharedMaterial = false)
{
TweenerCore<Color, Color, ColorOptions> t = useSharedMaterial
? target.fontSharedMaterial.DOColor(endValue, "_GlowColor", duration)
: target.fontMaterial.DOColor(endValue, "_GlowColor", duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's alpha color to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this TMP_Text target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro faceColor's alpha to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFaceFade(this TMP_Text target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.faceColor, x => target.faceColor = x, endValue, duration);
t.SetTarget(target);
return t;
}
#endregion
#region Other
/// <summary>Tweens a TextMeshPro's scale to the given value (using correct uniform scale as TMP requires).
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this TMP_Text target, float endValue, float duration)
{
Transform trans = target.transform;
Vector3 endValueV3 = new Vector3(endValue, endValue, endValue);
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => trans.localScale, x => trans.localScale = x, endValueV3, duration);
t.SetTarget(target);
return t;
}
/// <summary>
/// Tweens a TextMeshPro's text from one integer to another, with options for thousands separators
/// </summary>
/// <param name="fromValue">The value to start from</param>
/// <param name="endValue">The end value to reach</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="addThousandsSeparator">If TRUE (default) also adds thousands separators</param>
/// <param name="culture">The <see cref="CultureInfo"/> to use (InvariantCulture if NULL)</param>
public static TweenerCore<int, int, NoOptions> DOCounter(
this TMP_Text target, int fromValue, int endValue, float duration, bool addThousandsSeparator = true, CultureInfo culture = null
){
int v = fromValue;
CultureInfo cInfo = !addThousandsSeparator ? null : culture ?? CultureInfo.InvariantCulture;
TweenerCore<int, int, NoOptions> t = DOTween.To(() => v, x => {
v = x;
target.text = addThousandsSeparator
? v.ToString("N0", cInfo)
: v.ToString();
}, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's fontSize to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<float, float, FloatOptions> DOFontSize(this TMP_Text target, float endValue, float duration)
{
TweenerCore<float, float, FloatOptions> t = DOTween.To(() => target.fontSize, x => target.fontSize = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's maxVisibleCharacters to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<int, int, NoOptions> DOMaxVisibleCharacters(this TMP_Text target, int endValue, float duration)
{
TweenerCore<int, int, NoOptions> t = DOTween.To(() => target.maxVisibleCharacters, x => target.maxVisibleCharacters = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a TextMeshPro's text to the given value.
/// Also stores the TextMeshPro as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
/// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
/// otherwise all tags will be considered as normal text</param>
/// <param name="scrambleMode">The type of scramble mode to use, if any</param>
/// <param name="scrambleChars">A string containing the characters to use for scrambling.
/// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
/// Leave it to NULL (default) to use default ones</param>
public static TweenerCore<string, string, StringOptions> DOText(this TMP_Text target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
{
TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
.SetTarget(target);
return t;
}
#endregion
}
#region DOTweenTMPAnimator
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ CLASS ███████████████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
/// <summary>
/// Wrapper for <see cref="TMP_Text"/> objects that enables per-character tweening
/// (you don't need this if instead you want to animate the whole text object).
/// It also contains various handy methods to simply deform text without animating it ;)
/// <para><code>EXAMPLE:<para/>
/// DOTweenTMPAnimator animator = new DOTweenTMPAnimator(myTextMeshProTextField);<para/>
/// Tween tween = animator.DOCharScale(characterIndex, scaleValue, duration);
/// </code></para>
/// </summary>
public class DOTweenTMPAnimator : IDisposable
{
/// <summary><see cref="TMP_Text"/> that this animator is linked to</summary>
public TMP_Text target { get; private set; }
public TMP_TextInfo textInfo { get; private set; }
readonly List<CharTransform> _charTransforms = new List<CharTransform>();
TMP_MeshInfo[] _cachedMeshInfos;
bool _ignoreTextChangedEvent;
/// <summary>
/// Creates a new instance of the <see cref="DOTweenTMPAnimator"/>, which is necessary to animate <see cref="TMP_Text"/> by single characters.
/// If you want to animate the whole text object you don't need this, and you can use direct <see cref="TMP_Text"/> DO shortcuts instead.<para/>
/// IMPORTANT: the <see cref="TMP_Text"/> target must have been enabled/activated at least once before you can use it with this
/// </summary>
/// <param name="target">The <see cref="TMP_Text"/> that will be linked to this animator</param>
public DOTweenTMPAnimator(TMP_Text target)
{
if (!target.gameObject.activeInHierarchy) {
Debugger.LogError("You can't create a DOTweenTMPAnimator if its target is disabled");
return;
}
this.target = target;
Refresh();
// Listeners
TMPro_EventManager.TEXT_CHANGED_EVENT.Add(OnTextChanged);
}
/// <summary>
/// Clears and disposes of this object
/// </summary>
public void Dispose()
{
target = null;
_charTransforms.Clear();
textInfo = null;
_cachedMeshInfos = null;
TMPro_EventManager.TEXT_CHANGED_EVENT.Remove(OnTextChanged);
}
/// <summary>
/// Refreshes the animator text data and resets all transformation data. Call this after you change the target <see cref="TMP_Text"/>
/// </summary>
public void Refresh()
{
_ignoreTextChangedEvent = true;
target.ForceMeshUpdate(true);
textInfo = target.textInfo;
_cachedMeshInfos = textInfo.CopyMeshInfoVertexData();
int totChars = textInfo.characterCount;
int totCurrent = _charTransforms.Count;
if (totCurrent > totChars) {
_charTransforms.RemoveRange(totChars, totCurrent - totChars);
totCurrent = totChars;
}
for (int i = 0; i < totCurrent; ++i) {
CharTransform c = _charTransforms[i];
c.ResetTransformationData();
c.Refresh(textInfo, _cachedMeshInfos);
_charTransforms[i] = c;
}
for (int i = totCurrent; i < totChars; ++i) _charTransforms.Add(new CharTransform(i, textInfo, _cachedMeshInfos));
_ignoreTextChangedEvent = false;
}
/// <summary>
/// Resets all deformations
/// </summary>
public void Reset()
{
int totCurrent = _charTransforms.Count;
for (int i = 0; i < totCurrent; ++i) _charTransforms[i].ResetAll(target, textInfo.meshInfo, _cachedMeshInfos);
}
void OnTextChanged(Object obj)
{
if (_ignoreTextChangedEvent || target == null || obj != target) return;
Refresh();
}
bool ValidateChar(int charIndex, bool isTween = true)
{
if (textInfo.characterCount <= charIndex) {
Debugger.LogError(string.Format("CharIndex {0} doesn't exist", charIndex));
return false;
}
if (!textInfo.characterInfo[charIndex].isVisible) {
if (Debugger.logPriority > 1) {
if (isTween) {
Debugger.Log(string.Format(
"CharIndex {0} isn't visible, ignoring it and returning an empty tween (TextMesh Pro will behave weirdly if invisible chars are included in the animation)",
charIndex
));
} else {
Debugger.Log(string.Format("CharIndex {0} isn't visible, ignoring it", charIndex));
}
}
return false;
}
return true;
}
bool ValidateSpan(int fromCharIndex, int toCharIndex, out int firstVisibleCharIndex, out int lastVisibleCharIndex)
{
firstVisibleCharIndex = -1; // First visible/existing charIndex from given index
lastVisibleCharIndex = -1; // Last visible/existing charIndex backwards from given index
int charCount = textInfo.characterCount;
if (fromCharIndex >= charCount) return false;
if (toCharIndex >= charCount) toCharIndex = charCount - 1;
for (int i = fromCharIndex; i < toCharIndex + 1; ++i) {
if (!_charTransforms[i].isVisible) continue;
firstVisibleCharIndex = i;
break;
}
if (firstVisibleCharIndex == -1) return false;
for (int i = toCharIndex; i > firstVisibleCharIndex - 1; --i) {
if (!_charTransforms[i].isVisible) continue;
lastVisibleCharIndex = i;
break;
}
if (lastVisibleCharIndex == -1) return false;
return true;
}
#region Word Setters
/// <summary>
/// Skews a span of characters uniformly (like normal skew works in graphic applications)
/// </summary>
/// <param name="fromCharIndex">First char index of the span to skew</param>
/// <param name="toCharIndex">Last char index of the span to skew</param>
/// <param name="skewFactor">Skew factor</param>
/// <param name="skewTop">If TRUE skews the top side of the span, otherwise the bottom one</param>
public void SkewSpanX(int fromCharIndex, int toCharIndex, float skewFactor, bool skewTop = true)
{
int firstVisibleCharIndex, lastVisibleCharIndex;
if (!ValidateSpan(fromCharIndex, toCharIndex, out firstVisibleCharIndex, out lastVisibleCharIndex)) return;
for (int i = firstVisibleCharIndex; i < lastVisibleCharIndex + 1; ++i) {
if (!_charTransforms[i].isVisible) continue;
CharVertices v = _charTransforms[i].GetVertices();
float skew = SkewCharX(i, skewFactor, skewTop);
}
}
/// <summary>
/// Skews a span of characters uniformly (like normal skew works in graphic applications)
/// </summary>
/// <param name="fromCharIndex">First char index of the span to skew</param>
/// <param name="toCharIndex">Last char index of the span to skew</param>
/// <param name="skewFactor">Skew factor</param>
/// <param name="mode">Skew mode</param>
/// <param name="skewRight">If TRUE skews the right side of the span, otherwise the left one</param>
public void SkewSpanY(
int fromCharIndex, int toCharIndex, float skewFactor,
TMPSkewSpanMode mode = TMPSkewSpanMode.Default, bool skewRight = true
){
int firstVisibleCharIndex, lastVisibleCharIndex;
if (!ValidateSpan(fromCharIndex, toCharIndex, out firstVisibleCharIndex, out lastVisibleCharIndex)) return;
if (mode == TMPSkewSpanMode.AsMaxSkewFactor) {
CharVertices firstVisibleCharVertices = _charTransforms[firstVisibleCharIndex].GetVertices();
CharVertices lastVisibleCharVertices = _charTransforms[lastVisibleCharIndex].GetVertices();
float spanW = Mathf.Abs(lastVisibleCharVertices.bottomRight.x - firstVisibleCharVertices.bottomLeft.x);
float spanH = Mathf.Abs(lastVisibleCharVertices.topRight.y - lastVisibleCharVertices.bottomRight.y);
float ratio = spanH / spanW;
skewFactor *= ratio;
}
float offsetY = 0;
CharVertices prevCharVertices = new CharVertices();
float prevCharSkew = 0;
if (skewRight) {
for (int i = firstVisibleCharIndex; i < lastVisibleCharIndex + 1; ++i) {
if (!_charTransforms[i].isVisible) continue;
CharVertices v = _charTransforms[i].GetVertices();
float skew = SkewCharY(i, skewFactor, skewRight);
if (i > firstVisibleCharIndex) {
float prevCharW = Mathf.Abs(prevCharVertices.bottomLeft.x - prevCharVertices.bottomRight.x);
float charsDist = Mathf.Abs(v.bottomLeft.x - prevCharVertices.bottomRight.x);
offsetY += prevCharSkew + (prevCharSkew * charsDist) / prevCharW;
SetCharOffset(i, new Vector3(0, _charTransforms[i].offset.y + offsetY, 0));
}
prevCharVertices = v;
prevCharSkew = skew;
}
} else {
for (int i = lastVisibleCharIndex; i > firstVisibleCharIndex - 1; --i) {
if (!_charTransforms[i].isVisible) continue;
CharVertices v = _charTransforms[i].GetVertices();
float skew = SkewCharY(i, skewFactor, skewRight);
if (i < lastVisibleCharIndex) {
float prevCharW = Mathf.Abs(prevCharVertices.bottomLeft.x - prevCharVertices.bottomRight.x);
float charsDist = Mathf.Abs(v.bottomRight.x - prevCharVertices.bottomLeft.x);
offsetY += prevCharSkew + (prevCharSkew * charsDist) / prevCharW;
SetCharOffset(i, new Vector3(0, _charTransforms[i].offset.y + offsetY, 0));
}
prevCharVertices = v;
prevCharSkew = skew;
}
}
}
#endregion
#region Char Getters
/// <summary>
/// Returns the current color of the given character, if it exists and is visible.
/// </summary>
/// <param name="charIndex">Character index</param>
public Color GetCharColor(int charIndex)
{
if (!ValidateChar(charIndex)) return Color.white;
return _charTransforms[charIndex].GetColor(textInfo.meshInfo);
}
/// <summary>
/// Returns the current offset of the given character, if it exists and is visible.
/// </summary>
/// <param name="charIndex">Character index</param>
public Vector3 GetCharOffset(int charIndex)
{
if (!ValidateChar(charIndex)) return Vector3.zero;
return _charTransforms[charIndex].offset;
}
/// <summary>
/// Returns the current rotation of the given character, if it exists and is visible.
/// </summary>
/// <param name="charIndex">Character index</param>
public Vector3 GetCharRotation(int charIndex)
{
if (!ValidateChar(charIndex)) return Vector3.zero;
return _charTransforms[charIndex].rotation.eulerAngles;
}
/// <summary>
/// Returns the current scale of the given character, if it exists and is visible.
/// </summary>
/// <param name="charIndex">Character index</param>
public Vector3 GetCharScale(int charIndex)
{
if (!ValidateChar(charIndex)) return Vector3.zero;
return _charTransforms[charIndex].scale;
}
#endregion
#region Char Setters
/// <summary>
/// Immediately sets the color of the given character.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="color">Color to set</param>
public void SetCharColor(int charIndex, Color32 color)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.UpdateColor(target, color, textInfo.meshInfo);
_charTransforms[charIndex] = c;
}
/// <summary>
/// Immediately sets the offset of the given character.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="offset">Offset to set</param>
public void SetCharOffset(int charIndex, Vector3 offset)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.UpdateGeometry(target, offset, c.rotation, c.scale, _cachedMeshInfos);
_charTransforms[charIndex] = c;
}
/// <summary>
/// Immediately sets the rotation of the given character.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="rotation">Rotation to set</param>
public void SetCharRotation(int charIndex, Vector3 rotation)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.UpdateGeometry(target, c.offset, Quaternion.Euler(rotation), c.scale, _cachedMeshInfos);
_charTransforms[charIndex] = c;
}
/// <summary>
/// Immediately sets the scale of the given character.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="scale">Scale to set</param>
public void SetCharScale(int charIndex, Vector3 scale)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.UpdateGeometry(target, c.offset, c.rotation, scale, _cachedMeshInfos);
_charTransforms[charIndex] = c;
}
/// <summary>
/// Immediately shifts the vertices of the given character by the given factor.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="topLeftShift">Top left offset</param>
/// <param name="topRightShift">Top right offset</param>
/// <param name="bottomLeftShift">Bottom left offset</param>
/// <param name="bottomRightShift">Bottom right offset</param>
public void ShiftCharVertices(int charIndex, Vector3 topLeftShift, Vector3 topRightShift, Vector3 bottomLeftShift, Vector3 bottomRightShift)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.ShiftVertices(target, topLeftShift, topRightShift, bottomLeftShift, bottomRightShift);
_charTransforms[charIndex] = c;
}
/// <summary>
/// Skews the given character horizontally along the X axis and returns the skew amount applied (based on the character's size)
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="skewFactor">skew amount</param>
/// <param name="skewTop">If TRUE skews the top side of the character, otherwise the bottom one</param>
public float SkewCharX(int charIndex, float skewFactor, bool skewTop = true)
{
if (!ValidateChar(charIndex)) return 0;
Vector3 skewV = new Vector3(skewFactor, 0, 0);
CharTransform c = _charTransforms[charIndex];
if (skewTop) c.ShiftVertices(target, skewV, skewV, Vector3.zero, Vector3.zero);
else c.ShiftVertices(target, Vector3.zero, Vector3.zero, skewV, skewV);
_charTransforms[charIndex] = c;
return skewFactor;
}
/// <summary>
/// Skews the given character vertically along the Y axis and returns the skew amount applied (based on the character's size)
/// </summary>
/// <param name="charIndex">Character index</param>
/// <param name="skewFactor">skew amount</param>
/// <param name="skewRight">If TRUE skews the right side of the character, otherwise the left one</param>
/// <param name="fixedSkew">If TRUE applies exactly the given <see cref="skewFactor"/>,
/// otherwise modifies it based on the aspectRation of the character</param>
public float SkewCharY(int charIndex, float skewFactor, bool skewRight = true, bool fixedSkew = false)
{
if (!ValidateChar(charIndex)) return 0;
float skew = fixedSkew ? skewFactor : skewFactor * textInfo.characterInfo[charIndex].aspectRatio;
Vector3 skewV = new Vector3(0, skew, 0);
CharTransform c = _charTransforms[charIndex];
if (skewRight) c.ShiftVertices(target, Vector3.zero, skewV, Vector3.zero, skewV);
else c.ShiftVertices(target, skewV, Vector3.zero, skewV, Vector3.zero);
_charTransforms[charIndex] = c;
return skew;
}
/// <summary>
/// Resets the eventual vertices shift applied to the given character via <see cref="ShiftCharVertices"/>.
/// Will do nothing if the <see cref="charIndex"/> is invalid or the character isn't visible
/// </summary>
/// <param name="charIndex">Character index</param>
public void ResetVerticesShift(int charIndex)
{
if (!ValidateChar(charIndex)) return;
CharTransform c = _charTransforms[charIndex];
c.ResetVerticesShift(target);
_charTransforms[charIndex] = c;
}
#endregion
#region Char Tweens
/// <summary>Tweens a character's alpha to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public TweenerCore<Color, Color, ColorOptions> DOFadeChar(int charIndex, float endValue, float duration)
{
if (!ValidateChar(charIndex)) return null;
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => _charTransforms[charIndex].GetColor(textInfo.meshInfo), x => {
_charTransforms[charIndex].UpdateAlpha(target, x, textInfo.meshInfo);
}, endValue, duration);
return t;
}
/// <summary>Tweens a character's color to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public TweenerCore<Color, Color, ColorOptions> DOColorChar(int charIndex, Color endValue, float duration)
{
if (!ValidateChar(charIndex)) return null;
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => _charTransforms[charIndex].GetColor(textInfo.meshInfo), x => {
_charTransforms[charIndex].UpdateColor(target, x, textInfo.meshInfo);
}, endValue, duration);
return t;
}
/// <summary>Tweens a character's offset to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public TweenerCore<Vector3, Vector3, VectorOptions> DOOffsetChar(int charIndex, Vector3 endValue, float duration)
{
if (!ValidateChar(charIndex)) return null;
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => _charTransforms[charIndex].offset, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, x, charT.rotation, charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, endValue, duration);
return t;
}
/// <summary>Tweens a character's rotation to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
/// <param name="mode">Rotation mode</param>
public TweenerCore<Quaternion, Vector3, QuaternionOptions> DORotateChar(int charIndex, Vector3 endValue, float duration, RotateMode mode = RotateMode.Fast)
{
if (!ValidateChar(charIndex)) return null;
TweenerCore<Quaternion, Vector3, QuaternionOptions> t = DOTween.To(() => _charTransforms[charIndex].rotation, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, x, charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, endValue, duration);
t.plugOptions.rotateMode = mode;
return t;
}
/// <summary>Tweens a character's scale to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public TweenerCore<Vector3, Vector3, VectorOptions> DOScaleChar(int charIndex, float endValue, float duration)
{
return DOScaleChar(charIndex, new Vector3(endValue, endValue, endValue), duration);
}
/// <summary>Tweens a character's color to the given value and returns the <see cref="Tween"/>.
/// Will return NULL if the <see cref="charIndex"/> is invalid or the character isn't visible.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public TweenerCore<Vector3, Vector3, VectorOptions> DOScaleChar(int charIndex, Vector3 endValue, float duration)
{
if (!ValidateChar(charIndex)) return null;
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => _charTransforms[charIndex].scale, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, charT.rotation, x, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, endValue, duration);
return t;
}
/// <summary>Punches a character's offset towards the given direction and then back to the starting one
/// as if it was connected to the starting position via an elastic.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="punch">The punch strength</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="vibrato">Indicates how much will the punch vibrate per second</param>
/// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards.
/// 1 creates a full oscillation between the punch offset and the opposite offset,
/// while 0 oscillates only between the punch offset and the start offset</param>
public Tweener DOPunchCharOffset(int charIndex, Vector3 punch, float duration, int vibrato = 10, float elasticity = 1)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Punch(() => _charTransforms[charIndex].offset, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, x, charT.rotation, charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, punch, duration, vibrato, elasticity);
}
/// <summary>Punches a character's rotation towards the given direction and then back to the starting one
/// as if it was connected to the starting position via an elastic.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="punch">The punch strength</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="vibrato">Indicates how much will the punch vibrate per second</param>
/// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards.
/// 1 creates a full oscillation between the punch rotation and the opposite rotation,
/// while 0 oscillates only between the punch rotation and the start rotation</param>
public Tweener DOPunchCharRotation(int charIndex, Vector3 punch, float duration, int vibrato = 10, float elasticity = 1)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Punch(() => _charTransforms[charIndex].rotation.eulerAngles, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, Quaternion.Euler(x), charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, punch, duration, vibrato, elasticity);
}
/// <summary>Punches a character's scale towards the given direction and then back to the starting one
/// as if it was connected to the starting position via an elastic.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="punch">The punch strength (added to the character's current scale)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="vibrato">Indicates how much will the punch vibrate per second</param>
/// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards.
/// 1 creates a full oscillation between the punch scale and the opposite scale,
/// while 0 oscillates only between the punch scale and the start scale</param>
public Tweener DOPunchCharScale(int charIndex, float punch, float duration, int vibrato = 10, float elasticity = 1)
{
return DOPunchCharScale(charIndex, new Vector3(punch, punch, punch), duration, vibrato, elasticity);
}
/// <summary>Punches a character's scale towards the given direction and then back to the starting one
/// as if it was connected to the starting position via an elastic.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="punch">The punch strength (added to the character's current scale)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="vibrato">Indicates how much will the punch vibrate per second</param>
/// <param name="elasticity">Represents how much (0 to 1) the vector will go beyond the starting size when bouncing backwards.
/// 1 creates a full oscillation between the punch scale and the opposite scale,
/// while 0 oscillates only between the punch scale and the start scale</param>
public Tweener DOPunchCharScale(int charIndex, Vector3 punch, float duration, int vibrato = 10, float elasticity = 1)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Punch(() => _charTransforms[charIndex].scale, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, charT.rotation, x, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, punch, duration, vibrato, elasticity);
}
/// <summary>Shakes a character's offset with the given values.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public Tweener DOShakeCharOffset(int charIndex, float duration, float strength, int vibrato = 10, float randomness = 90, bool fadeOut = true)
{
return DOShakeCharOffset(charIndex, duration, new Vector3(strength, strength, strength), vibrato, randomness, fadeOut);
}
/// <summary>Shakes a character's offset with the given values.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public Tweener DOShakeCharOffset(int charIndex, float duration, Vector3 strength, int vibrato = 10, float randomness = 90, bool fadeOut = true)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Shake(() => _charTransforms[charIndex].offset, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, x, charT.rotation, charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, duration, strength, vibrato, randomness, fadeOut);
}
/// <summary>Shakes a character's rotation with the given values.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public Tweener DOShakeCharRotation(int charIndex, float duration, Vector3 strength, int vibrato = 10, float randomness = 90, bool fadeOut = true)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Shake(() => _charTransforms[charIndex].rotation.eulerAngles, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, Quaternion.Euler(x), charT.scale, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, duration, strength, vibrato, randomness, fadeOut);
}
/// <summary>Shakes a character's scale with the given values.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public Tweener DOShakeCharScale(int charIndex, float duration, float strength, int vibrato = 10, float randomness = 90, bool fadeOut = true)
{
return DOShakeCharScale(charIndex, duration, new Vector3(strength, strength, strength), vibrato, randomness, fadeOut);
}
/// <summary>Shakes a character's scale with the given values.</summary>
/// <param name="charIndex">The index of the character to tween (will throw an error if it doesn't exist)</param>
/// <param name="duration">The duration of the tween</param>
/// <param name="strength">The shake strength</param>
/// <param name="vibrato">Indicates how much will the shake vibrate</param>
/// <param name="randomness">Indicates how much the shake will be random (0 to 180 - values higher than 90 kind of suck, so beware).
/// Setting it to 0 will shake along a single direction.</param>
/// <param name="fadeOut">If TRUE the shake will automatically fadeOut smoothly within the tween's duration, otherwise it will not</param>
public Tweener DOShakeCharScale(int charIndex, float duration, Vector3 strength, int vibrato = 10, float randomness = 90, bool fadeOut = true)
{
if (!ValidateChar(charIndex)) return null;
if (duration <= 0) {
if (Debugger.logPriority > 0) Debug.LogWarning("Duration can't be 0, returning NULL without creating a tween");
return null;
}
return DOTween.Shake(() => _charTransforms[charIndex].scale, x => {
CharTransform charT = _charTransforms[charIndex];
charT.UpdateGeometry(target, charT.offset, charT.rotation, x, _cachedMeshInfos);
_charTransforms[charIndex] = charT;
}, duration, strength, vibrato, randomness, fadeOut);
}
#endregion
// ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
struct CharVertices
{
public Vector3 bottomLeft, topLeft, topRight, bottomRight;
public CharVertices(Vector3 bottomLeft, Vector3 topLeft, Vector3 topRight, Vector3 bottomRight)
{
this.bottomLeft = bottomLeft;
this.topLeft = topLeft;
this.topRight = topRight;
this.bottomRight = bottomRight;
}
}
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// Vertices of each character are:
// 0 : bottom left, 1 : top left, 2 : top right, 3 : bottom right
struct CharTransform
{
public int charIndex;
public bool isVisible { get; private set; } // FALSE both if it's invisible or if it's a space
public Vector3 offset;
public Quaternion rotation;
public Vector3 scale;
Vector3 _topLeftShift, _topRightShift, _bottomLeftShift, _bottomRightShift;
Vector3 _charMidBaselineOffset;
int _matIndex, _firstVertexIndex;
TMP_MeshInfo _meshInfo;
public CharTransform(int charIndex, TMP_TextInfo textInfo, TMP_MeshInfo[] cachedMeshInfos) : this()
{
this.charIndex = charIndex;
offset = Vector3.zero;
rotation = Quaternion.identity;
scale = Vector3.one;
Refresh(textInfo, cachedMeshInfos);
}
public void Refresh(TMP_TextInfo textInfo, TMP_MeshInfo[] cachedMeshInfos)
{
TMP_CharacterInfo charInfo = textInfo.characterInfo[charIndex];
bool isSpaceChar = charInfo.character == ' ';
isVisible = charInfo.isVisible && !isSpaceChar;
_matIndex = charInfo.materialReferenceIndex;
_firstVertexIndex = charInfo.vertexIndex;
_meshInfo = textInfo.meshInfo[_matIndex];
Vector3[] cachedVertices = cachedMeshInfos[_matIndex].vertices;
_charMidBaselineOffset = isSpaceChar
? Vector3.zero
: (cachedVertices[_firstVertexIndex] + cachedVertices[_firstVertexIndex + 2]) * 0.5f;
}
public void ResetAll(TMP_Text target, TMP_MeshInfo[] meshInfos, TMP_MeshInfo[] cachedMeshInfos)
{
ResetGeometry(target, cachedMeshInfos);
ResetColors(target, meshInfos);
}
public void ResetTransformationData()
{
offset = Vector3.zero;
rotation = Quaternion.identity;
scale = Vector3.one;
_topLeftShift = _topRightShift = _bottomLeftShift = _bottomRightShift = Vector3.zero;
}
public void ResetGeometry(TMP_Text target, TMP_MeshInfo[] cachedMeshInfos)
{
ResetTransformationData();
Vector3[] destinationVertices = _meshInfo.vertices;
Vector3[] cachedVertices = cachedMeshInfos[_matIndex].vertices;
destinationVertices[_firstVertexIndex + 0] = cachedVertices[_firstVertexIndex + 0];
destinationVertices[_firstVertexIndex + 1] = cachedVertices[_firstVertexIndex + 1];
destinationVertices[_firstVertexIndex + 2] = cachedVertices[_firstVertexIndex + 2];
destinationVertices[_firstVertexIndex + 3] = cachedVertices[_firstVertexIndex + 3];
_meshInfo.mesh.vertices = _meshInfo.vertices;
target.UpdateGeometry(_meshInfo.mesh, _matIndex);
}
public void ResetColors(TMP_Text target, TMP_MeshInfo[] meshInfos)
{
Color color = target.color;
Color32[] vertexCols = meshInfos[_matIndex].colors32;
vertexCols[_firstVertexIndex] = color;
vertexCols[_firstVertexIndex + 1] = color;
vertexCols[_firstVertexIndex + 2] = color;
vertexCols[_firstVertexIndex + 3] = color;
target.UpdateVertexData(TMP_VertexDataUpdateFlags.Colors32);
}
public Color32 GetColor(TMP_MeshInfo[] meshInfos)
{
return meshInfos[_matIndex].colors32[_firstVertexIndex];
}
public CharVertices GetVertices()
{
return new CharVertices(
_meshInfo.vertices[_firstVertexIndex], _meshInfo.vertices[_firstVertexIndex + 1],
_meshInfo.vertices[_firstVertexIndex + 2], _meshInfo.vertices[_firstVertexIndex + 3]
);
}
public void UpdateAlpha(TMP_Text target, Color alphaColor, TMP_MeshInfo[] meshInfos, bool apply = true)
{
byte alphaByte = (byte)(alphaColor.a * 255);
Color32[] vertexCols = meshInfos[_matIndex].colors32;
vertexCols[_firstVertexIndex].a = alphaByte;
vertexCols[_firstVertexIndex + 1].a = alphaByte;
vertexCols[_firstVertexIndex + 2].a = alphaByte;
vertexCols[_firstVertexIndex + 3].a = alphaByte;
if (apply) target.UpdateVertexData(TMP_VertexDataUpdateFlags.Colors32);
}
public void UpdateColor(TMP_Text target, Color32 color, TMP_MeshInfo[] meshInfos, bool apply = true)
{
Color32[] vertexCols = meshInfos[_matIndex].colors32;
vertexCols[_firstVertexIndex] = color;
vertexCols[_firstVertexIndex + 1] = color;
vertexCols[_firstVertexIndex + 2] = color;
vertexCols[_firstVertexIndex + 3] = color;
if (apply) target.UpdateVertexData(TMP_VertexDataUpdateFlags.Colors32);
}
public void UpdateGeometry(TMP_Text target, Vector3 offset, Quaternion rotation, Vector3 scale, TMP_MeshInfo[] cachedMeshInfos, bool apply = true)
{
this.offset = offset;
this.rotation = rotation;
this.scale = scale;
if (!apply) return;
Vector3[] destinationVertices = _meshInfo.vertices;
Vector3[] cachedVertices = cachedMeshInfos[_matIndex].vertices;
destinationVertices[_firstVertexIndex] = cachedVertices[_firstVertexIndex + 0] - _charMidBaselineOffset;
destinationVertices[_firstVertexIndex + 1] = cachedVertices[_firstVertexIndex + 1] - _charMidBaselineOffset;
destinationVertices[_firstVertexIndex + 2] = cachedVertices[_firstVertexIndex + 2] - _charMidBaselineOffset;
destinationVertices[_firstVertexIndex + 3] = cachedVertices[_firstVertexIndex + 3] - _charMidBaselineOffset;
Matrix4x4 matrix = Matrix4x4.TRS(this.offset, this.rotation, this.scale);
destinationVertices[_firstVertexIndex]
= matrix.MultiplyPoint3x4(destinationVertices[_firstVertexIndex + 0]) + _charMidBaselineOffset + _bottomLeftShift;
destinationVertices[_firstVertexIndex + 1]
= matrix.MultiplyPoint3x4(destinationVertices[_firstVertexIndex + 1]) + _charMidBaselineOffset + _topLeftShift;
destinationVertices[_firstVertexIndex + 2]
= matrix.MultiplyPoint3x4(destinationVertices[_firstVertexIndex + 2]) + _charMidBaselineOffset + _topRightShift;
destinationVertices[_firstVertexIndex + 3]
= matrix.MultiplyPoint3x4(destinationVertices[_firstVertexIndex + 3]) + _charMidBaselineOffset + _bottomRightShift;
_meshInfo.mesh.vertices = _meshInfo.vertices;
target.UpdateGeometry(_meshInfo.mesh, _matIndex);
}
public void ShiftVertices(TMP_Text target, Vector3 topLeftShift, Vector3 topRightShift, Vector3 bottomLeftShift, Vector3 bottomRightShift)
{
_topLeftShift += topLeftShift;
_topRightShift += topRightShift;
_bottomLeftShift += bottomLeftShift;
_bottomRightShift += bottomRightShift;
Vector3[] destinationVertices = _meshInfo.vertices;
destinationVertices[_firstVertexIndex] = destinationVertices[_firstVertexIndex] + _bottomLeftShift;
destinationVertices[_firstVertexIndex + 1] = destinationVertices[_firstVertexIndex + 1] + _topLeftShift;
destinationVertices[_firstVertexIndex + 2] = destinationVertices[_firstVertexIndex + 2] + _topRightShift;
destinationVertices[_firstVertexIndex + 3] = destinationVertices[_firstVertexIndex + 3] + _bottomRightShift;
_meshInfo.mesh.vertices = _meshInfo.vertices;
target.UpdateGeometry(_meshInfo.mesh, _matIndex);
}
public void ResetVerticesShift(TMP_Text target)
{
Vector3[] destinationVertices = _meshInfo.vertices;
destinationVertices[_firstVertexIndex] = destinationVertices[_firstVertexIndex] - _bottomLeftShift;
destinationVertices[_firstVertexIndex + 1] = destinationVertices[_firstVertexIndex + 1] - _topLeftShift;
destinationVertices[_firstVertexIndex + 2] = destinationVertices[_firstVertexIndex + 2] - _topRightShift;
destinationVertices[_firstVertexIndex + 3] = destinationVertices[_firstVertexIndex + 3] - _bottomRightShift;
_meshInfo.mesh.vertices = _meshInfo.vertices;
target.UpdateGeometry(_meshInfo.mesh, _matIndex);
_topLeftShift = _topRightShift = _bottomLeftShift = _bottomRightShift = Vector3.zero;
}
}
}
#endregion
}
#endif
Assets/Plugins/Demigiant/DOTweenPro/DOTweenTextMeshPro.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8fb0d65aa5b048649a3a785b82b8f8db
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/DOTweenTk2d.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2014/10/27 15:59
//
// License Copyright (c) Daniele Giardini.
// This work is subject to the terms at http://dotween.demigiant.com/license.php
#if false // MODULE_MARKER
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using UnityEngine;
namespace DG.Tweening
{
/// <summary>
/// Methods that extend 2D Toolkit objects and allow to directly create and control tweens from their instances.
/// </summary>
public static class ShortcutExtensionsTk2d
{
#region Sprite
/// <summary>Tweens a 2D Toolkit Sprite's dimensions to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dBaseSprite target, Vector3 endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a Sprite's dimensions to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dBaseSprite target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
t.SetOptions(AxisConstraint.X)
.SetTarget(target);
return t;
}
/// <summary>Tweens a Sprite's dimensions to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dBaseSprite target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
t.SetOptions(AxisConstraint.Y)
.SetTarget(target);
return t;
}
/// <summary>Tweens a Sprite's dimensions to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dBaseSprite target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
t.SetOptions(AxisConstraint.Z)
.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit Sprite's color to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dBaseSprite target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit Sprite's alpha color to the given value.
/// Also stores the Sprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dBaseSprite target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit Sprite's color using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this tk2dBaseSprite target, Gradient gradient, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.color = c.color;
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
#endregion
#region tk2dSlicedSprite
/// <summary>Tweens a 2D Toolkit SlicedSprite's dimensions to the given value.
/// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensions(this tk2dSlicedSprite target, Vector2 endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a SlicedSprite's dimensions to the given value.
/// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsX(this tk2dSlicedSprite target, float endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(endValue, 0), duration);
t.SetOptions(AxisConstraint.X)
.SetTarget(target);
return t;
}
/// <summary>Tweens a SlicedSprite's dimensions to the given value.
/// Also stores the SlicedSprite as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector2, Vector2, VectorOptions> DOScaleDimensionsY(this tk2dSlicedSprite target, float endValue, float duration)
{
TweenerCore<Vector2, Vector2, VectorOptions> t = DOTween.To(() => target.dimensions, x => target.dimensions = x, new Vector2(0, endValue), duration);
t.SetOptions(AxisConstraint.Y)
.SetTarget(target);
return t;
}
#endregion
#region TextMesh
/// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScale(this tk2dTextMesh target, Vector3 endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleX(this tk2dTextMesh target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(endValue, 0, 0), duration);
t.SetOptions(AxisConstraint.X)
.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleY(this tk2dTextMesh target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, endValue, 0), duration);
t.SetOptions(AxisConstraint.Y)
.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's dimensions to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Vector3, Vector3, VectorOptions> DOScaleZ(this tk2dTextMesh target, float endValue, float duration)
{
TweenerCore<Vector3, Vector3, VectorOptions> t = DOTween.To(() => target.scale, x => target.scale = x, new Vector3(0, 0, endValue), duration);
t.SetOptions(AxisConstraint.Z)
.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's color to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOColor(this tk2dTextMesh target, Color endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.To(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's alpha color to the given value.
/// Also stores the TextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static TweenerCore<Color, Color, ColorOptions> DOFade(this tk2dTextMesh target, float endValue, float duration)
{
TweenerCore<Color, Color, ColorOptions> t = DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration);
t.SetTarget(target);
return t;
}
/// <summary>Tweens a 2D Toolkit TextMesh's color using the given gradient
/// (NOTE 1: only uses the colors of the gradient, not the alphas - NOTE 2: creates a Sequence, not a Tweener).
/// Also stores the image as the tween's target so it can be used for filtered operations</summary>
/// <param name="gradient">The gradient to use</param><param name="duration">The duration of the tween</param>
public static Sequence DOGradientColor(this tk2dTextMesh target, Gradient gradient, float duration)
{
Sequence s = DOTween.Sequence();
GradientColorKey[] colors = gradient.colorKeys;
int len = colors.Length;
for (int i = 0; i < len; ++i) {
GradientColorKey c = colors[i];
if (i == 0 && c.time <= 0) {
target.color = c.color;
continue;
}
float colorDuration = i == len - 1
? duration - s.Duration(false) // Verifies that total duration is correct
: duration * (i == 0 ? c.time : c.time - colors[i - 1].time);
s.Append(target.DOColor(c.color, colorDuration).SetEase(Ease.Linear));
}
s.SetTarget(target);
return s;
}
/// <summary>Tweens a tk2dTextMesh's text to the given value.
/// Also stores the tk2dTextMesh as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end string to tween to</param><param name="duration">The duration of the tween</param>
/// <param name="richTextEnabled">If TRUE (default), rich text will be interpreted correctly while animated,
/// otherwise all tags will be considered as normal text</param>
/// <param name="scrambleMode">The type of scramble mode to use, if any</param>
/// <param name="scrambleChars">A string containing the characters to use for scrambling.
/// Use as many characters as possible (minimum 10) because DOTween uses a fast scramble mode which gives better results with more characters.
/// Leave it to NULL (default) to use default ones</param>
public static TweenerCore<string, string, StringOptions> DOText(this tk2dTextMesh target, string endValue, float duration, bool richTextEnabled = true, ScrambleMode scrambleMode = ScrambleMode.None, string scrambleChars = null)
{
TweenerCore<string, string, StringOptions> t = DOTween.To(() => target.text, x => target.text = x, endValue, duration);
t.SetOptions(richTextEnabled, scrambleMode, scrambleChars)
.SetTarget(target);
return t;
}
#endregion
}
}
#endif
Assets/Plugins/Demigiant/DOTweenPro/DOTweenTk2d.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: b590cd7c24ffa5d4faa5b6fa993cccad
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 34ca5bde92f87fa4dbeb9593d201fde2
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/12 16:03
using System;
using System.Collections.Generic;
using System.IO;
using DG.DemiEditor;
using DG.DOTweenEditor.Core;
using DG.DOTweenEditor.UI;
using DG.Tweening;
using DG.Tweening.Core;
using UnityEditor;
using UnityEngine;
using DOTweenSettings = DG.Tweening.Core.DOTweenSettings;
#if true // UI_MARKER
using UnityEngine.UI;
#endif
#if false // TEXTMESHPRO_MARKER
using TMPro;
#endif
namespace DG.DOTweenEditor
{
[CustomEditor(typeof(DOTweenAnimation))]
public class DOTweenAnimationInspector : ABSAnimationInspector
{
enum FadeTargetType
{
CanvasGroup,
Image
}
enum ChooseTargetMode
{
None,
BetweenCanvasGroupAndImage
}
static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _AnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
{ DOTweenAnimation.AnimationType.Move, new[] {
#if true // PHYSICS_MARKER
typeof(Rigidbody),
#endif
#if true // PHYSICS2D_MARKER
typeof(Rigidbody2D),
#endif
#if true // UI_MARKER
typeof(RectTransform),
#endif
typeof(Transform)
}},
{ DOTweenAnimation.AnimationType.Rotate, new[] {
#if true // PHYSICS_MARKER
typeof(Rigidbody),
#endif
#if true // PHYSICS2D_MARKER
typeof(Rigidbody2D),
#endif
typeof(Transform)
}},
{ DOTweenAnimation.AnimationType.LocalMove, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.LocalRotate, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.Scale, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.Color, new[] {
typeof(Light),
#if true // SPRITE_MARKER
typeof(SpriteRenderer),
#endif
#if true // UI_MARKER
typeof(Image), typeof(Text), typeof(RawImage), typeof(Graphic),
#endif
typeof(Renderer),
}},
{ DOTweenAnimation.AnimationType.Fade, new[] {
typeof(Light),
#if true // SPRITE_MARKER
typeof(SpriteRenderer),
#endif
#if true // UI_MARKER
typeof(Image), typeof(Text), typeof(CanvasGroup), typeof(RawImage), typeof(Graphic),
#endif
typeof(Renderer),
}},
#if true // UI_MARKER
{ DOTweenAnimation.AnimationType.Text, new[] { typeof(Text) } },
#endif
{ DOTweenAnimation.AnimationType.PunchPosition, new[] {
#if true // UI_MARKER
typeof(RectTransform),
#endif
typeof(Transform)
}},
{ DOTweenAnimation.AnimationType.PunchRotation, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.PunchScale, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.ShakePosition, new[] {
#if true // UI_MARKER
typeof(RectTransform),
#endif
typeof(Transform)
}},
{ DOTweenAnimation.AnimationType.ShakeRotation, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.ShakeScale, new[] { typeof(Transform) } },
{ DOTweenAnimation.AnimationType.CameraAspect, new[] { typeof(Camera) } },
{ DOTweenAnimation.AnimationType.CameraBackgroundColor, new[] { typeof(Camera) } },
{ DOTweenAnimation.AnimationType.CameraFieldOfView, new[] { typeof(Camera) } },
{ DOTweenAnimation.AnimationType.CameraOrthoSize, new[] { typeof(Camera) } },
{ DOTweenAnimation.AnimationType.CameraPixelRect, new[] { typeof(Camera) } },
{ DOTweenAnimation.AnimationType.CameraRect, new[] { typeof(Camera) } },
#if true // UI_MARKER
{ DOTweenAnimation.AnimationType.UIWidthHeight, new[] { typeof(RectTransform) } },
#endif
};
#if false // TK2D_MARKER
static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _Tk2dAnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
{ DOTweenAnimation.AnimationType.Scale, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
{ DOTweenAnimation.AnimationType.Color, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
{ DOTweenAnimation.AnimationType.Fade, new[] { typeof(tk2dBaseSprite), typeof(tk2dTextMesh) } },
{ DOTweenAnimation.AnimationType.Text, new[] { typeof(tk2dTextMesh) } }
};
#endif
#if false // TEXTMESHPRO_MARKER
static readonly Dictionary<DOTweenAnimation.AnimationType, Type[]> _TMPAnimationTypeToComponent = new Dictionary<DOTweenAnimation.AnimationType, Type[]>() {
{ DOTweenAnimation.AnimationType.Color, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } },
{ DOTweenAnimation.AnimationType.Fade, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } },
{ DOTweenAnimation.AnimationType.Text, new[] { typeof(TextMeshPro), typeof(TextMeshProUGUI) } }
};
#endif
static readonly string[] _AnimationType = new[] {
"None",
"Move", "LocalMove",
"Rotate", "LocalRotate",
"Scale",
"Color", "Fade",
#if true // UI_MARKER
"Text",
#endif
#if false // TK2D_MARKER
"Text",
#endif
#if false // TEXTMESHPRO_MARKER
"Text",
#endif
#if true // UI_MARKER
"UIWidthHeight",
#endif
"Punch/Position", "Punch/Rotation", "Punch/Scale",
"Shake/Position", "Shake/Rotation", "Shake/Scale",
"Camera/Aspect", "Camera/BackgroundColor", "Camera/FieldOfView", "Camera/OrthoSize", "Camera/PixelRect", "Camera/Rect"
};
static string[] _animationTypeNoSlashes; // _AnimationType list without slashes in values
static string[] _datString; // String representation of DOTweenAnimation enum (here for caching reasons)
DOTweenAnimation _src;
DOTweenSettings _settings;
bool _runtimeEditMode; // If TRUE allows to change and save stuff at runtime
bool _refreshRequired; // If TRUE refreshes components data
int _totComponentsOnSrc; // Used to determine if a Component is added or removed from the source
bool _isLightSrc; // Used to determine if we're tweening a Light, to set the max Fade value to more than 1
#pragma warning disable 414
ChooseTargetMode _chooseTargetMode = ChooseTargetMode.None;
#pragma warning restore 414
static readonly GUIContent _GuiC_selfTarget_true = new GUIContent(
"SELF", "Will animate components on this gameObject"
);
static readonly GUIContent _GuiC_selfTarget_false = new GUIContent(
"OTHER", "Will animate components on the given gameObject instead than on this one"
);
static readonly GUIContent _GuiC_tweenTargetIsTargetGO_true = new GUIContent(
"Use As Tween Target", "Will set the tween target (via SetTarget, used to control a tween directly from a target) to the \"OTHER\" gameObject"
);
static readonly GUIContent _GuiC_tweenTargetIsTargetGO_false = new GUIContent(
"Use As Tween Target", "Will set the tween target (via SetTarget, used to control a tween directly from a target) to the gameObject containing this animation, not the \"OTHER\" one"
);
#region MonoBehaviour Methods
void OnEnable()
{
_src = target as DOTweenAnimation;
_settings = DOTweenUtilityWindow.GetDOTweenSettings();
onStartProperty = base.serializedObject.FindProperty("onStart");
onPlayProperty = base.serializedObject.FindProperty("onPlay");
onUpdateProperty = base.serializedObject.FindProperty("onUpdate");
onStepCompleteProperty = base.serializedObject.FindProperty("onStepComplete");
onCompleteProperty = base.serializedObject.FindProperty("onComplete");
onRewindProperty = base.serializedObject.FindProperty("onRewind");
onTweenCreatedProperty = base.serializedObject.FindProperty("onTweenCreated");
// Convert _AnimationType to _animationTypeNoSlashes
int len = _AnimationType.Length;
_animationTypeNoSlashes = new string[len];
for (int i = 0; i < len; ++i) {
string a = _AnimationType[i];
a = a.Replace("/", "");
_animationTypeNoSlashes[i] = a;
}
}
void OnDisable()
{
DOTweenPreviewManager.StopAllPreviews();
}
override public void OnInspectorGUI()
{
base.OnInspectorGUI();
GUILayout.Space(3);
EditorGUIUtils.SetGUIStyles();
bool playMode = Application.isPlaying;
_runtimeEditMode = _runtimeEditMode && playMode;
GUILayout.BeginHorizontal();
EditorGUIUtils.InspectorLogo();
GUILayout.Label(_src.animationType.ToString() + (string.IsNullOrEmpty(_src.id) ? "" : " [" + _src.id + "]"), EditorGUIUtils.sideLogoIconBoldLabelStyle);
// Up-down buttons
GUILayout.FlexibleSpace();
if (GUILayout.Button("▲", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentUp(_src);
if (GUILayout.Button("▼", DeGUI.styles.button.toolIco)) UnityEditorInternal.ComponentUtility.MoveComponentDown(_src);
GUILayout.EndHorizontal();
if (playMode) {
if (_runtimeEditMode) {
} else {
GUILayout.Space(8);
GUILayout.Label("Animation Editor disabled while in play mode", EditorGUIUtils.wordWrapLabelStyle);
if (!_src.isActive) {
GUILayout.Label("This animation has been toggled as inactive and won't be generated", EditorGUIUtils.wordWrapLabelStyle);
GUI.enabled = false;
}
if (GUILayout.Button(new GUIContent("Activate Edit Mode", "Switches to Runtime Edit Mode, where you can change animations values and restart them"))) {
_runtimeEditMode = true;
}
GUILayout.Label("NOTE: when using DOPlayNext, the sequence is determined by the DOTweenAnimation Components order in the target GameObject's Inspector", EditorGUIUtils.wordWrapLabelStyle);
GUILayout.Space(10);
if (!_runtimeEditMode) return;
}
}
Undo.RecordObject(_src, "DOTween Animation");
Undo.RecordObject(_settings, "DOTween Animation");
// _src.isValid = Validate(); // Moved down
EditorGUIUtility.labelWidth = 110;
if (playMode) {
GUILayout.Space(4);
DeGUILayout.Toolbar("Edit Mode Commands");
DeGUILayout.BeginVBox(DeGUI.styles.box.stickyTop);
GUILayout.BeginHorizontal();
if (GUILayout.Button("TogglePause")) _src.tween.TogglePause();
if (GUILayout.Button("Rewind")) _src.tween.Rewind();
if (GUILayout.Button("Restart")) _src.tween.Restart();
GUILayout.EndHorizontal();
if (GUILayout.Button("Commit changes and restart")) {
_src.tween.Rewind();
_src.tween.Kill();
if (_src.isValid) {
_src.CreateTween();
_src.tween.Play();
}
}
GUILayout.Label("To apply your changes when exiting Play mode, use the Component's upper right menu and choose \"Copy Component\", then \"Paste Component Values\" after exiting Play mode", DeGUI.styles.label.wordwrap);
DeGUILayout.EndVBox();
} else {
GUILayout.BeginHorizontal();
bool hasManager = _src.GetComponent<DOTweenVisualManager>() != null;
EditorGUI.BeginChangeCheck();
_settings.showPreviewPanel = hasManager
? DeGUILayout.ToggleButton(_settings.showPreviewPanel, "Preview Controls", styles.custom.inlineToggle)
: DeGUILayout.ToggleButton(_settings.showPreviewPanel, "Preview Controls", styles.custom.inlineToggle, GUILayout.Width(120));
if (EditorGUI.EndChangeCheck()) {
EditorUtility.SetDirty(_settings);
DOTweenPreviewManager.StopAllPreviews();
}
if (!hasManager) {
if (GUILayout.Button(new GUIContent("Add Manager", "Adds a manager component which allows you to choose additional options for this gameObject"))) {
_src.gameObject.AddComponent<DOTweenVisualManager>();
}
}
GUILayout.EndHorizontal();
}
// Preview in editor
bool isPreviewing = _settings.showPreviewPanel ? DOTweenPreviewManager.PreviewGUI(_src) : false;
EditorGUI.BeginDisabledGroup(isPreviewing);
// Choose target
GUILayout.BeginHorizontal();
_src.isActive = EditorGUILayout.Toggle(new GUIContent("", "If unchecked, this animation will not be created"), _src.isActive, GUILayout.Width(14));
EditorGUI.BeginChangeCheck();
EditorGUI.BeginChangeCheck();
_src.targetIsSelf = DeGUILayout.ToggleButton(
_src.targetIsSelf, _src.targetIsSelf ? _GuiC_selfTarget_true : _GuiC_selfTarget_false,
new Color(1f, 0.78f, 0f), DeGUI.colors.bg.toggleOn, new Color(0.33f, 0.14f, 0.02f), DeGUI.colors.content.toggleOn,
null, GUILayout.Width(47)
);
bool innerChanged = EditorGUI.EndChangeCheck();
if (innerChanged) {
_src.targetGO = null;
GUI.changed = true;
}
if (_src.targetIsSelf) GUILayout.Label(_GuiC_selfTarget_true.tooltip);
else {
using (new DeGUI.ColorScope(null, null, _src.targetGO == null ? Color.red : Color.white)) {
_src.targetGO = (GameObject)EditorGUILayout.ObjectField(_src.targetGO, typeof(GameObject), true);
}
_src.tweenTargetIsTargetGO = DeGUILayout.ToggleButton(
_src.tweenTargetIsTargetGO, _src.tweenTargetIsTargetGO ? _GuiC_tweenTargetIsTargetGO_true : _GuiC_tweenTargetIsTargetGO_false,
GUILayout.Width(131)
);
}
bool check = EditorGUI.EndChangeCheck();
if (check) _refreshRequired = true;
GUILayout.EndHorizontal();
GameObject targetGO = _src.targetIsSelf ? _src.gameObject : _src.targetGO;
if (targetGO == null) {
// Uses external target gameObject but it's not set
if (_src.targetGO != null || _src.target != null) {
_src.targetGO = null;
_src.target = null;
GUI.changed = true;
}
} else {
GUILayout.BeginHorizontal();
DOTweenAnimation.AnimationType prevAnimType = _src.animationType;
// _src.animationType = (DOTweenAnimation.AnimationType)EditorGUILayout.EnumPopup(_src.animationType, EditorGUIUtils.popupButton);
GUI.enabled = GUI.enabled && _src.isActive;
_src.animationType = AnimationToDOTweenAnimationType(_AnimationType[EditorGUILayout.Popup(DOTweenAnimationTypeToPopupId(_src.animationType), _AnimationType)]);
_src.autoPlay = DeGUILayout.ToggleButton(_src.autoPlay, new GUIContent("AutoPlay", "If selected, the tween will play automatically"));
_src.autoKill = DeGUILayout.ToggleButton(_src.autoKill, new GUIContent("AutoKill", "If selected, the tween will be killed when it completes, and won't be reusable"));
GUILayout.EndHorizontal();
if (prevAnimType != _src.animationType) {
// Set default optional values based on animation type
_src.endValueTransform = null;
_src.useTargetAsV3 = false;
switch (_src.animationType) {
case DOTweenAnimation.AnimationType.Move:
case DOTweenAnimation.AnimationType.LocalMove:
case DOTweenAnimation.AnimationType.Rotate:
case DOTweenAnimation.AnimationType.LocalRotate:
case DOTweenAnimation.AnimationType.Scale:
_src.endValueV3 = Vector3.zero;
_src.endValueFloat = 0;
_src.optionalBool0 = _src.animationType == DOTweenAnimation.AnimationType.Scale;
break;
case DOTweenAnimation.AnimationType.UIWidthHeight:
_src.endValueV3 = Vector3.zero;
_src.endValueFloat = 0;
_src.optionalBool0 = _src.animationType == DOTweenAnimation.AnimationType.UIWidthHeight;
break;
case DOTweenAnimation.AnimationType.Color:
case DOTweenAnimation.AnimationType.Fade:
_isLightSrc = targetGO.GetComponent<Light>() != null;
_src.endValueFloat = 0;
break;
case DOTweenAnimation.AnimationType.Text:
_src.optionalBool0 = true;
break;
case DOTweenAnimation.AnimationType.PunchPosition:
case DOTweenAnimation.AnimationType.PunchRotation:
case DOTweenAnimation.AnimationType.PunchScale:
_src.endValueV3 = _src.animationType == DOTweenAnimation.AnimationType.PunchRotation ? new Vector3(0, 180, 0) : Vector3.one;
_src.optionalFloat0 = 1;
_src.optionalInt0 = 10;
_src.optionalBool0 = false;
break;
case DOTweenAnimation.AnimationType.ShakePosition:
case DOTweenAnimation.AnimationType.ShakeRotation:
case DOTweenAnimation.AnimationType.ShakeScale:
_src.endValueV3 = _src.animationType == DOTweenAnimation.AnimationType.ShakeRotation ? new Vector3(90, 90, 90) : Vector3.one;
_src.optionalInt0 = 10;
_src.optionalFloat0 = 90;
_src.optionalBool0 = false;
break;
case DOTweenAnimation.AnimationType.CameraAspect:
case DOTweenAnimation.AnimationType.CameraFieldOfView:
case DOTweenAnimation.AnimationType.CameraOrthoSize:
_src.endValueFloat = 0;
break;
case DOTweenAnimation.AnimationType.CameraPixelRect:
case DOTweenAnimation.AnimationType.CameraRect:
_src.endValueRect = new Rect(0, 0, 0, 0);
break;
}
}
if (_src.animationType == DOTweenAnimation.AnimationType.None) {
_src.isValid = false;
if (GUI.changed) EditorUtility.SetDirty(_src);
return;
}
if (_refreshRequired || prevAnimType != _src.animationType || ComponentsChanged()) {
_refreshRequired = false;
_src.isValid = Validate(targetGO);
// See if we need to choose between multiple targets
#if true // UI_MARKER
if (_src.animationType == DOTweenAnimation.AnimationType.Fade && targetGO.GetComponent<CanvasGroup>() != null && targetGO.GetComponent<Image>() != null) {
_chooseTargetMode = ChooseTargetMode.BetweenCanvasGroupAndImage;
// Reassign target and forcedTargetType if lost
if (_src.forcedTargetType == DOTweenAnimation.TargetType.Unset) _src.forcedTargetType = _src.targetType;
switch (_src.forcedTargetType) {
case DOTweenAnimation.TargetType.CanvasGroup:
_src.target = targetGO.GetComponent<CanvasGroup>();
break;
case DOTweenAnimation.TargetType.Image:
_src.target = targetGO.GetComponent<Image>();
break;
}
} else {
#endif
_chooseTargetMode = ChooseTargetMode.None;
_src.forcedTargetType = DOTweenAnimation.TargetType.Unset;
#if true // UI_MARKER
}
#endif
}
if (!_src.isValid) {
GUI.color = Color.red;
GUILayout.BeginVertical(GUI.skin.box);
GUILayout.Label("No valid Component was found for the selected animation", EditorGUIUtils.wordWrapLabelStyle);
GUILayout.EndVertical();
GUI.color = Color.white;
if (GUI.changed) EditorUtility.SetDirty(_src);
return;
}
#if true // UI_MARKER
// Special cases in which multiple target types could be used (set after validation)
if (_chooseTargetMode == ChooseTargetMode.BetweenCanvasGroupAndImage && _src.forcedTargetType != DOTweenAnimation.TargetType.Unset) {
FadeTargetType fadeTargetType = (FadeTargetType)Enum.Parse(typeof(FadeTargetType), _src.forcedTargetType.ToString());
DOTweenAnimation.TargetType prevTargetType = _src.forcedTargetType;
_src.forcedTargetType = (DOTweenAnimation.TargetType)Enum.Parse(typeof(DOTweenAnimation.TargetType), EditorGUILayout.EnumPopup(_src.animationType + " Target", fadeTargetType).ToString());
if (_src.forcedTargetType != prevTargetType) {
// Target type change > assign correct target
switch (_src.forcedTargetType) {
case DOTweenAnimation.TargetType.CanvasGroup:
_src.target = targetGO.GetComponent<CanvasGroup>();
break;
case DOTweenAnimation.TargetType.Image:
_src.target = targetGO.GetComponent<Image>();
break;
}
}
}
#endif
GUILayout.BeginHorizontal();
_src.duration = EditorGUILayout.FloatField("Duration", _src.duration);
if (_src.duration < 0) _src.duration = 0;
_src.isSpeedBased = DeGUILayout.ToggleButton(_src.isSpeedBased, new GUIContent("SpeedBased", "If selected, the duration will count as units/degree x second"), DeGUI.styles.button.tool, GUILayout.Width(75));
GUILayout.EndHorizontal();
_src.delay = EditorGUILayout.FloatField("Delay", _src.delay);
if (_src.delay < 0) _src.delay = 0;
_src.isIndependentUpdate = EditorGUILayout.Toggle("Ignore TimeScale", _src.isIndependentUpdate);
_src.easeType = EditorGUIUtils.FilteredEasePopup("Ease", _src.easeType);
if (_src.easeType == Ease.INTERNAL_Custom) {
_src.easeCurve = EditorGUILayout.CurveField(" Ease Curve", _src.easeCurve);
}
_src.loops = EditorGUILayout.IntField(new GUIContent("Loops", "Set to -1 for infinite loops"), _src.loops);
if (_src.loops < -1) _src.loops = -1;
if (_src.loops > 1 || _src.loops == -1)
_src.loopType = (LoopType)EditorGUILayout.EnumPopup(" Loop Type", _src.loopType);
_src.id = EditorGUILayout.TextField("ID", _src.id);
bool canBeRelative = true;
// End value and eventual specific options
switch (_src.animationType) {
case DOTweenAnimation.AnimationType.Move:
case DOTweenAnimation.AnimationType.LocalMove:
GUIEndValueV3(targetGO, _src.animationType == DOTweenAnimation.AnimationType.Move);
_src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0);
canBeRelative = !_src.useTargetAsV3;
break;
case DOTweenAnimation.AnimationType.Rotate:
case DOTweenAnimation.AnimationType.LocalRotate:
bool isRigidbody2D = DOTweenModuleUtils.Physics.HasRigidbody2D(_src);
if (isRigidbody2D) GUIEndValueFloat();
else {
GUIEndValueV3(targetGO);
_src.optionalRotationMode = (RotateMode)EditorGUILayout.EnumPopup(" Rotation Mode", _src.optionalRotationMode);
}
break;
case DOTweenAnimation.AnimationType.Scale:
if (_src.optionalBool0) GUIEndValueFloat();
else GUIEndValueV3(targetGO);
_src.optionalBool0 = EditorGUILayout.Toggle("Uniform Scale", _src.optionalBool0);
break;
case DOTweenAnimation.AnimationType.UIWidthHeight:
if (_src.optionalBool0) GUIEndValueFloat();
else GUIEndValueV2();
_src.optionalBool0 = EditorGUILayout.Toggle("Uniform Scale", _src.optionalBool0);
break;
case DOTweenAnimation.AnimationType.Color:
GUIEndValueColor();
canBeRelative = false;
break;
case DOTweenAnimation.AnimationType.Fade:
GUIEndValueFloat();
if (_src.endValueFloat < 0) _src.endValueFloat = 0;
if (!_isLightSrc && _src.endValueFloat > 1) _src.endValueFloat = 1;
canBeRelative = false;
break;
case DOTweenAnimation.AnimationType.Text:
GUIEndValueString();
_src.optionalBool0 = EditorGUILayout.Toggle("Rich Text Enabled", _src.optionalBool0);
_src.optionalScrambleMode = (ScrambleMode)EditorGUILayout.EnumPopup("Scramble Mode", _src.optionalScrambleMode);
_src.optionalString = EditorGUILayout.TextField(new GUIContent("Custom Scramble", "Custom characters to use in case of ScrambleMode.Custom"), _src.optionalString);
break;
case DOTweenAnimation.AnimationType.PunchPosition:
case DOTweenAnimation.AnimationType.PunchRotation:
case DOTweenAnimation.AnimationType.PunchScale:
GUIEndValueV3(targetGO);
canBeRelative = false;
_src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent(" Vibrato", "How much will the punch vibrate"), _src.optionalInt0, 1, 50);
_src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent(" Elasticity", "How much the vector will go beyond the starting position when bouncing backwards"), _src.optionalFloat0, 0, 1);
if (_src.animationType == DOTweenAnimation.AnimationType.PunchPosition) _src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0);
break;
case DOTweenAnimation.AnimationType.ShakePosition:
case DOTweenAnimation.AnimationType.ShakeRotation:
case DOTweenAnimation.AnimationType.ShakeScale:
GUIEndValueV3(targetGO);
canBeRelative = false;
_src.optionalInt0 = EditorGUILayout.IntSlider(new GUIContent(" Vibrato", "How much will the shake vibrate"), _src.optionalInt0, 1, 50);
_src.optionalFloat0 = EditorGUILayout.Slider(new GUIContent(" Randomness", "The shake randomness"), _src.optionalFloat0, 0, 90);
if (_src.animationType == DOTweenAnimation.AnimationType.ShakePosition) _src.optionalBool0 = EditorGUILayout.Toggle(" Snapping", _src.optionalBool0);
break;
case DOTweenAnimation.AnimationType.CameraAspect:
case DOTweenAnimation.AnimationType.CameraFieldOfView:
case DOTweenAnimation.AnimationType.CameraOrthoSize:
GUIEndValueFloat();
canBeRelative = false;
break;
case DOTweenAnimation.AnimationType.CameraBackgroundColor:
GUIEndValueColor();
canBeRelative = false;
break;
case DOTweenAnimation.AnimationType.CameraPixelRect:
case DOTweenAnimation.AnimationType.CameraRect:
GUIEndValueRect();
canBeRelative = false;
break;
}
// Final settings
if (canBeRelative) _src.isRelative = EditorGUILayout.Toggle(" Relative", _src.isRelative);
// Events
AnimationInspectorGUI.AnimationEvents(this, _src);
}
EditorGUI.EndDisabledGroup();
if (GUI.changed) EditorUtility.SetDirty(_src);
}
#endregion
#region Methods
// Returns TRUE if the Component layout on the src gameObject changed (a Component was added or removed)
bool ComponentsChanged()
{
int prevTotComponentsOnSrc = _totComponentsOnSrc;
_totComponentsOnSrc = _src.gameObject.GetComponents<Component>().Length;
return prevTotComponentsOnSrc != _totComponentsOnSrc;
}
// Checks if a Component that can be animated with the given animationType is attached to the src
bool Validate(GameObject targetGO)
{
if (_src.animationType == DOTweenAnimation.AnimationType.None) return false;
Component srcTarget;
// First check for external plugins
#if false // TK2D_MARKER
if (_Tk2dAnimationTypeToComponent.ContainsKey(_src.animationType)) {
foreach (Type t in _Tk2dAnimationTypeToComponent[_src.animationType]) {
srcTarget = targetGO.GetComponent(t);
if (srcTarget != null) {
_src.target = srcTarget;
_src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
return true;
}
}
}
#endif
#if false // TEXTMESHPRO_MARKER
if (_TMPAnimationTypeToComponent.ContainsKey(_src.animationType)) {
foreach (Type t in _TMPAnimationTypeToComponent[_src.animationType]) {
srcTarget = targetGO.GetComponent(t);
if (srcTarget != null) {
_src.target = srcTarget;
_src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
return true;
}
}
}
#endif
// Then check for regular stuff
if (_AnimationTypeToComponent.ContainsKey(_src.animationType)) {
foreach (Type t in _AnimationTypeToComponent[_src.animationType]) {
srcTarget = targetGO.GetComponent(t);
if (srcTarget != null) {
_src.target = srcTarget;
_src.targetType = DOTweenAnimation.TypeToDOTargetType(t);
return true;
}
}
}
return false;
}
DOTweenAnimation.AnimationType AnimationToDOTweenAnimationType(string animation)
{
if (_datString == null) _datString = Enum.GetNames(typeof(DOTweenAnimation.AnimationType));
animation = animation.Replace("/", "");
return (DOTweenAnimation.AnimationType)(Array.IndexOf(_datString, animation));
}
int DOTweenAnimationTypeToPopupId(DOTweenAnimation.AnimationType animation)
{
return Array.IndexOf(_animationTypeNoSlashes, animation.ToString());
}
#endregion
#region GUI Draw Methods
void GUIEndValueFloat()
{
GUILayout.BeginHorizontal();
GUIToFromButton();
_src.endValueFloat = EditorGUILayout.FloatField(_src.endValueFloat);
GUILayout.EndHorizontal();
}
void GUIEndValueColor()
{
GUILayout.BeginHorizontal();
GUIToFromButton();
_src.endValueColor = EditorGUILayout.ColorField(_src.endValueColor);
GUILayout.EndHorizontal();
}
void GUIEndValueV3(GameObject targetGO, bool optionalTransform = false)
{
GUILayout.BeginHorizontal();
GUIToFromButton();
if (_src.useTargetAsV3) {
Transform prevT = _src.endValueTransform;
_src.endValueTransform = EditorGUILayout.ObjectField(_src.endValueTransform, typeof(Transform), true) as Transform;
if (_src.endValueTransform != prevT && _src.endValueTransform != null) {
#if true // UI_MARKER
// Check that it's a Transform for a Transform or a RectTransform for a RectTransform
if (targetGO.GetComponent<RectTransform>() != null) {
if (_src.endValueTransform.GetComponent<RectTransform>() == null) {
EditorUtility.DisplayDialog("DOTween Pro", "For Unity UI elements, the target must also be a UI element", "Ok");
_src.endValueTransform = null;
}
} else if (_src.endValueTransform.GetComponent<RectTransform>() != null) {
EditorUtility.DisplayDialog("DOTween Pro", "You can't use a UI target for a non UI object", "Ok");
_src.endValueTransform = null;
}
#endif
}
} else {
_src.endValueV3 = EditorGUILayout.Vector3Field("", _src.endValueV3, GUILayout.Height(16));
}
if (optionalTransform) {
if (GUILayout.Button(_src.useTargetAsV3 ? "target" : "value", EditorGUIUtils.sideBtStyle, GUILayout.Width(44))) _src.useTargetAsV3 = !_src.useTargetAsV3;
}
GUILayout.EndHorizontal();
#if true // UI_MARKER
if (_src.useTargetAsV3 && _src.endValueTransform != null && _src.target is RectTransform) {
EditorGUILayout.HelpBox("NOTE: when using a UI target, the tween will be created during Start instead of Awake", MessageType.Info);
}
#endif
}
void GUIEndValueV2()
{
GUILayout.BeginHorizontal();
GUIToFromButton();
_src.endValueV2 = EditorGUILayout.Vector2Field("", _src.endValueV2, GUILayout.Height(16));
GUILayout.EndHorizontal();
}
void GUIEndValueString()
{
GUILayout.BeginHorizontal();
GUIToFromButton();
_src.endValueString = EditorGUILayout.TextArea(_src.endValueString, EditorGUIUtils.wordWrapTextArea);
GUILayout.EndHorizontal();
}
void GUIEndValueRect()
{
GUILayout.BeginHorizontal();
GUIToFromButton();
_src.endValueRect = EditorGUILayout.RectField(_src.endValueRect);
GUILayout.EndHorizontal();
}
void GUIToFromButton()
{
if (GUILayout.Button(_src.isFrom ? "FROM" : "TO", EditorGUIUtils.sideBtStyle, GUILayout.Width(90))) _src.isFrom = !_src.isFrom;
GUILayout.Space(16);
}
#endregion
}
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
[InitializeOnLoad]
static class Initializer
{
static Initializer()
{
DOTweenAnimation.OnReset += OnReset;
}
static void OnReset(DOTweenAnimation src)
{
DOTweenSettings settings = DOTweenUtilityWindow.GetDOTweenSettings();
if (settings == null) return;
Undo.RecordObject(src, "DOTweenAnimation");
src.autoPlay = settings.defaultAutoPlay == AutoPlay.All || settings.defaultAutoPlay == AutoPlay.AutoPlayTweeners;
src.autoKill = settings.defaultAutoKill;
EditorUtility.SetDirty(src);
}
}
}
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenAnimationInspector.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e0203fd81362bab4d842d87ad09ee76e
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenPreviewManager.cs 0 → 100644
View file @ f21b0cad
// Author: Daniele Giardini - http://www.demigiant.com
// Created: 2015/03/12 16:03
using System;
using System.Collections.Generic;
using DG.DemiEditor;
using DG.DemiLib;
using DG.Tweening;
using DG.Tweening.Core;
using UnityEditor;
using UnityEditorInternal;
using UnityEngine;
using Object = UnityEngine.Object;
namespace DG.DOTweenEditor
{
public static class DOTweenPreviewManager
{
static bool _previewOnlyIfSetToAutoPlay = true;
static readonly Dictionary<DOTweenAnimation,TweenInfo> _AnimationToTween = new Dictionary<DOTweenAnimation,TweenInfo>();
static readonly List<DOTweenAnimation> _TmpKeys = new List<DOTweenAnimation>();
#region Public Methods & GUI
/// <summary>
/// Returns TRUE if its actually previewing animations
/// </summary>
public static bool PreviewGUI(DOTweenAnimation src)
{
if (EditorApplication.isPlaying) return false;
Styles.Init();
bool isPreviewing = _AnimationToTween.Count > 0;
bool isPreviewingThis = isPreviewing && _AnimationToTween.ContainsKey(src);
// Preview in editor
GUI.backgroundColor = isPreviewing
? new DeSkinColor(new Color(0.49f, 0.8f, 0.86f), new Color(0.15f, 0.26f, 0.35f))
: new DeSkinColor(Color.white, new Color(0.13f, 0.13f, 0.13f));
GUILayout.BeginVertical(Styles.previewBox);
DeGUI.ResetGUIColors();
GUILayout.BeginHorizontal();
GUILayout.Label("Preview Mode - Experimental", Styles.previewLabel);
_previewOnlyIfSetToAutoPlay = DeGUILayout.ToggleButton(
_previewOnlyIfSetToAutoPlay,
new GUIContent("AutoPlay only", "If toggled only previews animations that have AutoPlay turned ON"),
Styles.btOption
);
GUILayout.EndHorizontal();
GUILayout.Space(1);
// Preview - Play
GUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(
isPreviewingThis || src.animationType == DOTweenAnimation.AnimationType.None
|| !src.isActive || _previewOnlyIfSetToAutoPlay && !src.autoPlay
);
if (GUILayout.Button("► Play", Styles.btPreview)) {
if (!isPreviewing) StartupGlobalPreview();
AddAnimationToGlobalPreview(src);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(isPreviewing);
if (GUILayout.Button("► Play All <i>on GameObject</i>", Styles.btPreview)) {
if (!isPreviewing) StartupGlobalPreview();
DOTweenAnimation[] anims = src.gameObject.GetComponents<DOTweenAnimation>();
foreach (DOTweenAnimation anim in anims) AddAnimationToGlobalPreview(anim);
}
if (GUILayout.Button("► Play All <i>in Scene</i>", Styles.btPreview)) {
if (!isPreviewing) StartupGlobalPreview();
DOTweenAnimation[] anims = Object.FindObjectsOfType<DOTweenAnimation>();
foreach (DOTweenAnimation anim in anims) AddAnimationToGlobalPreview(anim);
}
EditorGUI.EndDisabledGroup();
GUILayout.EndHorizontal();
// Preview - Stop
GUILayout.BeginHorizontal();
EditorGUI.BeginDisabledGroup(!isPreviewingThis);
if (GUILayout.Button("■ Stop", Styles.btPreview)) {
if (_AnimationToTween.ContainsKey(src)) StopPreview(_AnimationToTween[src].tween);
}
EditorGUI.EndDisabledGroup();
EditorGUI.BeginDisabledGroup(!isPreviewing);
if (GUILayout.Button("■ Stop All <i>on GameObject</i>", Styles.btPreview)) {
StopPreview(src.gameObject);
}
if (GUILayout.Button("■ Stop All <i>in Scene</i>", Styles.btPreview)) {
StopAllPreviews();
}
EditorGUI.EndDisabledGroup();
GUILayout.EndHorizontal();
if (isPreviewing) {
int playingTweens = 0;
int completedTweens = 0;
int pausedTweens = 0;
foreach (KeyValuePair<DOTweenAnimation, TweenInfo> kvp in _AnimationToTween) {
Tween t = kvp.Value.tween;
if (t.IsPlaying()) playingTweens++;
else if (t.IsComplete()) completedTweens++;
else pausedTweens++;
}
GUILayout.Label("Playing Tweens: " + playingTweens, Styles.previewStatusLabel);
GUILayout.Label("Completed Tweens: " + completedTweens, Styles.previewStatusLabel);
// GUILayout.Label("Paused Tweens: " + playingTweens);
}
GUILayout.EndVertical();
return isPreviewing;
}
#if !(UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5)
public static void StopAllPreviews(PlayModeStateChange state)
{
StopAllPreviews();
}
#endif
public static void StopAllPreviews()
{
_TmpKeys.Clear();
foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
_TmpKeys.Add(kvp.Key);
}
StopPreview(_TmpKeys);
_TmpKeys.Clear();
_AnimationToTween.Clear();
DOTweenEditorPreview.Stop();
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5
UnityEditor.EditorApplication.playmodeStateChanged -= StopAllPreviews;
#else
UnityEditor.EditorApplication.playModeStateChanged -= StopAllPreviews;
#endif
// EditorApplication.playmodeStateChanged -= StopAllPreviews;
InternalEditorUtility.RepaintAllViews();
}
#endregion
#region Methods
static void StartupGlobalPreview()
{
DOTweenEditorPreview.Start();
#if UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_5
UnityEditor.EditorApplication.playmodeStateChanged += StopAllPreviews;
#else
UnityEditor.EditorApplication.playModeStateChanged += StopAllPreviews;
#endif
// EditorApplication.playmodeStateChanged += StopAllPreviews;
}
static void AddAnimationToGlobalPreview(DOTweenAnimation src)
{
if (!src.isActive) return; // Ignore sources whose tweens have been set to inactive
if (_previewOnlyIfSetToAutoPlay && !src.autoPlay) return;
Tween t = src.CreateEditorPreview();
_AnimationToTween.Add(src, new TweenInfo(src, t, src.isFrom));
// Tween setup
DOTweenEditorPreview.PrepareTweenForPreview(t);
}
static void StopPreview(GameObject go)
{
_TmpKeys.Clear();
foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
if (kvp.Key.gameObject != go) continue;
_TmpKeys.Add(kvp.Key);
}
StopPreview(_TmpKeys);
_TmpKeys.Clear();
if (_AnimationToTween.Count == 0) StopAllPreviews();
else InternalEditorUtility.RepaintAllViews();
}
static void StopPreview(Tween t)
{
TweenInfo tInfo = null;
foreach (KeyValuePair<DOTweenAnimation,TweenInfo> kvp in _AnimationToTween) {
if (kvp.Value.tween != t) continue;
tInfo = kvp.Value;
_AnimationToTween.Remove(kvp.Key);
break;
}
if (tInfo == null) {
Debug.LogWarning("DOTween Preview ► Couldn't find tween to stop");
return;
}
if (tInfo.isFrom) {
int totLoops = tInfo.tween.Loops();
if (totLoops < 0 || totLoops > 1) {
tInfo.tween.Goto(tInfo.tween.Duration(false));
} else tInfo.tween.Complete();
} else tInfo.tween.Rewind();
tInfo.tween.Kill();
EditorUtility.SetDirty(tInfo.animation); // Refresh views
if (_AnimationToTween.Count == 0) StopAllPreviews();
else InternalEditorUtility.RepaintAllViews();
}
// Stops while iterating inversely, which deals better with tweens that overwrite each other
static void StopPreview(List<DOTweenAnimation> keys)
{
for (int i = keys.Count - 1; i > -1; --i) {
DOTweenAnimation anim = keys[i];
TweenInfo tInfo = _AnimationToTween[anim];
if (tInfo.isFrom) {
int totLoops = tInfo.tween.Loops();
if (totLoops < 0 || totLoops > 1) {
tInfo.tween.Goto(tInfo.tween.Duration(false));
} else tInfo.tween.Complete();
} else tInfo.tween.Rewind();
tInfo.tween.Kill();
EditorUtility.SetDirty(anim); // Refresh views
_AnimationToTween.Remove(anim);
}
}
#endregion
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
// ███ INTERNAL CLASSES ████████████████████████████████████████████████████████████████████████████████████████████████
// █████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
class TweenInfo
{
public DOTweenAnimation animation;
public Tween tween;
public bool isFrom;
public TweenInfo(DOTweenAnimation animation, Tween tween, bool isFrom)
{
this.animation = animation;
this.tween = tween;
this.isFrom = isFrom;
}
}
static class Styles
{
static bool _initialized;
public static GUIStyle previewBox, previewLabel, btOption, btPreview, previewStatusLabel;
public static void Init()
{
if (_initialized) return;
_initialized = true;
previewBox = new GUIStyle(GUI.skin.box).Clone().Padding(1, 1, 0, 3)
.Background(DeStylePalette.squareBorderCurved_darkBorders).Border(7, 7, 7, 7);
previewLabel = new GUIStyle(GUI.skin.label).Clone(10, FontStyle.Bold).Padding(1, 0, 3, 0).Margin(3, 6, 0, 0).StretchWidth(false);
btOption = DeGUI.styles.button.bBlankBorderCompact.MarginBottom(2).MarginRight(4);
btPreview = EditorStyles.miniButton.Clone(Format.RichText);
previewStatusLabel = EditorStyles.miniLabel.Clone().Padding(4, 0, 0, 0).Margin(0);
}
}
}
}
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenPreviewManager.cs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 22292a5f27a9a644ba9e6ad1bf863531
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML 0 → 100644
View file @ f21b0cad
<?xml version="1.0"?>
<doc>
<assembly>
<name>DOTweenProEditor</name>
</assembly>
<members>
<member name="T:DG.DOTweenEditor.Core.ColorPalette.Custom">
<summary>
Custom colors
</summary>
</member>
<member name="M:DG.DOTweenEditor.Core.StylePalette.Custom.Init">
<summary>
Needs to be overridden in order to initialize new styles added from inherited classes
</summary>
</member>
</members>
</doc>
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenProEditor.XML.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 753a4f4ed73b17143923101226957756
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ee3a420017f129443896310d9fab256b
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenProEditor.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a6402d4311c862b4eb1325590d6466af
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 0
settings: {}
Editor:
enabled: 1
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/Editor/DOTweenProEditor.zip.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7d8319d7443886d43af20da7db38d51b
timeCreated: 1594632147
licenseType: Store
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DOTweenPro/readme.txt 0 → 100644
View file @ f21b0cad
DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
// IMPORTANT!!! /////////////////////////////////////////////
// Upgrading DOTween from versions older than 1.2.000 ///////
// (or DOTween Pro older than 1.0.000) //////////////////////
-------------------------------------------------------------
If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (like TextMesh Pro)
// GET STARTED //////////////////////////////////////////////
- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
// VISUAL SCRIPTING (PRO ONLY)
- To animate a gameObject, select it and choose "Add Component > DOTween > DOTween Animation"
- To animate a gameObject along a path, select it and choose "Add Component > DOTween > DOTween Path"
// SCRIPTING
- In your code, add "using DG.Tweening" to each class where you want to use DOTween.
- You're ready to tween. Check out the links below for full documentation and license info.
// LINKS ///////////////////////////////////////////////////////
DOTween website (documentation, examples, etc): http://dotween.demigiant.com
DOTween license: http://dotween.demigiant.com/license.php
DOTween repository (Google Code): https://code.google.com/p/dotween/
Demigiant website (documentation, examples, etc): http://www.demigiant.com
// NOTES //////////////////////////////////////////////////////
- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences
\ No newline at end of file
Assets/Plugins/Demigiant/DOTweenPro/readme.txt.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: aa8f07903bf128e44a7d0b91a63dedab
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DemiLib.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 5a499e4809836274eb38cd99b370a2c1
labels:
- iTween
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DemiLib/Core.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 03513cf143bb144409fbb3a51ec77b1b
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/DemiLib.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 995cf2d9b4a41f840b3a41712e9b3bc0
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/DemiLib.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 54be29b67d0d29a478da2c6e5c62f091
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 1
settings: {}
Editor:
enabled: 0
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DemiLib/Core/DemiLib.xml 0 → 100644
View file @ f21b0cad
<?xml version="1.0"?>
<doc>
<assembly>
<name>DemiLib</name>
</assembly>
<members>
<member name="T:DG.DemiLib.Attributes.DeScriptExecutionOrderAttribute">
<summary>
<code>Class attribute</code><para/>
Sets the script execution order index
</summary>
</member>
<member name="M:DG.DemiLib.Attributes.DeScriptExecutionOrderAttribute.#ctor(System.Int32)">
<summary>
Sets the script execution order for this class
</summary>
<param name="order">Script execution order index</param>
</member>
<member name="F:DG.DemiLib.Core.GUIUtils.isProSkin">
<summary>
Set when calling <code>DeGUI.BeginGUI</code>
</summary>
</member>
<member name="T:DG.DemiLib.DeColorPalette">
<summary>
Stores a color palette, which can be passed to default DeGUI layouts when calling <code>DeGUI.BeginGUI</code>,
and changed at any time by calling <code>DeGUI.ChangePalette</code>.
You can inherit from this class to create custom color palettes with more hColor options.
</summary>
</member>
<member name="M:DG.DemiLib.DeColorPalette.HexToColor(System.String)">
<summary>
Converts a HEX color to a Unity Color and returns it
</summary>
<param name="hex">The HEX color, either with or without the initial # (accepts both regular and short format)</param>
</member>
<member name="T:DG.DemiLib.DeColorGlobal">
<summary>
Global colors
</summary>
</member>
<member name="T:DG.DemiLib.DeColorBG">
<summary>
Background colors
</summary>
</member>
<member name="F:DG.DemiLib.DeColorBG.editor">
<summary>Editor background color</summary>
</member>
<member name="T:DG.DemiLib.DeColorContent">
<summary>
Content colors
</summary>
</member>
<member name="T:DG.DemiLib.DeInputUtils">
<summary>
Various Input utils
</summary>
</member>
<member name="M:DG.DemiLib.DeInputUtils.IsNumKeyDown">
<summary>
Returns a number key int if a number key was pressed in this frame, or -1 otherwise
</summary>
<returns></returns>
</member>
<member name="T:DG.DemiLib.DeScope">
<summary>
Extend this to replicate Unity's Scope system with any Unity version.
Thanks to Dmitriy Yukhanov for pointing this out and creating an initial version.
Expand this class to create scopes.<para/>
Example:
<code>public class VBoxScope : DeScope
{
public VBoxScope(GUIStyle style)
{
BeginVBox(style);
}
protected override void CloseScope()
{
EndVBox();
}
}</code>
Usage:
<code>using (new VBoxScope(myStyle) {
// Do something
}</code>
</summary>
</member>
<member name="T:DG.DemiLib.DeSkinColor">
<summary>
Contains both free and pro skins color variations,
and automatically returns the correct one when converted to Color
</summary>
</member>
<member name="T:DG.DemiLib.External.DeHierarchyComponent">
<summary>
Used by DeHierarchy
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.MissingItemsIndexes">
<summary>
Returns a list of all items whose gameObject is NULL, or NULL if there's no missing gameObjects.
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.StoreItemColor(UnityEngine.GameObject,DG.DemiLib.External.DeHierarchyComponent.HColor)">
<summary>
If the item exists sets it, otherwise first creates it and then sets it
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.StoreItemIcon(UnityEngine.GameObject,DG.DemiLib.External.DeHierarchyComponent.IcoType)">
<summary>
If the item exists sets it, otherwise first creates it and then sets it
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.StoreItemSeparator(UnityEngine.GameObject,System.Nullable{DG.DemiLib.External.DeHierarchyComponent.SeparatorType},System.Nullable{DG.DemiLib.External.DeHierarchyComponent.HColor})">
<summary>
If the item exists sets it, otherwise first creates it and then sets it
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.RemoveItemData(UnityEngine.GameObject)">
<summary>
Returns TRUE if the item existed and was removed.
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.ResetSeparator(UnityEngine.GameObject)">
<summary>
Returns TRUE if the item existed and was changed.
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.GetItem(UnityEngine.GameObject)">
<summary>
Returns the customizedItem for the given gameObject, or NULL if none was found
</summary>
</member>
<member name="M:DG.DemiLib.External.DeHierarchyComponent.GetColor(DG.DemiLib.External.DeHierarchyComponent.HColor)">
<summary>
Returns the color corresponding to the given <see cref="T:DG.DemiLib.External.DeHierarchyComponent.HColor"/>
</summary>
</member>
<member name="P:DG.DemiLib.IEditorGUINode.id">
<summary>Must be univocal</summary>
</member>
<member name="P:DG.DemiLib.IEditorGUINode.guiPosition">
<summary>Node position in editor GUI</summary>
</member>
<member name="P:DG.DemiLib.IEditorGUINode.connectedNodesIds">
<summary>Ids of all forward connected nodes. Length indicates how many forward connections are allowed.
Min length represents available connections from node.</summary>
</member>
<member name="T:DG.DemiLib.IntRange">
<summary>
A serializable struct including a min and a max int value
</summary>
</member>
<member name="F:DG.DemiLib.IntRange.min">
<summary>Min value</summary>
</member>
<member name="F:DG.DemiLib.IntRange.max">
<summary>Max value</summary>
</member>
<member name="M:DG.DemiLib.IntRange.#ctor(System.Int32,System.Int32)">
<summary>
Creates a new Range
</summary>
</member>
<member name="M:DG.DemiLib.IntRange.RandomWithin">
<summary>
Returns a random value within this range (min/max included)
</summary>
</member>
<member name="M:DG.DemiLib.IntRange.ToString">
<inheritdoc />
</member>
<member name="T:DG.DemiLib.Range">
<summary>
A serializable struct including a min and a max float value
</summary>
</member>
<member name="F:DG.DemiLib.Range.min">
<summary>Min value</summary>
</member>
<member name="F:DG.DemiLib.Range.max">
<summary>Max value</summary>
</member>
<member name="M:DG.DemiLib.Range.#ctor(System.Single,System.Single)">
<summary>
Creates a new Range
</summary>
</member>
<member name="M:DG.DemiLib.Range.RandomWithin">
<summary>
Returns a random value within this range (min/max included)
</summary>
</member>
<member name="M:DG.DemiLib.Range.ToString">
<inheritdoc />
</member>
</members>
</doc>
Assets/Plugins/Demigiant/DemiLib/Core/DemiLib.xml.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 9bf2564c9817bb34988453ae948954d2
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 77fbbad1c51d68f4c844d26743104b07
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/DemiEditor.dll.mdb.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 2c20a7b4db3cd0a4a99bcf6218f92860
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/DemiEditor.dll.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 202f9ddaf2c1a8a429504f7f3cd7b84f
PluginImporter:
serializedVersion: 1
iconMap: {}
executionOrder: {}
isPreloaded: 0
platformData:
Any:
enabled: 0
settings: {}
Editor:
enabled: 1
settings:
DefaultValueInitialized: true
WindowsStoreApps:
enabled: 0
settings:
CPU: AnyCPU
userData:
assetBundleName:
assetBundleVariant:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/DemiEditor.xml 0 → 100644
View file @ f21b0cad
This source diff could not be displayed because it is too large. You can view the blob instead.
Assets/Plugins/Demigiant/DemiLib/Core/Editor/DemiEditor.xml.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d4a42b2e4e6f64d4ba01d35c5a3dafed
TextScriptImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 1efb03f507a60b949a70ed828ac18eb8
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7ba4b2810f605d945af87e032ca2957b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquareAlpha10.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8c9cfa1dbe00a1d41ae9d14f5ac543ec
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquareAlpha15.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 53d696c01f6ca524383f11fcc34dd13c
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquareAlpha25.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: f7ff421f40d548444864a01cd7f47112
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquareAlpha50.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: aa1d42dc6ff3e894da2208c6929d2165
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blackSquareAlpha80.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 595b166389c8db546a199430284ebc9b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/blueSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 05cfe010378336646ad6c721f66543d1
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/circle.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: af28470bd0e2e9543a6dfa9a1a4b348d
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/greenSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 789ef07ba2573f6448fa8b5dc5224c44
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/grid_bright.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 93b1287b4a087f84c95c72f49ec94e83
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/grid_dark.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d542f997a51000946873268e3546b6ba
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alert.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 39cacc93c6c183f44992bf2421362f78
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignB.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8b6b31f71cd528243b053cfc488e73f5
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignBC.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 2cdc0bc527f7a434496c6be9236e636f
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignBL.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: abf8a615f379ef44b9ac872a13b7712f
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignBR.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: eeac3acbf7d1cd54fabfb1c4a12f9fc8
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignCC.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8f0cb66458819764b94b93250bae94b6
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignCL.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 2a8208d8e80f90944b8ff2978292b03b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignCR.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 6f504a3fa8848264bb4fb9bb7d582dd5
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignHC.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: b9e0e5a8836018e4c810fbceba55a1b4
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignL.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d18ceface0c20014b8db4bba05a41b83
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignR.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 727ba41e4cc95fe4a98b07301e3ebfc8
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignT.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: b4785ec6d937dab4fa59da70b69afc9d
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignTC.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 0f79253104349f44cb73978f6c8e93de
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignTL.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 6efe1c8569d975640ba0c9f2ac4a9d61
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignTR.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e01c0b07c87513844ab88bb432bcf85a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_alignVC.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d1d45eadab0e41c4a82cdffb6396b1d7
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_camera.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 37639be6148186645bca3fce45d5aa22
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_camera_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 358cddede8023574191e0aae610a4645
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_cog.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7c83a08052c9e2f49b47897a637994de
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_cog_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 6862027f2176eae40a3143c562466a1b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_comment.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 622fdb780ae13e840938631c5ed708f2
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_comment_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d98b8847646169c4fb5af28dd84c4179
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_delete.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 6b1f9e1e1c2cf004b8e3bdd3033a8e75
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_demigiant.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 229d0d11465a822449f78a50dbf7104d
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_distributeHAlignT.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 1ccb12a4b0bf8f447b2cc114851732f5
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_distributeVAlignL.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 32eaa0efb2b38774ea9705b40fdcc00a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_end.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a248c8288afb9184f953d9aa07a696b0
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_flipV.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: c44ae4a96937e2c4b8be481648364682
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_foldout_closed.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 301c130dbb4bbba4e87072804939c861
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_foldout_open.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 18a5a7cde794cc04b9b446f0feedb3a0
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_heart.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d173388c1d9c32a418b5b777dd89d71a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_heart_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 669c487f3c9c5fe4abb6459f9c2628f0
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_light.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4f69b96f9308d8f4ea239773ef5b55c4
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_light_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 252f207d01ecc87419cdba1d1c0ab1ea
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_lock.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e3d0592dad579e141924133869455c53
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_lock_open.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8d60feae84bdb2d4eb16a0037056c588
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_nodeArrow.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4aa34055b1d36ef479af3d7b5701b28a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_ok.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 34f39b5a760ddbb4d8b8749852868335
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_optionsDropdown.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 62a48d93e78c63b4ea9b46537c7c0091
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_play.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 2a563a43c33f0f3428d02b3a43886fc2
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_play_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 45e128e1cf00555479ee7934ab11cadf
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_skull.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 01976ad42d31f494e8040d3e32e283dc
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_skull_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 6dfd924c0ba23844fb5d04ad1560de22
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_star.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 645aafe2260b2884a9df05b4bc01b1ec
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_star_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 18f3a26aa87fccc4cb5e211d4c6de662
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_ui.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: cb46e1d925af22d43a6f8bf0e1d459e6
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_ui_border.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: c0c40ceac3c6df146a0fcd4e6b226540
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_visibility.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 55c2b426022dac44f9b25f0cba28aa45
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/ico_visibility_off.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 0c0132429106c8a4d89d9d0a6b723ec3
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/orangeSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 3e730492361eb6e45be5c5fdafac23be
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 52bdbb53205da074d9937b996806e2e2
folderAsset: yes
DefaultImporter:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_atlas.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e2279677842a8064fbae0bc889fb85ab
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_audio.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e1af8927fb6f5634896d59aed409a589
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_bundle.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 58676a985ae875646b7be748cf4499fd
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_cog.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: fb605a2688b31194887f2e7a6769235b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_cross.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 3b67e53c8c2f8114b966c0e70d452419
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_demigiant.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: f36ab42cc6fcdfd4187033279d3d14a9
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_folder.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4f2c4b43188596b47866d41e1dc13c8a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_fonts.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: cf986943c88c2254780c17b2b5e3bc2f
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_heart.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 20794834c0a413f408b80110d0fc73b8
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_materials.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e02713e10d7aced44a7a651231f0adef
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_models.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 09a0cde07b4d75f49b4c817932791b81
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_particles.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8003873ab749935489bb11f23f830856
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_play.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d8306b1e159c72c4ebc9a4fc31debe60
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_prefab.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ed3789262161efa4fa33c85ca534590e
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_scripts.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 96cbdf605b8ddb34da384703f2d0b849
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_shaders.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: f252c69cd0163714eba038403f61b09e
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_skull.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d563d6ce25cd2ca48b185ec47a74a3fb
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_star.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 21820ec6fc9dd0b4fbf42a3b93fdad4e
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_terrains.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4a091a7609ef2d34bbdfaa1a886deb18
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/project/ico_textures.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 3e6b96a975eba1c43b2bad66fb7f8b4a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/purpleSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: dc0ca9b32ae9fd049911671cf1a480bf
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/redSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: fbdd7ecf39c13bf48a5bd02a1159c90b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorder.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: afd7d0ddb1d6c744b9cb87ae49b2ce62
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderAlpha15.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: dfd33662d9f6f3849bd92f6e159ca226
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurved.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4896b5aa9d63dec498136c21ffce735b
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurved02.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ff88be84254fb1f4b9a81a27ae0b2e81
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurved02_darkBorders.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: e3ae01f12865ad54ba365963bda55759
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurvedAlpha.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a1606d34a052ed3449da93edd229743e
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurvedEmpty.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4578222ee7a511446b0c340551bf8740
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurvedEmpty02.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7d504312fad10f040b95bd8836dc6fc6
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurvedEmptyThick.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: fc3b86627d5fe1c4d865b80627e2e37c
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurved_darkBorders.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 25da15ac84743244ab4c860cf8798ec8
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderCurved_darkBordersAlpha.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: f536c51d3da3f2e4ca93ac8773ec2ad8
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderEmpty.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 8db54efcce998554c86b796b37a7cdfa
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderEmpty01.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: aa8dc9238ab21e54ca88fa22698e4679
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderEmpty02.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 29b0e8156f6fb774faf129c83bc9ee33
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderEmpty03.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: c0a56b88a1b449045b3fe5f561aa12fa
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderThickEmpty.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: c456d5ac01d2aa843a63985497b04931
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareBorderThickerEmpty.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 7acc6bd588627b046bc1c9b3cd78a6c7
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareCorners03.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: dec3ea647707588408ec0d11ab130b73
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/squareCornersEmpty02.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ca2f91cc405eb144dad970eb23db2f72
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/tileBars_empty.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: d1278357b25e10442b6ca6c24edc9781
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/tileBars_slanted.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: c99a391f381fe534c80a193fe9f307a0
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/tileBars_slanted_alpha.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 018a5623a46db1d49b1e6ff2482b07ab
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/transparentSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 4d338c631fa36f345b72a36f1c91ff9a
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteDot.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ed7cb8f9a27664e48896c904189f0e2c
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteDot_darkBorder.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 27df4ca974a8eaf40803907859421506
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteDot_whiteBorderAlpha.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 039dc89c76661c344b7776f8a47cc5a4
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: dfe6e0ac3e5f24740a17e14b65e08406
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquareAlpha10.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 93b68213089b05943a651574eb7e2fb5
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquareAlpha15.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 5510cdd48a6aaaa439c95ef5b2fe9e28
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquareAlpha25.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 511f6b24c50557a40a09633b12b8b8ef
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 0
linearTexture: 1
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -3
maxTextureSize: 32
textureSettings:
filterMode: 0
aniso: 1
mipBias: -1
wrapMode: 1
nPOTScale: 0
lightmap: 0
compressionQuality: 100
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 1
textureType: 2
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquareAlpha50.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: ef40b00a83f7bd34f84851386b3321f0
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquareAlpha80.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 11848dd30e516d846a02cd302634d317
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/whiteSquare_fadeOut_bt.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: a40dc0d6372a9084fb45976308087290
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/DemiLib/Core/Editor/Imgs/yellowSquare.png.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 517a5bfe18f2ee04d9925db10be034e2
TextureImporter:
fileIDToRecycleName: {}
serializedVersion: 2
mipmaps:
mipMapMode: 0
enableMipMap: 1
linearTexture: 0
correctGamma: 0
fadeOut: 0
borderMipMap: 0
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: .25
normalMapFilter: 0
isReadable: 0
grayScaleToAlpha: 0
generateCubemap: 0
seamlessCubemap: 0
textureFormat: -1
maxTextureSize: 1024
textureSettings:
filterMode: -1
aniso: -1
mipBias: -1
wrapMode: -1
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: .5, y: .5}
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spritePixelsToUnits: 100
alphaIsTransparency: 0
textureType: -1
buildTargetSettings: []
spriteSheet:
sprites: []
spritePackingTag:
userData:
Assets/Plugins/Demigiant/readme_DOTweenPro.txt 0 → 100644
View file @ f21b0cad
DOTween and DOTween Pro are copyright (c) 2014-2018 Daniele Giardini - Demigiant
// IMPORTANT!!! /////////////////////////////////////////////
// Upgrading DOTween from versions older than 1.2.000 ///////
// (or DOTween Pro older than 1.0.000) //////////////////////
-------------------------------------------------------------
If you're upgrading your project from a version of DOTween older than 1.2.000 (or DOTween Pro older than 1.0.000) please follow these instructions carefully.
1) Import the new version in the same folder as the previous one, overwriting old files. A lot of errors will appear but don't worry
2) Close and reopen Unity (and your project). This is fundamental: skipping this step will cause a bloodbath
3) Open DOTween's Utility Panel (Tools > Demigiant > DOTween Utility Panel) if it doesn't open automatically, then press "Setup DOTween...": this will run the upgrade setup
4) From the Add/Remove Modules panel that opens, activate/deactivate Modules for Unity systems and for external assets (like TextMesh Pro)
// GET STARTED //////////////////////////////////////////////
- After importing a new DOTween update, select DOTween's Utility Panel from the "Tools/Demigiant" menu (if it doesn't open automatically) and press the "Setup DOTween..." button to activate/deactivate Modules. You can also access a Preferences Tab from there to choose default settings for DOTween.
// VISUAL SCRIPTING (PRO ONLY)
- To animate a gameObject, select it and choose "Add Component > DOTween > DOTween Animation"
- To animate a gameObject along a path, select it and choose "Add Component > DOTween > DOTween Path"
// SCRIPTING
- In your code, add "using DG.Tweening" to each class where you want to use DOTween.
- You're ready to tween. Check out the links below for full documentation and license info.
// LINKS ///////////////////////////////////////////////////////
DOTween website (documentation, examples, etc): http://dotween.demigiant.com
DOTween license: http://dotween.demigiant.com/license.php
DOTween repository (Google Code): https://code.google.com/p/dotween/
Demigiant website (documentation, examples, etc): http://www.demigiant.com
// NOTES //////////////////////////////////////////////////////
- DOTween's Utility Panel can be found under "Tools > Demigiant > DOTween Utility Panel" and also contains other useful options, plus a tab to set DOTween's preferences
\ No newline at end of file
Assets/Plugins/Demigiant/readme_DOTweenPro.txt.meta 0 → 100644
View file @ f21b0cad
fileFormatVersion: 2
guid: 24123b2fcdc15c943bed44e0c6beeec7
labels:
- iTween
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment