Merge branch '4.1' into 4.2-beta

spine-ts/spine-webgl/src/Shader.ts

@@ -194,106 +194,106 @@ export class Shader implements Disposable, Restorable {
 
 	public static newColoredTextured (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
 		let vs = `
-				attribute vec4 ${Shader.POSITION};
-				attribute vec4 ${Shader.COLOR};
-				attribute vec2 ${Shader.TEXCOORDS};
-				uniform mat4 ${Shader.MVP_MATRIX};
-				varying vec4 v_color;
-				varying vec2 v_texCoords;
-
-				void main () {
-					v_color = ${Shader.COLOR};
-					v_texCoords = ${Shader.TEXCOORDS};
-					gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
-				}
-			`;
+attribute vec4 ${Shader.POSITION};
+attribute vec4 ${Shader.COLOR};
+attribute vec2 ${Shader.TEXCOORDS};
+uniform mat4 ${Shader.MVP_MATRIX};
+varying vec4 v_color;
+varying vec2 v_texCoords;
+
+void main () {
+	v_color = ${Shader.COLOR};
+	v_texCoords = ${Shader.TEXCOORDS};
+	gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
+}
+`;
 
 		let fs = `
-				#ifdef GL_ES
-					#define LOWP lowp
-					precision mediump float;
-				#else
-					#define LOWP
-				#endif
-				varying LOWP vec4 v_color;
-				varying vec2 v_texCoords;
-				uniform sampler2D u_texture;
-
-				void main () {
-					gl_FragColor = v_color * texture2D(u_texture, v_texCoords);
-				}
-			`;
+#ifdef GL_ES
+	#define LOWP lowp
+	precision mediump float;
+#else
+	#define LOWP
+#endif
+varying LOWP vec4 v_color;
+varying vec2 v_texCoords;
+uniform sampler2D u_texture;
+
+void main () {
+	gl_FragColor = v_color * texture2D(u_texture, v_texCoords);
+}
+`;
 
 		return new Shader(context, vs, fs);
 	}
 
 	public static newTwoColoredTextured (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
 		let vs = `
-				attribute vec4 ${Shader.POSITION};
-				attribute vec4 ${Shader.COLOR};
-				attribute vec4 ${Shader.COLOR2};
-				attribute vec2 ${Shader.TEXCOORDS};
-				uniform mat4 ${Shader.MVP_MATRIX};
-				varying vec4 v_light;
-				varying vec4 v_dark;
-				varying vec2 v_texCoords;
-
-				void main () {
-					v_light = ${Shader.COLOR};
-					v_dark = ${Shader.COLOR2};
-					v_texCoords = ${Shader.TEXCOORDS};
-					gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
-				}
-			`;
+attribute vec4 ${Shader.POSITION};
+attribute vec4 ${Shader.COLOR};
+attribute vec4 ${Shader.COLOR2};
+attribute vec2 ${Shader.TEXCOORDS};
+uniform mat4 ${Shader.MVP_MATRIX};
+varying vec4 v_light;
+varying vec4 v_dark;
+varying vec2 v_texCoords;
+
+void main () {
+	v_light = ${Shader.COLOR};
+	v_dark = ${Shader.COLOR2};
+	v_texCoords = ${Shader.TEXCOORDS};
+	gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
+}
+`;
 
 		let fs = `
-				#ifdef GL_ES
-					#define LOWP lowp
-					precision mediump float;
-				#else
-					#define LOWP
-				#endif
-				varying LOWP vec4 v_light;
-				varying LOWP vec4 v_dark;
-				varying vec2 v_texCoords;
-				uniform sampler2D u_texture;
-
-				void main () {
-					vec4 texColor = texture2D(u_texture, v_texCoords);
-					gl_FragColor.a = texColor.a * v_light.a;
-					gl_FragColor.rgb = ((texColor.a - 1.0) * v_dark.a + 1.0 - texColor.rgb) * v_dark.rgb + texColor.rgb * v_light.rgb;
-				}
-			`;
+#ifdef GL_ES
+	#define LOWP lowp
+	precision mediump float;
+#else
+	#define LOWP
+#endif
+varying LOWP vec4 v_light;
+varying LOWP vec4 v_dark;
+varying vec2 v_texCoords;
+uniform sampler2D u_texture;
+
+void main () {
+	vec4 texColor = texture2D(u_texture, v_texCoords);
+	gl_FragColor.a = texColor.a * v_light.a;
+	gl_FragColor.rgb = ((texColor.a - 1.0) * v_dark.a + 1.0 - texColor.rgb) * v_dark.rgb + texColor.rgb * v_light.rgb;
+}
+`;
 
 		return new Shader(context, vs, fs);
 	}
 
 	public static newColored (context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader {
 		let vs = `
-				attribute vec4 ${Shader.POSITION};
-				attribute vec4 ${Shader.COLOR};
-				uniform mat4 ${Shader.MVP_MATRIX};
-				varying vec4 v_color;
-
-				void main () {
-					v_color = ${Shader.COLOR};
-					gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
-				}
-			`;
+attribute vec4 ${Shader.POSITION};
+attribute vec4 ${Shader.COLOR};
+uniform mat4 ${Shader.MVP_MATRIX};
+varying vec4 v_color;
+
+void main () {
+	v_color = ${Shader.COLOR};
+	gl_Position = ${Shader.MVP_MATRIX} * ${Shader.POSITION};
+}
+`;
 
 		let fs = `
-				#ifdef GL_ES
-					#define LOWP lowp
-					precision mediump float;
-				#else
-					#define LOWP
-				#endif
-				varying LOWP vec4 v_color;
-
-				void main () {
-					gl_FragColor = v_color;
-				}
-			`;
+#ifdef GL_ES
+	#define LOWP lowp
+	precision mediump float;
+#else
+	#define LOWP
+#endif
+varying LOWP vec4 v_color;
+
+void main () {
+	gl_FragColor = v_color;
+}
+`;
 
 		return new Shader(context, vs, fs);
 	}

spine-ue4/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineSkeletonRendererComponent.cpp

@@ -135,7 +135,6 @@ void USpineSkeletonRendererComponent::UpdateMaterial(UTexture2D *Texture, UMater
 		material->SetTextureParameterValue(TextureParameterName, Texture);
 		CurrentInstance = material;
 	}
-	
 }
 
 void USpineSkeletonRendererComponent::Flush(int &Idx, TArray<FVector> &Vertices, TArray<int32> &Indices, TArray<FVector> &Normals, TArray<FVector2D> &Uvs, TArray<FColor> &Colors, UMaterialInstanceDynamic *Material) {
@@ -167,13 +166,13 @@ void USpineSkeletonRendererComponent::UpdateMesh(USpineSkeletonComponent *compon
 	normals.Empty();
 	uvs.Empty();
 	colors.Empty();
-	
+
 	int idx = 0;
 	int meshSection = 0;
 	UMaterialInstanceDynamic *lastMaterial = nullptr;
 
 	ClearAllMeshSections();
-	
+
 	// Early out if skeleton is invisible
 	if (Skeleton->getColor().a == 0) return;
 
@@ -226,13 +225,13 @@ void USpineSkeletonRendererComponent::UpdateMesh(USpineSkeletonComponent *compon
 			numIndices = 6;
 		} else if (attachment->getRTTI().isExactly(MeshAttachment::rtti)) {
 			MeshAttachment *mesh = (MeshAttachment *) attachment;
-			
+
 			// Early out if region is invisible
 			if (mesh->getColor().a == 0) {
 				clipper.clipEnd(*slot);
 				continue;
 			}
-			
+
 			attachmentColor.set(mesh->getColor());
 			attachmentVertices->setSize(mesh->getWorldVerticesLength(), 0);
 			mesh->computeWorldVertices(*slot, 0, mesh->getWorldVerticesLength(), attachmentVertices->buffer(), 0, 2);
@@ -259,14 +258,14 @@ void USpineSkeletonRendererComponent::UpdateMesh(USpineSkeletonComponent *compon
 				continue;
 			}
 		}
-		
+
 		// if the user switches the atlas data while not having switched
 		// to the correct skeleton data yet, we won't find any regions.
 		// ignore regions for which we can't find a material
-		UMaterialInstanceDynamic* material = nullptr;
+		UMaterialInstanceDynamic *material = nullptr;
 		int foundPageIndex = -1;
 		for (int pageIndex = 0; i < component->Atlas->atlasPages.Num(); pageIndex++) {
-			AtlasPage* page = component->Atlas->GetAtlas()->getPages()[pageIndex];
+			AtlasPage *page = component->Atlas->GetAtlas()->getPages()[pageIndex];
 			if (attachmentAtlasRegion->page == page) {
 				foundPageIndex = pageIndex;
 				break;
@@ -277,74 +276,74 @@ void USpineSkeletonRendererComponent::UpdateMesh(USpineSkeletonComponent *compon
 			continue;
 		}
 		switch (slot->getData().getBlendMode()) {
-		case BlendMode_Additive:
-			if (i >= atlasAdditiveBlendMaterials.Num()) {
-				clipper.clipEnd(*slot);
-				continue;
-			}
-			material = atlasAdditiveBlendMaterials[i];
-			break;
-		case BlendMode_Multiply:
-			if (i >= atlasMultiplyBlendMaterials.Num()) {
-				clipper.clipEnd(*slot);
-				continue;
-			}
-			material = atlasMultiplyBlendMaterials[i];
-			break;
-		case BlendMode_Screen:
-			if (i >= atlasScreenBlendMaterials.Num()) {
-				clipper.clipEnd(*slot);
-				continue;
-			}
-			material = atlasScreenBlendMaterials[i];
-			break;
-		case BlendMode_Normal:
-		default:
-			if (i >= atlasNormalBlendMaterials.Num()) {
-				clipper.clipEnd(*slot);
-				continue;
-			}
-			material = atlasNormalBlendMaterials[i];
-			break;
+			case BlendMode_Additive:
+				if (i >= atlasAdditiveBlendMaterials.Num()) {
+					clipper.clipEnd(*slot);
+					continue;
+				}
+				material = atlasAdditiveBlendMaterials[i];
+				break;
+			case BlendMode_Multiply:
+				if (i >= atlasMultiplyBlendMaterials.Num()) {
+					clipper.clipEnd(*slot);
+					continue;
+				}
+				material = atlasMultiplyBlendMaterials[i];
+				break;
+			case BlendMode_Screen:
+				if (i >= atlasScreenBlendMaterials.Num()) {
+					clipper.clipEnd(*slot);
+					continue;
+				}
+				material = atlasScreenBlendMaterials[i];
+				break;
+			case BlendMode_Normal:
+			default:
+				if (i >= atlasNormalBlendMaterials.Num()) {
+					clipper.clipEnd(*slot);
+					continue;
+				}
+				material = atlasNormalBlendMaterials[i];
+				break;
 		}
-		
+
 		if (lastMaterial != material) {
 			Flush(meshSection, vertices, indices, normals, uvs, colors, lastMaterial);
 			lastMaterial = material;
 			idx = 0;
 		}
-		
+
 		SetMaterial(meshSection, material);
-		
+
 		uint8 r = static_cast<uint8>(Skeleton->getColor().r * slot->getColor().r * attachmentColor.r * 255);
 		uint8 g = static_cast<uint8>(Skeleton->getColor().g * slot->getColor().g * attachmentColor.g * 255);
 		uint8 b = static_cast<uint8>(Skeleton->getColor().b * slot->getColor().b * attachmentColor.b * 255);
 		uint8 a = static_cast<uint8>(Skeleton->getColor().a * slot->getColor().a * attachmentColor.a * 255);
-		
-		float* verticesPtr = attachmentVertices->buffer();
+
+		float *verticesPtr = attachmentVertices->buffer();
 		for (int j = 0; j < numVertices << 1; j += 2) {
 			colors.Add(FColor(r, g, b, a));
 			vertices.Add(FVector(verticesPtr[j], depthOffset, verticesPtr[j + 1]));
 			uvs.Add(FVector2D(attachmentUvs[j], attachmentUvs[j + 1]));
 		}
-		
+
 		for (int j = 0; j < numIndices; j++) {
 			indices.Add(idx + attachmentIndices[j]);
 		}
-		
+
 		int numTriangles = indices.Num() / 3;
 		for (int j = 0; j < numTriangles; j++) {
 			const int triangleIndex = j * 3;
 			if (FVector::CrossProduct(
-					vertices[indices[triangleIndex + 2]] - vertices[indices[triangleIndex]],
-					vertices[indices[triangleIndex + 1]] - vertices[indices[triangleIndex]])
-				.Y < 0.f) {
+						vertices[indices[triangleIndex + 2]] - vertices[indices[triangleIndex]],
+						vertices[indices[triangleIndex + 1]] - vertices[indices[triangleIndex]])
+						.Y < 0.f) {
 				const int32 targetVertex = indices[triangleIndex];
 				indices[triangleIndex] = indices[triangleIndex + 2];
 				indices[triangleIndex + 2] = targetVertex;
 			}
 		}
-		
+
 		FVector normal = FVector(0, 1, 0);
 		for (int j = 0; j < numVertices; j++) {
 			normals.Add(normal);

spine-ue4/Plugins/SpinePlugin/Source/SpinePlugin/Private/SpineWidget.cpp

@@ -331,12 +331,12 @@ bool USpineWidget::HasBone(const FString BoneName) {
 	return false;
 }
 
-FTransform USpineWidget::GetBoneTransform(const FString& BoneName) {
+FTransform USpineWidget::GetBoneTransform(const FString &BoneName) {
 	CheckState();
 	if (skeleton) {
 		Bone *bone = skeleton->findBone(TCHAR_TO_UTF8(*BoneName));
 		if (!bone) return FTransform();
-		
+
 		FMatrix localTransform;
 		localTransform.SetIdentity();
 		localTransform.SetAxis(2, FVector(bone->getA(), 0, bone->getC()));

spine-ue4/Plugins/SpinePlugin/Source/SpinePlugin/Public/SpineSkeletonRendererComponent.h

@@ -99,15 +99,15 @@ protected:
 
 	spine::Vector<float> worldVertices;
 	spine::SkeletonClipping clipper;
-	
+
 	UPROPERTY();
 	TArray<FVector> vertices;
 	UPROPERTY();
-    TArray<int32> indices;
-    UPROPERTY();
-    TArray<FVector> normals;
-    UPROPERTY();
-    TArray<FVector2D> uvs;
-    UPROPERTY();
-    TArray<FColor> colors;
+	TArray<int32> indices;
+	UPROPERTY();
+	TArray<FVector> normals;
+	UPROPERTY();
+	TArray<FVector2D> uvs;
+	UPROPERTY();
+	TArray<FColor> colors;
 };

spine-unity/Modules/com.esotericsoftware.spine.urp-shaders/Shaders/2D/Include/Spine-Sprite-StandardPass-URP-2D.hlsl

@@ -101,7 +101,7 @@ half4 CombinedShapeLightFragment(VertexOutputSpriteURP2D input) : SV_Target
 	surfaceData.albedo = main.rgb;
 	surfaceData.alpha = 1;
 	surfaceData.mask = mask;
-	inputData.uv = input.texcoord;
+	inputData.uv = input.texcoord.xy;
 	inputData.lightingUV = input.lightingUV;
 	half4 pixel = half4(CombinedShapeLightShared(surfaceData, inputData).rgb * main.a, main.a);
 #endif

spine-unity/Modules/com.esotericsoftware.spine.urp-shaders/Shaders/Include/Spine-SkeletonLit-ForwardPass-URP.hlsl

@@ -65,7 +65,7 @@ half3 LightweightLightVertexSimplified(float3 positionWS, half3 normalWS, out ha
 		additionalLightColor += ProcessLight(positionWS, normalWS, meshRenderingLayers, lightIndex);
 	}
 #else // !USE_FORWARD_PLUS
-	int pixelLightCount = GetAdditionalLightsCount();
+	uint pixelLightCount = GetAdditionalLightsCount();
 	LIGHT_LOOP_BEGIN_SPINE(pixelLightCount)
 		additionalLightColor += ProcessLight(positionWS, normalWS, meshRenderingLayers, lightIndex);
 	LIGHT_LOOP_END_SPINE
@@ -84,9 +84,9 @@ half3 LightweightLightFragmentSimplified(float3 positionWS, float2 positionCS, h
 	InputData inputData; // LIGHT_LOOP_BEGIN macro requires InputData struct in USE_FORWARD_PLUS branch
 	inputData.positionWS = positionWS;
 	inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(positionCS);
-	
+
 	uint meshRenderingLayers = GetMeshRenderingLayerBackwardsCompatible();
-	int pixelLightCount = GetAdditionalLightsCount();
+	uint pixelLightCount = GetAdditionalLightsCount();
 	LIGHT_LOOP_BEGIN_SPINE(pixelLightCount)
 		additionalLightColor += ProcessLight(positionWS, normalWS, meshRenderingLayers, lightIndex);
 	LIGHT_LOOP_END_SPINE
@@ -124,7 +124,7 @@ VertexOutput vert(appdata v) {
 	if (color.a == 0) {
 		o.color = color;
 #if defined(SKELETONLIT_RECEIVE_SHADOWS)
-		o.shadowedColor = color;
+		o.shadowedColor = color.rgb;
 		o.shadowCoord = float4(0, 0, 0, 0);
 #endif
 		return o;
@@ -169,9 +169,11 @@ half4 frag(VertexOutput i
 	// USE_FORWARD_PLUS lights need to be processed in fragment shader,
 	// otherwise light culling by vertex will create a very bad lighting result.
 	half3 shadowedColor;
-	i.color.rgb += LightweightLightFragmentSimplified(i.positionWS, i.pos, i.normalWS, shadowedColor);
+	i.color.rgb += LightweightLightFragmentSimplified(i.positionWS, i.pos.xy, i.normalWS, shadowedColor);
+#if defined(SKELETONLIT_RECEIVE_SHADOWS)
 	i.shadowedColor += shadowedColor;
 #endif
+#endif
 
 #if defined(SKELETONLIT_RECEIVE_SHADOWS)
 	half shadowAttenuation = MainLightRealtimeShadow(i.shadowCoord);

spine-unity/Modules/com.esotericsoftware.spine.urp-shaders/Shaders/Include/Spine-Sprite-ForwardPass-URP.hlsl

@@ -131,7 +131,7 @@ half4 LightweightFragmentPBRSimplified(InputData inputData, half4 texAlbedoAlpha
 
 #ifdef _ADDITIONAL_LIGHTS
 	uint meshRenderingLayers = GetMeshRenderingLayerBackwardsCompatible();
-	
+
 #if defined(_ADDITIONAL_LIGHT_SHADOWS) && !defined(_RECEIVE_SHADOWS_OFF)
 	half4 shadowMask = CalculateShadowMaskBackwardsCompatible(inputData);
 #else
@@ -145,7 +145,7 @@ half4 LightweightFragmentPBRSimplified(InputData inputData, half4 texAlbedoAlpha
 		finalColor += ProcessLightPBRSimplified(inputData, brdfData, shadowMask, meshRenderingLayers, lightIndex);
 	}
 #endif
-	int pixelLightCount = GetAdditionalLightsCount();
+	uint pixelLightCount = GetAdditionalLightsCount();
 	LIGHT_LOOP_BEGIN_SPINE(pixelLightCount)
 		finalColor += ProcessLightPBRSimplified(inputData, brdfData, shadowMask, meshRenderingLayers, lightIndex);
 	LIGHT_LOOP_END_SPINE
@@ -221,11 +221,11 @@ half4 LightweightFragmentBlinnPhongSimplified(InputData inputData, half4 texDiff
 		diffuseLighting += ProcessLightLambert(inputData, shadowMask, meshRenderingLayers, lightIndex);
 	}
 #endif
-	int pixelLightCount = GetAdditionalLightsCount();
+	uint pixelLightCount = GetAdditionalLightsCount();
 	LIGHT_LOOP_BEGIN(pixelLightCount)
 		diffuseLighting += ProcessLightLambert(inputData, shadowMask, meshRenderingLayers, lightIndex);
 	LIGHT_LOOP_END
-    
+
 #endif
 #ifdef _ADDITIONAL_LIGHTS_VERTEX
 	diffuseLighting += inputData.vertexLighting;
@@ -329,7 +329,7 @@ half4 ForwardPassFragmentSprite(VertexOutputLWRP input
 #else
 	inputData.normalizedScreenSpaceUV = 0;
 #endif
-	
+
 #if defined(SPECULAR)
 	half2 metallicGloss = getMetallicGloss(input.texcoord.xy);
 	half metallic = metallicGloss.x;

spine-unity/Modules/com.esotericsoftware.spine.urp-shaders/package.json

@@ -2,7 +2,7 @@
   "name": "com.esotericsoftware.spine.urp-shaders",
   "displayName": "Spine Universal RP Shaders",
   "description": "This plugin provides universal render pipeline (URP) shaders for the spine-unity runtime.\n\nPrerequisites:\nIt requires a working installation of the spine-unity runtime, version 4.1.\n(See http://esotericsoftware.com/git/spine-runtimes/spine-unity)",
-  "version": "4.1.8",
+  "version": "4.1.9",
   "unity": "2019.3",
   "author": {
     "name": "Esoteric Software",