RobiiAragon/FueraDeEscala
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Game Kit Controller assets

Browse Source 
Bulk modifications across the Game Kit Controller package: updated materials and shader, adjusted particle prefabs, and numerous prefab updates for Character Customization, Inventory, Map System, Locked Camera System, Probuilder export objects, Gravity, Health, Mission System and other scene elements. These changes appear to be a large asset rework/reimport or parameter/reference updates to keep prefabs and materials in sync.
This commit is contained in:
Robii Aragon
2026-03-27 23:57:08 -07:00
parent 5218513a22
commit 0777676dbd
426 changed files with 1849 additions and 2082 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
Assets/Game Kit Controller/Shaders/Dissolve.shader
View File

@@ -1,79 +1,59 @@
Shader "Custom/URP_Dissolve"
Shader "Custom/Dissolve"
{
Properties {
_Color ("Color", Color) = (1,1,1,1)
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
_DissolveTexture("Dissolve Texture", 2D) = "white" {}
_DissolveTexture("Dissolve Texture", 2D) = "white" {}
_Amount("Amount", Range(0,1)) = 0
_DissolveColor ("Dissolve Color", Color) = (1,1,1,1)
_DissolveColor ("Disolve Color", Color) = (1,1,1,1)
_DissolveColorAlpha ("Dissolve Color Alpha", Range(0,1)) = 0.0
}
SubShader {
Tags { "RenderType"="Opaque" }
LOD 200
Cull Off
Pass {
Name "FORWARD"
Tags { "LightMode" = "UniversalForward" }
CGPROGRAM
#pragma surface surf Standard fullforwardshadows
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#pragma target 3.0
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
};
sampler2D _MainTex;
struct Varyings {
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float fogFactor : TEXCOORD1;
};
struct Input {
float2 uv_MainTex;
};
CBUFFER_START(UnityPerMaterial)
float4 _Color;
float _Glossiness;
float _Metallic;
float4 _DissolveColor;
float _DissolveColorAlpha;
float _Amount;
CBUFFER_END
half _Glossiness;
half _Metallic;
fixed4 _Color;
fixed3 _DissolveColor;
half _DissolveColorAlpha;
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
TEXTURE2D(_DissolveTexture); SAMPLER(sampler_DissolveTexture);
//Dissolve properties
sampler2D _DissolveTexture;
half _Amount;
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
void surf (Input IN, inout SurfaceOutputStandard o) {
float4 frag(Varyings IN) : SV_Target
{
float dissolve_value = SAMPLE_TEXTURE2D(_DissolveTexture, sampler_DissolveTexture, IN.uv).r;
clip(dissolve_value - _Amount);
//Dissolve function
half dissolve_value = tex2D(_DissolveTexture, IN.uv_MainTex).r;
clip(dissolve_value - _Amount);
float4 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv) * _Color;
//Basic shader function
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
// Simple metallic/smoothness (not PBR, but for effect)
float3 emission = _DissolveColor.rgb * step(dissolve_value - _Amount, _DissolveColorAlpha);
float3 color = albedo.rgb + emission;
float alpha = albedo.a;
color = MixFog(color, IN.fogFactor);
return float4(color, alpha);
}
ENDHLSL
o.Albedo = c.rgb;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
o.Emission = fixed3(_DissolveColor.r, _DissolveColor.g, _DissolveColor.b) * step( dissolve_value - _Amount, _DissolveColorAlpha); //emits white color with 0.05 border size
}
ENDCG
}
FallBack "Universal Forward"
FallBack "Diffuse"
}

18
Assets/Game Kit Controller/Shaders/Foot Dust Particles.mat
View File

@@ -2,24 +2,19 @@
%TAG !u! tag:unity3d.com,2011:
--- !u!21 &2100000
Material:
serializedVersion: 8
serializedVersion: 6
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_Name: Foot Dust Particles
m_Shader: {fileID: 203, guid: 0000000000000000f000000000000000, type: 0}
m_Parent: {fileID: 0}
m_ModifiedSerializedProperties: 0
m_ValidKeywords: []
m_InvalidKeywords: []
m_ShaderKeywords:
m_LightmapFlags: 4
m_EnableInstancingVariants: 0
m_DoubleSidedGI: 0
m_CustomRenderQueue: -1
stringTagMap: {}
disabledShaderPasses: []
m_LockedProperties:
m_SavedProperties:
serializedVersion: 3
m_TexEnvs:
@@ -59,7 +54,6 @@ Material:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
m_Ints: []
m_Floats:
- _BumpScale: 1
- _Cutoff: 0.5
@@ -81,6 +75,4 @@ Material:
m_Colors:
- _Color: {r: 1, g: 1, b: 1, a: 1}
- _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
- _TintColor: {r: 0.3490566, g: 0.3490566, b: 0.3490566, a: 0.5}
m_BuildTextureStacks: []
m_AllowLocking: 1
- _TintColor: {r: 0.74264705, g: 0.5023789, b: 0.5023789, a: 0.5}

132
Assets/Game Kit Controller/Shaders/Glow Shader.shader
View File

@@ -1,73 +1,61 @@
Shader "Custom/URP_GlowShader"
{
Properties {
_Color ("Color", Color) = (1,1,1,1)
_Size ("Atmosphere Size Multiplier", Range(0,16)) = 4
_Rim ("Fade Power", Range(0,8)) = 4
_Light ("Lighting Power", Range(0,10)) = 1.4
_Ambient ("Ambient Power", Range (0,6)) = 0.8
}
SubShader {
Tags { "RenderType"="Transparent" }
LOD 200
Cull Front
Pass {
Name "FORWARD"
Tags { "LightMode" = "UniversalForward" }
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
float3 normalOS : NORMAL;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float3 normalWS : TEXCOORD0;
float3 viewDirWS : TEXCOORD1;
float fogFactor : TEXCOORD2;
};
CBUFFER_START(UnityPerMaterial)
float4 _Color;
float _Size;
float _Rim;
float _Light;
float _Ambient;
CBUFFER_END
Varyings vert(Attributes IN)
{
Varyings OUT;
float3 scaled = IN.positionOS.xyz + IN.positionOS.xyz * (_Size / 10.0);
OUT.positionHCS = TransformObjectToHClip(scaled);
float3 normalWS = TransformObjectToWorldNormal(-IN.normalOS); // Invert normal
OUT.normalWS = normalWS;
OUT.viewDirWS = normalize(_WorldSpaceCameraPos - TransformObjectToWorld(scaled));
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
float4 frag(Varyings IN) : SV_Target
{
float rim = saturate(dot(normalize(IN.viewDirWS), IN.normalWS));
float alpha = lerp(0, 1, pow(rim, _Rim));
// Lighting: simple negative lambert
float3 lightDir = normalize(_MainLightPosition.xyz);
float diff = max(0, dot(-IN.normalWS, lightDir)) * _Light + _Ambient;
float3 color = _Color.rgb * _MainLightColor.rgb * diff;
color = MixFog(color, IN.fogFactor);
return float4(color, alpha * _Color.a);
}
ENDHLSL
}
}
FallBack "Universal Forward"
Shader "Custom/Glow Shader" {
Properties {
_Color ("Color", Color) = (1,1,1,1)
_Size ("Atmosphere Size Multiplier", Range(0,16)) = 4
_Rim ("Fade Power", Range(0,8)) = 4
_Light ("Lighting Power", Range(0,10)) = 1.4
_Ambient ("Ambient Power", Range (0,6)) = 0.8
}
SubShader {
Tags { "RenderType"="Transparent" }
LOD 200
Cull Front
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf NegativeLambert fullforwardshadows alpha:fade
#pragma vertex vert
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
struct Input {
float3 viewDir;
};
half _Size;
half _Rim;
half _Light;
half _Ambient;
fixed4 _Color;
void vert (inout appdata_full v) {
v.vertex.xyz += v.vertex.xyz * _Size / 10;
v.normal *= -1;
}
half4 LightingNegativeLambert (SurfaceOutput s, half3 lightDir, half3 viewDir, half atten) {
s.Normal = normalize (s.Normal);
half diff = max (0, dot (-s.Normal, lightDir)) * _Light + _Ambient;
half4 c;
c.rgb = (s.Albedo * _LightColor0 * diff) * atten;
c.a = s.Alpha;
return c;
}
void surf (Input IN, inout SurfaceOutput o) {
half rim = saturate (dot (normalize (IN.viewDir), o.Normal));
// Albedo comes from a texture tinted by color
fixed4 c = _Color;
o.Albedo = c.rgb;
o.Alpha = lerp (0, 1, pow (rim, _Rim));
}
ENDCG
}
FallBack "Diffuse"
}

127
Assets/Game Kit Controller/Shaders/Others/Transparent Diffuse Stipple.shader
View File

@@ -1,83 +1,80 @@
Shader "Custom/URP Transparent Diffuse" {
Shader "Custom/Transparent Diffuse Stipple" {
Properties {
_MainTex("Base (RGB)", 2D) = "white" {}
_Color("Main Color", Color) = (1,1,1,1)
_Glossiness("Smoothness", Range(0,1)) = 0.5
_Metallic("Metallic", Range(0,1)) = 0.0
_BumpMap("Normalmap", 2D) = "bump" {}
_MainTex("Base (RGB)", 2D) = "white" { }
_Color("Main Color", Color) = (1, 1, 1, 1)
_Glossiness ("Smoothness", Range(0,1)) = 0.5
_Metallic ("Metallic", Range(0,1)) = 0.0
_BumpMap ("Normalmap", 2D) = "bump" {}
_TransparentAmount("Transparent Amount", Float) = 1
_StippleSize("Stipple Size", Float) = 1
}
SubShader {
Tags { "RenderType"="Transparent" "Queue"="Transparent" }
Tags { "RenderType"="Opaque" }
LOD 200
Cull Off
Blend SrcAlpha OneMinusSrcAlpha
Pass {
Name "FORWARD"
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
float2 uv2 : TEXCOORD1;
float3 normalOS : NORMAL;
float4 tangentOS : TANGENT;
};
CGPROGRAM
#pragma surface surf Standard fullforwardshadows
struct Varyings {
float4 positionCS : SV_POSITION;
float2 uv : TEXCOORD0;
float2 uv2 : TEXCOORD1;
float3 normalWS : TEXCOORD2;
float4 screenPos : TEXCOORD3;
float3 tangentWS : TEXCOORD4;
float3 bitangentWS : TEXCOORD5;
};
#pragma target 3.0
CBUFFER_START(UnityPerMaterial)
float4 _MainTex_ST;
float4 _Color;
float _Glossiness;
float _Metallic;
float _TransparentAmount;
float _StippleSize;
CBUFFER_END
float _TransparentAmount;
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
TEXTURE2D(_BumpMap); SAMPLER(sampler_BumpMap);
sampler2D _MainTex;
Varyings vert(Attributes IN) {
Varyings OUT;
OUT.positionCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
OUT.uv2 = IN.uv2;
OUT.normalWS = TransformObjectToWorldNormal(IN.normalOS);
OUT.tangentWS = TransformObjectToWorldDir(IN.tangentOS.xyz);
OUT.bitangentWS = cross(OUT.normalWS, OUT.tangentWS) * IN.tangentOS.w;
OUT.screenPos = ComputeScreenPos(OUT.positionCS);
return OUT;
}
fixed4 _Color;
float4 frag(Varyings IN) : SV_Target {
float4 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv) * _Color;
float3 normalTS = UnpackNormal(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, IN.uv));
float3x3 TBN = float3x3(normalize(IN.tangentWS), normalize(IN.bitangentWS), normalize(IN.normalWS));
float3 normalWS = mul(normalTS, TBN);
sampler2D _BumpMap;
float alpha = albedo.a * _TransparentAmount;
if (alpha <= 0.01)
discard;
float _StippleSize;
float3 color = albedo.rgb;
return float4(color, alpha);
}
ENDHLSL
half _Glossiness;
half _Metallic;
static const float4x4 kThresholdMatrix = {
1.0 / 17.0, 9.0 / 17.0, 3.0 / 17.0, 11.0 / 17.0,
13.0 / 17.0, 5.0 / 17.0, 15.0 / 17.0, 7.0 / 17.0,
4.0 / 17.0, 12.0 / 17.0, 2.0 / 17.0, 10.0 / 17.0,
16.0 / 17.0, 8.0 / 17.0, 14.0 / 17.0, 6.0 / 17.0
};
static const float4x4 kKernelMatrix = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
struct Input {
float2 uv_MainTex;
float4 screenPos;
float3 worldPos;
float2 uv_BumpMap;
};
void surf (Input IN, inout SurfaceOutputStandard o) {
fixed4 c = tex2D(_MainTex, IN.uv_MainTex)* _Color;
o.Albedo = c.rgb;
o.Alpha = c.a;
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Normal = UnpackNormal (tex2D (_BumpMap, IN.uv_BumpMap));
// Unproject the screen pixel coordiante
float2 pos = IN.screenPos.xy / IN.screenPos.w;
pos *= _ScreenParams.xy * _StippleSize;
// Clip pixel within [start, end] distance from camera
float interpDist = _TransparentAmount;
clip(interpDist - kThresholdMatrix[fmod(pos.x, 4)] * kKernelMatrix[fmod(pos.y, 4)]);
}
ENDCG
}
FallBack "Universal Forward"
FallBack "Diffuse"
}

324
Assets/Game Kit Controller/Shaders/Outlined.shader
View File

@@ -1,223 +1,109 @@
Shader "Custom/URP_Outline_Lit"
{
Properties
{
[Header(Main)]
_MainTex ("Albedo (RGB)", 2D) = "white" {}
_Color ("Base Color", Color) = (1,1,1,1)
Shader "Outlined/Diffuse" {
Properties {
_Color ("Main Color", Color) = (.5,.5,.5,1)
_OutlineColor ("Outline Color", Color) = (0,0,0,1)
_Outline ("Outline width", Range (0, 1)) = .1
_MainTex ("Base (RGB)", 2D) = "white" { }
}
CGINCLUDE
#include "UnityCG.cginc"
struct appdata {
float4 vertex : POSITION;
float3 normal : NORMAL;
};
struct v2f {
float4 pos : POSITION;
float4 color : COLOR;
};
uniform float _Outline;
uniform float4 _OutlineColor;
v2f vert(appdata v) {
// just make a copy of incoming vertex data but scaled according to normal direction
v2f o;
[Header(Outline)]
_OutlineColor ("Outline Color", Color) = (0,0,0,1)
_OutlineWidth ("Outline Width", Range(0, 0.2)) = 0.02
}
v.vertex *= ( 1 + _Outline);
SubShader
{
// CAMBIO 1: Cambiamos a Opaque para que reciba sombras correctamente
Tags
{
"RenderType" = "Opaque"
"RenderPipeline" = "UniversalPipeline"
"Queue" = "Geometry"
}
o.pos = UnityObjectToClipPos(v.vertex);
//float3 norm = normalize(mul ((float3x3)UNITY_MATRIX_IT_MV, v.normal));
//float2 offset = TransformViewToProjection(norm.xy);
// ─────────────────────────────────────────────────────────────
// PASS 1 – Main (Tu código original)
// ─────────────────────────────────────────────────────────────
Pass
{
Name "ForwardLit"
Tags { "LightMode" = "UniversalForward" }
Cull Back
ZWrite On
ZTest LEqual
// CAMBIO 2: Desactivamos la transparencia del material principal
Blend One Zero
// Tu lógica perfecta de Stencil para que el outline no se raye por dentro
Stencil
{
Ref 1
Comp Always
Pass Replace
}
HLSLPROGRAM
#pragma vertex MainVert
#pragma fragment MainFrag
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
#pragma multi_compile_fragment _ _SHADOWS_SOFT
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
CBUFFER_START(UnityPerMaterial)
float4 _MainTex_ST;
float4 _Color;
float4 _OutlineColor;
float _OutlineWidth;
CBUFFER_END
struct Attributes
{
float4 positionOS : POSITION;
float3 normalOS : NORMAL;
float2 uv : TEXCOORD0;
};
struct Varyings
{
float4 positionHCS : SV_POSITION;
float3 positionWS : TEXCOORD1;
float3 normalWS : NORMAL;
float2 uv : TEXCOORD0;
};
Varyings MainVert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.positionWS = TransformObjectToWorld(IN.positionOS.xyz);
OUT.normalWS = TransformObjectToWorldNormal(IN.normalOS);
OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
return OUT;
}
half4 MainFrag(Varyings IN) : SV_Target
{
half4 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv) * _Color;
float4 shadowCoord = TransformWorldToShadowCoord(IN.positionWS);
Light mainLight = GetMainLight(shadowCoord);
half NdotL = saturate(dot(normalize(IN.normalWS), mainLight.direction));
half3 diffuse = mainLight.color * (NdotL * mainLight.shadowAttenuation);
half3 ambient = SampleSH(IN.normalWS);
half3 finalColor = albedo.rgb * (diffuse + ambient);
return half4(finalColor, albedo.a);
}
ENDHLSL
}
// ─────────────────────────────────────────────────────────────
// PASS 2 – ShadowCaster (Para proyectar sombras)
// ─────────────────────────────────────────────────────────────
Pass
{
Name "ShadowCaster"
Tags{"LightMode" = "ShadowCaster"}
ZWrite On
ZTest LEqual
ColorMask 0
Cull Back
HLSLPROGRAM
#pragma vertex ShadowPassVertex
#pragma fragment ShadowPassFragment
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
struct Attributes
{
float4 positionOS : POSITION;
float3 normalOS : NORMAL;
};
struct Varyings
{
float4 positionCS : SV_POSITION;
};
Varyings ShadowPassVertex(Attributes input)
{
Varyings output;
float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
// CAMBIO 3: Usamos la posición de la luz principal para que no dé errores
float3 lightDir = _MainLightPosition.xyz;
output.positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDir));
return output;
}
half4 ShadowPassFragment(Varyings input) : SV_TARGET
{
return 0;
}
ENDHLSL
}
// ─────────────────────────────────────────────────────────────
// PASS 3 – Outline (Tu código original intacto)
// ─────────────────────────────────────────────────────────────
Pass
{
Name "Outline"
Tags { "LightMode" = "SRPDefaultUnlit" }
Cull Front
ZWrite Off
ZTest LEqual
Blend SrcAlpha OneMinusSrcAlpha
Stencil
{
Ref 1
Comp NotEqual
}
HLSLPROGRAM
#pragma vertex OutlineVert
#pragma fragment OutlineFrag
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
CBUFFER_START(UnityPerMaterial)
float4 _MainTex_ST;
float4 _Color;
float4 _OutlineColor;
float _OutlineWidth;
CBUFFER_END
struct Attributes
{
float4 positionOS : POSITION;
float3 normalOS : NORMAL;
};
struct Varyings
{
float4 positionHCS : SV_POSITION;
};
Varyings OutlineVert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
float3 normalWS = TransformObjectToWorldNormal(IN.normalOS);
float3 normalCS = mul((float3x3)UNITY_MATRIX_VP, normalWS);
float2 offset = normalize(normalCS.xy) * (_OutlineWidth * OUT.positionHCS.w);
OUT.positionHCS.xy += offset;
return OUT;
}
half4 OutlineFrag(Varyings IN) : SV_Target
{
return _OutlineColor;
}
ENDHLSL
}
}
FallBack "Hidden/Universal Render Pipeline/FallbackError"
o.color = _OutlineColor;
return o;
}
ENDCG
SubShader {
//Tags {"Queue" = "Geometry+100" }
CGPROGRAM
#pragma surface surf Lambert
sampler2D _MainTex;
fixed4 _Color;
struct Input {
float2 uv_MainTex;
};
void surf (Input IN, inout SurfaceOutput o) {
fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG
// note that a vertex shader is specified here but its using the one above
Pass {
Name "OUTLINE"
Tags { "LightMode" = "Always" }
Cull Front
ZWrite On
ColorMask RGB
Blend SrcAlpha OneMinusSrcAlpha
//Offset 50,50
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
half4 frag(v2f i) :COLOR { return i.color; }
ENDCG
}
}
SubShader {
CGPROGRAM
#pragma surface surf Lambert
sampler2D _MainTex;
fixed4 _Color;
struct Input {
float2 uv_MainTex;
};
void surf (Input IN, inout SurfaceOutput o) {
fixed4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG
Pass {
Name "OUTLINE"
Tags { "LightMode" = "Always" }
Cull Front
ZWrite On
ColorMask RGB
Blend SrcAlpha OneMinusSrcAlpha
SetTexture [_MainTex] { combine primary }
}
}
Fallback "Diffuse"
}

69
Assets/Game Kit Controller/Shaders/Projector.shader
View File

@@ -1,11 +1,10 @@
Shader "Custom/URP_Projector"
{
Shader "Custom/Projector" {
Properties {
_Color ("Tint Color", Color) = (1,1,1,1)
_Attenuation ("Falloff", Range(0.0, 1.0)) = 1.0
_ShadowTex ("Cookie", 2D) = "gray" {}
}
SubShader {
Subshader {
Tags {"Queue"="Transparent"}
Pass {
ZWrite Off
@@ -13,51 +12,41 @@
Blend SrcAlpha One // Additive blending
Offset -1, -1
HLSLPROGRAM
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
#include "UnityCG.cginc"
struct v2f {
float4 uvShadow : TEXCOORD0;
float4 pos : SV_POSITION;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float4 uvShadow : TEXCOORD0;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
float4 _Color;
float _Attenuation;
CBUFFER_END
TEXTURE2D(_ShadowTex); SAMPLER(sampler_ShadowTex);
float4x4 unity_Projector;
Varyings vert(Attributes IN)
float4x4 unity_ProjectorClip;
v2f vert (float4 vertex : POSITION)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uvShadow = mul(unity_Projector, IN.positionOS);
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
v2f o;
o.pos = UnityObjectToClipPos (vertex);
o.uvShadow = mul (unity_Projector, vertex);
return o;
}
float4 frag(Varyings IN) : SV_Target
sampler2D _ShadowTex;
fixed4 _Color;
float _Attenuation;
fixed4 frag (v2f i) : SV_Target
{
float2 projUV = IN.uvShadow.xy / IN.uvShadow.w;
float4 texCookie = SAMPLE_TEXTURE2D(_ShadowTex, sampler_ShadowTex, projUV);
float4 outColor = _Color * texCookie.a;
float depth = IN.uvShadow.z;
float atten = clamp(1.0 - abs(depth) + _Attenuation, 0.0, 1.0);
float3 color = outColor.rgb * atten;
color = MixFog(color, IN.fogFactor);
return float4(color, outColor.a);
// Apply alpha mask
fixed4 texCookie = tex2Dproj (_ShadowTex, UNITY_PROJ_COORD(i.uvShadow));
fixed4 outColor = _Color * texCookie.a;
// Attenuation
float depth = i.uvShadow.z; // [-1 (near), 1 (far)]
return outColor * clamp(1.0 - abs(depth) + _Attenuation, 0.0, 1.0);
}
ENDHLSL
ENDCG
}
}
}

218
Assets/Game Kit Controller/Shaders/Simple Blur Shader.shader
View File

@@ -1,76 +1,164 @@
Shader "Custom/URP_SimpleBlurShader"
{
Shader "Custom/Simple Blur Shader" {
Properties {
_Size ("Blur", Range(0, 30)) = 1
[HideInInspector] _MainTex ("Texture (RGB)", 2D) = "white" {}
// _TintColor ("Tint Color", Color) = (1,1,1,1)
}
SubShader {
Tags { "Queue"="Transparent" "RenderType"="Transparent" }
LOD 100
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
Pass {
Name "FORWARD"
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
Category {
// We must be transparent, so other objects are drawn before this one.
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Opaque" }
SubShader
{
ZWrite Off
// Horizontal blur
GrabPass
{
"_HBlur"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest
#include "UnityCG.cginc"
struct appdata_t {
float4 vertex : POSITION;
float2 texcoord: TEXCOORD0;
float4 color : COLOR;
};
struct v2f {
float4 vertex : POSITION;
float4 uvgrab : TEXCOORD0;
float2 uvmain : TEXCOORD1;
float4 color : COLOR;
};
sampler2D _MainTex;
float4 _MainTex_ST;
v2f vert (appdata_t v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
#if UNITY_UV_STARTS_AT_TOP
float scale = -1.0;
#else
float scale = 1.0;
#endif
o.uvgrab.xy = (float2(o.vertex.x, o.vertex.y * scale) + o.vertex.w) * 0.5;
o.uvgrab.zw = o.vertex.zw;
o.uvmain = TRANSFORM_TEX(v.texcoord, _MainTex);
o.color = v.color;
return o;
}
sampler2D _HBlur;
float4 _HBlur_TexelSize;
float _Size;
CBUFFER_END
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
TEXTURE2D(_CameraOpaqueTexture); SAMPLER(sampler_CameraOpaqueTexture);
float4 _MainTex_ST;
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
OUT.color = IN.color;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
half4 frag( v2f i ) : COLOR
{
float alpha = tex2D(_MainTex, i.uvmain).a * i.color.a;
half4 sum = half4(0,0,0,0);
#define GRABPIXEL(weight,kernelx) tex2Dproj( _HBlur, UNITY_PROJ_COORD(float4(i.uvgrab.x + _HBlur_TexelSize.x * kernelx * _Size * alpha, i.uvgrab.y, i.uvgrab.z, i.uvgrab.w))) * weight
sum += GRABPIXEL(0.05, -4.0);
sum += GRABPIXEL(0.09, -3.0);
sum += GRABPIXEL(0.12, -2.0);
sum += GRABPIXEL(0.15, -1.0);
sum += GRABPIXEL(0.18, 0.0);
sum += GRABPIXEL(0.15, +1.0);
sum += GRABPIXEL(0.12, +2.0);
sum += GRABPIXEL(0.09, +3.0);
sum += GRABPIXEL(0.05, +4.0);
return sum ;
}
ENDCG
}
float4 frag(Varyings IN) : SV_Target
// Vertical blur
GrabPass
{
float2 uv = IN.uv;
float alpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv).a * IN.color.a;
float2 texelSize = float2(1.0/_ScreenParams.x, 1.0/_ScreenParams.y);
float4 sum = float4(0,0,0,0);
// Horizontal blur
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(-4.0, 0.0) * texelSize * _Size * alpha) * 0.05;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(-3.0, 0.0) * texelSize * _Size * alpha) * 0.09;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(-2.0, 0.0) * texelSize * _Size * alpha) * 0.12;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(-1.0, 0.0) * texelSize * _Size * alpha) * 0.15;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv) * 0.18;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(1.0, 0.0) * texelSize * _Size * alpha) * 0.15;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(2.0, 0.0) * texelSize * _Size * alpha) * 0.12;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(3.0, 0.0) * texelSize * _Size * alpha) * 0.09;
sum += SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, uv + float2(4.0, 0.0) * texelSize * _Size * alpha) * 0.05;
sum.rgb = MixFog(sum.rgb, IN.fogFactor);
return sum;
"_VBlur"
}
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest
#include "UnityCG.cginc"
struct appdata_t {
float4 vertex : POSITION;
float2 texcoord: TEXCOORD0;
float4 color : COLOR;
};
struct v2f {
float4 vertex : POSITION;
float4 uvgrab : TEXCOORD0;
float2 uvmain : TEXCOORD1;
float4 color : COLOR;
};
sampler2D _MainTex;
float4 _MainTex_ST;
v2f vert (appdata_t v) {
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
#if UNITY_UV_STARTS_AT_TOP
float scale = -1.0;
#else
float scale = 1.0;
#endif
o.uvgrab.xy = (float2(o.vertex.x, o.vertex.y * scale) + o.vertex.w) * 0.5;
o.uvgrab.zw = o.vertex.zw;
o.uvmain = TRANSFORM_TEX(v.texcoord, _MainTex);
o.color = v.color;
return o;
}
sampler2D _VBlur;
float4 _VBlur_TexelSize;
float _Size;
//fixed4 _TintColor;
half4 frag( v2f i ) : COLOR
{
float alpha = tex2D(_MainTex, i.uvmain).a * i.color.a;
half4 sum = half4(0,0,0,0);
#define GRABPIXEL(weight,kernely) tex2Dproj( _VBlur, UNITY_PROJ_COORD(float4(i.uvgrab.x, i.uvgrab.y + _VBlur_TexelSize.y * kernely * _Size * alpha, i.uvgrab.z, i.uvgrab.w))) * weight
sum += GRABPIXEL(0.05, -4.0);
sum += GRABPIXEL(0.09, -3.0);
sum += GRABPIXEL(0.12, -2.0);
sum += GRABPIXEL(0.15, -1.0);
sum += GRABPIXEL(0.18, 0.0);
sum += GRABPIXEL(0.15, +1.0);
sum += GRABPIXEL(0.12, +2.0);
sum += GRABPIXEL(0.09, +3.0);
sum += GRABPIXEL(0.05, +4.0);
return sum + i.color * alpha;
}
ENDCG
}
ENDHLSL
}
}
}

113
Assets/Game Kit Controller/Shaders/additive.shader
View File

@@ -1,69 +1,62 @@
Shader "Custom/URP_Additive"
{
Properties
{
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
Shader "Custom/additive" {
Properties {
_MainTex ("Base", 2D) = "white" {}
_TintColor ("TintColor", Color) = (1.0, 1.0, 1.0, 1.0)
}
SubShader
{
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" }
LOD 100
Cull Off
ZWrite Off
Blend One One
CGINCLUDE
Pass
{
Name "FORWARD"
Tags { "LightMode" = "UniversalForward" }
#include "UnityCG.cginc"
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
sampler2D _MainTex;
fixed4 _TintColor;
half4 _MainTex_ST;
struct v2f {
half4 pos : SV_POSITION;
half2 uv : TEXCOORD0;
fixed4 vertexColor : COLOR;
};
struct Attributes
{
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
};
struct Varyings
{
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float4 color : COLOR;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
float4 _TintColor;
CBUFFER_END
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
OUT.color = IN.color * _TintColor;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
float4 frag(Varyings IN) : SV_Target
{
float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
float4 col = tex * IN.color;
col.rgb = MixFog(col.rgb, IN.fogFactor);
return col;
}
ENDHLSL
v2f vert(appdata_full v) {
v2f o;
o.pos = UnityObjectToClipPos (v.vertex);
o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
o.vertexColor = v.color * _TintColor;
return o;
}
}
fixed4 frag( v2f i ) : COLOR {
return tex2D (_MainTex, i.uv.xy) * i.vertexColor;
}
ENDCG
SubShader {
Tags { "RenderType" = "Transparent" "Queue" = "Transparent"}
Cull Off
Lighting Off
ZWrite Off
Fog { Mode Off }
Blend One One
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest
ENDCG
}
}
FallBack Off
}

100
Assets/Game Kit Controller/Shaders/laserShader.shader
View File

@@ -1,61 +1,59 @@
Shader "Custom/URP_LaserShader"
{
// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
Shader "Custom/laserShader" {
Properties {
_MainTex ("Base", 2D) = "white" {}
_TintColor ("TintColor", Color) = (0.5, 0.5, 0.5, 0.5)
}
SubShader {
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" }
LOD 100
Cull Off
ZWrite Off
Blend SrcAlpha One
CGINCLUDE
Pass {
Name "FORWARD"
Tags { "LightMode" = "UniversalForward" }
#include "UnityCG.cginc"
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
sampler2D _MainTex;
fixed4 _TintColor;
struct v2f {
half4 pos : SV_POSITION;
half2 uv : TEXCOORD0;
};
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
float4 _TintColor;
CBUFFER_END
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
float4 frag(Varyings IN) : SV_Target
{
float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
float4 col = tex * _TintColor;
col.rgb = MixFog(col.rgb, IN.fogFactor);
return col;
}
ENDHLSL
v2f vert(appdata_full v) {
v2f o;
o.pos = UnityObjectToClipPos (v.vertex);
o.uv.xy = v.texcoord.xy;
return o;
}
}
fixed4 frag( v2f i ) : COLOR {
return tex2D (_MainTex, i.uv.xy) * _TintColor;
}
ENDCG
SubShader {
Tags { "RenderType" = "Transparent" "Queue" = "Transparent"}
Cull Off
Lighting Off
ZWrite Off
Fog { Mode Off }
Blend SrcAlpha One
Pass {
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma fragmentoption ARB_precision_hint_fastest
ENDCG
}
}
FallBack Off
}

92
Assets/Game Kit Controller/Shaders/runShader.shader
View File

@@ -1,66 +1,34 @@
Shader "Custom/URP_prueba"
{
Properties {
_Color ("Main Color", Color) = (1,1,1,1)
_SpecColor ("Spec Color", Color) = (1,1,1,0)
_Emission ("Emissive Color", Color) = (0,0,0,0)
_Shininess ("Shininess", Range (0.1, 1)) = 0.7
_MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
}
SubShader {
Tags {"RenderType"="Transparent" "Queue"="Transparent"}
LOD 200
Shader "Custom/prueba" {
Properties {
_Color ("Main Color", Color) = (1,1,1,1)
_SpecColor ("Spec Color", Color) = (1,1,1,0)
_Emission ("Emissive Color", Color) = (0,0,0,0)
_Shininess ("Shininess", Range (0.1, 1)) = 0.7
_MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
}
SubShader {
Tags {"RenderType"="Transparent" "Queue"="Transparent"}
// Render into depth buffer only
Pass {
Name "FORWARD"
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
ColorMask RGB
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
float4 _Color;
float4 _SpecColor;
float4 _Emission;
float _Shininess;
CBUFFER_END
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
float4 frag(Varyings IN) : SV_Target
{
float4 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv) * _Color;
float3 emission = _Emission.rgb;
float3 specular = _SpecColor.rgb * _Shininess;
float3 color = albedo.rgb + emission + specular;
float alpha = albedo.a;
color = MixFog(color, IN.fogFactor);
return float4(color, alpha);
}
ENDHLSL
ColorMask 0
}
// Render normally
Pass {
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
ColorMask RGB
Material {
Diffuse [_Color]
Ambient [_Color]
Shininess [_Shininess]
Specular [_SpecColor]
Emission [_Emission]
}
Lighting On
SetTexture [_MainTex] {
Combine texture * primary DOUBLE, texture * primary
}
}
}
}

71
Assets/Game Kit Controller/Shaders/textShader.shader
View File

@@ -1,58 +1,17 @@
Shader "Custom/URP_textShader"
{
Shader "Custom/textShader" {
Properties {
_MainTex ("Font Texture", 2D) = "white" {}
_Color ("Text Color", Color) = (1,1,1,1)
}
SubShader {
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
LOD 100
Cull Off
ZWrite Off
Blend SrcAlpha OneMinusSrcAlpha
Pass {
Name "FORWARD"
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma multi_compile_fog
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
struct Attributes {
float4 positionOS : POSITION;
float2 uv : TEXCOORD0;
};
struct Varyings {
float4 positionHCS : SV_POSITION;
float2 uv : TEXCOORD0;
float fogFactor : TEXCOORD1;
};
CBUFFER_START(UnityPerMaterial)
float4 _Color;
CBUFFER_END
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
Varyings vert(Attributes IN)
{
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
OUT.fogFactor = ComputeFogFactor(OUT.positionHCS.z / OUT.positionHCS.w);
return OUT;
}
float4 frag(Varyings IN) : SV_Target
{
float4 tex = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
float4 col = tex * _Color;
col.rgb = MixFog(col.rgb, IN.fogFactor);
return col;
}
ENDHLSL
}
}
_MainTex ("Font Texture", 2D) = "white" {}
_Color ("Text Color", Color) = (1,1,1,1)
}
SubShader {
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
Lighting Off Cull Off ZWrite Off Fog { Mode Off }
Blend SrcAlpha OneMinusSrcAlpha
Pass{
Color [_Color]
SetTexture [_MainTex] {
combine primary, texture * primary
}
}
}
}