UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-03-08 11:46:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '4.0' into 4.1-beta

Browse Source 
# Conflicts:
#	spine-ts/package-lock.json
#	spine-ts/package.json
#	spine-ts/spine-canvas/package.json
#	spine-ts/spine-core/package.json
#	spine-ts/spine-player/package.json
#	spine-ts/spine-threejs/package.json
#	spine-ts/spine-webgl/package.json
This commit is contained in:
Mario Zechner 2022-03-21 19:32:37 +01:00
commit 78e8f637bb
10 changed files with 139 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spine-ts/spine-threejs/example/index.html
View File

@ -3,7 +3,7 @@
<head> <head>
<meta charset="UTF-8"> <meta charset="UTF-8">
<title>spine-threejs</title> <title>spine-threejs</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.js"></script> <script src="https://unpkg.com/three@0.138.3/build/three.js"></script>
<script src="../dist/iife/spine-threejs.js"></script> <script src="../dist/iife/spine-threejs.js"></script>
</head> </head>
<style> <style>

6
spine-ts/spine-threejs/src/SkeletonMesh.ts
View File

@ -48,14 +48,14 @@ export class SkeletonMeshMaterial extends THREE.ShaderMaterial {
`; `;
let fragmentShader = ` let fragmentShader = `
uniform sampler2D map; uniform sampler2D map;
#ifdef USE_ALPHATEST #ifdef USE_SPINE_ALPHATEST
uniform float alphaTest; uniform float alphaTest;
#endif #endif
varying vec2 vUv; varying vec2 vUv;
varying vec4 vColor; varying vec4 vColor;
void main(void) { void main(void) {
gl_FragColor = texture2D(map, vUv)*vColor; gl_FragColor = texture2D(map, vUv)*vColor;
#ifdef USE_ALPHATEST #ifdef USE_SPINE_ALPHATEST
if (gl_FragColor.a < alphaTest) discard; if (gl_FragColor.a < alphaTest) discard;
#endif #endif
} }
@ -74,7 +74,7 @@ export class SkeletonMeshMaterial extends THREE.ShaderMaterial {
}; };
customizer(parameters); customizer(parameters);
if (parameters.alphaTest > 0) { if (parameters.alphaTest > 0) {
parameters.defines = { "USE_ALPHATEST": 1 }; parameters.defines = { "USE_SPINE_ALPHATEST": 1 };
parameters.uniforms["alphaTest"] = { value: parameters.alphaTest }; parameters.uniforms["alphaTest"] = { value: parameters.alphaTest };
} }
super(parameters); super(parameters);

101
spine-unity/Assets/Spine/Editor/spine-unity/Editor/Utility/SpineBuildProcessor.cs
View File

@ -71,62 +71,83 @@ namespace Spine.Unity.Editor {
#if HAS_ON_POSTPROCESS_PREFAB #if HAS_ON_POSTPROCESS_PREFAB
internal static void PreprocessSpinePrefabMeshes () { internal static void PreprocessSpinePrefabMeshes () {
AssetDatabase.StartAssetEditing(); BuildUtilities.IsInSkeletonAssetBuildPreProcessing = true;
prefabsToRestore.Clear(); try {
var prefabAssets = AssetDatabase.FindAssets("t:Prefab"); AssetDatabase.StartAssetEditing();
foreach (var asset in prefabAssets) { prefabsToRestore.Clear();
string assetPath = AssetDatabase.GUIDToAssetPath(asset); var prefabAssets = AssetDatabase.FindAssets("t:Prefab");
GameObject prefabGameObject = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath); foreach (var asset in prefabAssets) {
if (SpineEditorUtilities.CleanupSpinePrefabMesh(prefabGameObject)) { string assetPath = AssetDatabase.GUIDToAssetPath(asset);
prefabsToRestore.Add(assetPath); GameObject prefabGameObject = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
if (SpineEditorUtilities.CleanupSpinePrefabMesh(prefabGameObject)) {
prefabsToRestore.Add(assetPath);
}
EditorUtility.UnloadUnusedAssetsImmediate();
} }
EditorUtility.UnloadUnusedAssetsImmediate(); AssetDatabase.StopAssetEditing();
if (prefabAssets.Length > 0)
AssetDatabase.SaveAssets();
} finally {
BuildUtilities.IsInSkeletonAssetBuildPreProcessing = false;
} }
AssetDatabase.StopAssetEditing();
if (prefabAssets.Length > 0)
AssetDatabase.SaveAssets();
} }
internal static void PostprocessSpinePrefabMeshes () { internal static void PostprocessSpinePrefabMeshes () {
foreach (string assetPath in prefabsToRestore) { BuildUtilities.IsInSkeletonAssetBuildPostProcessing = true;
GameObject g = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath); try {
SpineEditorUtilities.SetupSpinePrefabMesh(g, null); foreach (string assetPath in prefabsToRestore) {
GameObject g = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
SpineEditorUtilities.SetupSpinePrefabMesh(g, null);
}
if (prefabsToRestore.Count > 0)
AssetDatabase.SaveAssets();
prefabsToRestore.Clear();
} finally {
BuildUtilities.IsInSkeletonAssetBuildPostProcessing = false;
} }
if (prefabsToRestore.Count > 0)
AssetDatabase.SaveAssets();
prefabsToRestore.Clear();
} }
#endif #endif
internal static void PreprocessSpriteAtlases () { internal static void PreprocessSpriteAtlases () {
AssetDatabase.StartAssetEditing(); BuildUtilities.IsInSpriteAtlasBuildPreProcessing = true;
spriteAtlasTexturesToRestore.Clear(); try {
var spriteAtlasAssets = AssetDatabase.FindAssets("t:SpineSpriteAtlasAsset"); AssetDatabase.StartAssetEditing();
foreach (var asset in spriteAtlasAssets) { spriteAtlasTexturesToRestore.Clear();
string assetPath = AssetDatabase.GUIDToAssetPath(asset); var spriteAtlasAssets = AssetDatabase.FindAssets("t:SpineSpriteAtlasAsset");
SpineSpriteAtlasAsset atlasAsset = AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(assetPath); foreach (var asset in spriteAtlasAssets) {
if (atlasAsset && atlasAsset.materials.Length > 0) { string assetPath = AssetDatabase.GUIDToAssetPath(asset);
spriteAtlasTexturesToRestore[assetPath] = AssetDatabase.GetAssetPath(atlasAsset.materials[0].mainTexture); SpineSpriteAtlasAsset atlasAsset = AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(assetPath);
atlasAsset.materials[0].mainTexture = null; if (atlasAsset && atlasAsset.materials.Length > 0) {
spriteAtlasTexturesToRestore[assetPath] = AssetDatabase.GetAssetPath(atlasAsset.materials[0].mainTexture);
atlasAsset.materials[0].mainTexture = null;
}
EditorUtility.UnloadUnusedAssetsImmediate();
} }
EditorUtility.UnloadUnusedAssetsImmediate(); AssetDatabase.StopAssetEditing();
if (spriteAtlasAssets.Length > 0)
AssetDatabase.SaveAssets();
} finally {
BuildUtilities.IsInSpriteAtlasBuildPreProcessing = false;
} }
AssetDatabase.StopAssetEditing();
if (spriteAtlasAssets.Length > 0)
AssetDatabase.SaveAssets();
} }
internal static void PostprocessSpriteAtlases () { internal static void PostprocessSpriteAtlases () {
foreach (var pair in spriteAtlasTexturesToRestore) { BuildUtilities.IsInSpriteAtlasBuildPostProcessing = true;
string assetPath = pair.Key; try {
SpineSpriteAtlasAsset atlasAsset = AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(assetPath); foreach (var pair in spriteAtlasTexturesToRestore) {
if (atlasAsset && atlasAsset.materials.Length > 0) { string assetPath = pair.Key;
Texture atlasTexture = AssetDatabase.LoadAssetAtPath<Texture>(pair.Value); SpineSpriteAtlasAsset atlasAsset = AssetDatabase.LoadAssetAtPath<SpineSpriteAtlasAsset>(assetPath);
atlasAsset.materials[0].mainTexture = atlasTexture; if (atlasAsset && atlasAsset.materials.Length > 0) {
Texture atlasTexture = AssetDatabase.LoadAssetAtPath<Texture>(pair.Value);
atlasAsset.materials[0].mainTexture = atlasTexture;
}
} }
if (spriteAtlasTexturesToRestore.Count > 0)
AssetDatabase.SaveAssets();
spriteAtlasTexturesToRestore.Clear();
} finally {
BuildUtilities.IsInSpriteAtlasBuildPostProcessing = false;
} }
if (spriteAtlasTexturesToRestore.Count > 0)
AssetDatabase.SaveAssets();
spriteAtlasTexturesToRestore.Clear();
} }
} }

5
spine-unity/Assets/Spine/Runtime/spine-unity/Asset Types/SpineAtlasAsset.cs
View File

@ -251,6 +251,11 @@ namespace Spine.Unity {
} }
public void Load (AtlasPage page, string path) { public void Load (AtlasPage page, string path) {
#if UNITY_EDITOR
if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing ||
BuildUtilities.IsInSkeletonAssetBuildPostProcessing)
return;
#endif
String name = Path.GetFileNameWithoutExtension(path); String name = Path.GetFileNameWithoutExtension(path);
Material material = null; Material material = null;
foreach (Material other in atlasAsset.materials) { foreach (Material other in atlasAsset.materials) {

4
spine-unity/Assets/Spine/Runtime/spine-unity/Components/SkeletonAnimation.cs
View File

@ -169,6 +169,10 @@ namespace Spine.Unity {
public override void Initialize (bool overwrite, bool quiet = false) { public override void Initialize (bool overwrite, bool quiet = false) {
if (valid && !overwrite) if (valid && !overwrite)
return; return;
#if UNITY_EDITOR
if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing)
return;
#endif
base.Initialize(overwrite, quiet); base.Initialize(overwrite, quiet);
if (!valid) if (!valid)

5
spine-unity/Assets/Spine/Runtime/spine-unity/Components/SkeletonGraphic.cs
View File

@ -525,7 +525,10 @@ namespace Spine.Unity {
public void Initialize (bool overwrite) { public void Initialize (bool overwrite) {
if (this.IsValid && !overwrite) return; if (this.IsValid && !overwrite) return;
#if UNITY_EDITOR
if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing)
return;
#endif
if (this.skeletonDataAsset == null) return; if (this.skeletonDataAsset == null) return;
var skeletonData = this.skeletonDataAsset.GetSkeletonData(false); var skeletonData = this.skeletonDataAsset.GetSkeletonData(false);
if (skeletonData == null) return; if (skeletonData == null) return;

5
spine-unity/Assets/Spine/Runtime/spine-unity/Components/SkeletonMecanim.cs
View File

@ -75,7 +75,10 @@ namespace Spine.Unity {
public override void Initialize (bool overwrite, bool quiet = false) { public override void Initialize (bool overwrite, bool quiet = false) {
if (valid && !overwrite) if (valid && !overwrite)
return; return;
#if UNITY_EDITOR
if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing)
return;
#endif
base.Initialize(overwrite, quiet); base.Initialize(overwrite, quiet);
if (!valid) if (!valid)

5
spine-unity/Assets/Spine/Runtime/spine-unity/Components/SkeletonRenderer.cs
View File

@ -367,7 +367,10 @@ namespace Spine.Unity {
public virtual void Initialize (bool overwrite, bool quiet = false) { public virtual void Initialize (bool overwrite, bool quiet = false) {
if (valid && !overwrite) if (valid && !overwrite)
return; return;
#if UNITY_EDITOR
if (BuildUtilities.IsInSkeletonAssetBuildPreProcessing)
return;
#endif
// Clear // Clear
{ {
// Note: do not reset meshFilter.sharedMesh or meshRenderer.sharedMaterial to null, // Note: do not reset meshFilter.sharedMesh or meshRenderer.sharedMaterial to null,

42
spine-unity/Assets/Spine/Runtime/spine-unity/Utility/BuildUtilities.cs Normal file
View File

@ -0,0 +1,42 @@
/******************************************************************************
* Spine Runtimes License Agreement
* Last updated January 1, 2020. Replaces all prior versions.
*
* Copyright (c) 2013-2022, Esoteric Software LLC
*
* Integration of the Spine Runtimes into software or otherwise creating
* derivative works of the Spine Runtimes is permitted under the terms and
* conditions of Section 2 of the Spine Editor License Agreement:
* http://esotericsoftware.com/spine-editor-license
*
* Otherwise, it is permitted to integrate the Spine Runtimes into software
* or otherwise create derivative works of the Spine Runtimes (collectively,
* "Products"), provided that each user of the Products must obtain their own
* Spine Editor license and redistribution of the Products in any form must
* include this license and copyright notice.
*
* THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
* BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*****************************************************************************/
#if UNITY_EDITOR
namespace Spine.Unity {
public static class BuildUtilities {
public static bool IsInSkeletonAssetBuildPreProcessing = false;
public static bool IsInSkeletonAssetBuildPostProcessing = false;
public static bool IsInSpriteAtlasBuildPreProcessing = false;
public static bool IsInSpriteAtlasBuildPostProcessing = false;
}
}
#endif

11
spine-unity/Assets/Spine/Runtime/spine-unity/Utility/BuildUtilities.cs.meta Normal file
View File

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a2f1169aaf0063f4da1c2b6033bbc13f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: