一款基于卡牌的塔防游戏,类似于 Supercell 的《皇室战争》的游戏玩法(简化形式), 可以与“非智能”AI 进行比赛。
您最多选择25个主题 主题必须以中文或者字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符
 
 
 
 

246 行
7.7 KiB

Shader "Custom/AnimateShader_noHelper"
{
Properties
{
_MainTex ("MainTex", 2D) = "white" {}
_SubTex ("Subtex",2D) = "white" {}
[Enum(UnityEngine.Rendering.BlendMode)] _Src("Source",Float)=1
[Enum(UnityEngine.Rendering.BlendMode)] _Des("Destination",Float) = 1
_SpeedMainU("Speed Main U",Float) =0
_SpeedMainV("Speed Main V",Float) =0
_SpeedSubU("Speed Sub U",Float) = 0
_SpeedSubV("Speed Sub V",Float) =0
_SpeedMainAlphaU("Speed Main Alpha U",Float) = 0
_SpeedMainAlphaV("Speed Main Alpha V",Float) =0
_SpeedSubAlphaU("Speed Sub Alpha U",Float) =0
_SpeedSubAlphaV("Speed Sub Alpha V",Float) = 0
_BlendMap ("Blend Map", 2D) = "white" {}
_SpeedBlendU("Speed Blend U",Float) = 0
_SpeedBlendV("Speed Blend V",Float) =0
_Blend("Blend",Range(0,1))=0
_AlphaMap1 ("Alpha 1",2D) = "white" { }
_AlphaMap2 ("Alpha 2",2D) = "white" { }
_Index("Index",Int)=0
_Octaves("Octaves", Float) = 8.0
_Frequency("Frequency", Float) = 1.0
_Amplitude("Amplitude", Float) = 1.0
_Lacunarity("Lacunarity", Float) = 1.92
_Persistence("Persistence", Float) = 0.8
_Offset("Offset", Vector) = (0.0, 0.0, 0.0, 0.0)
_AnimSpeed("Animation Speed", Float) = 1.0
}
CGINCLUDE
void FAST32_hash_3D(float3 gridcell,
out float4 lowz_hash_0,
out float4 lowz_hash_1,
out float4 lowz_hash_2,
out float4 highz_hash_0,
out float4 highz_hash_1,
out float4 highz_hash_2) // generates 3 random numbers for each of the 8 cell corners
{
const float2 OFFSET = float2(50.0, 161.0);
const float DOMAIN = 69.0;
const float3 SOMELARGEFLOATS = float3(635.298681, 682.357502, 668.926525);
const float3 ZINC = float3(48.500388, 65.294118, 63.934599);
// truncate the domain
gridcell.xyz = gridcell.xyz - floor(gridcell.xyz * (1.0 / DOMAIN)) * DOMAIN;
float3 gridcell_inc1 = step(gridcell, float3(DOMAIN - 1.5, DOMAIN - 1.5, DOMAIN - 1.5)) * (gridcell + 1.0);
// calculate the noise
float4 P = float4(gridcell.xy, gridcell_inc1.xy) + OFFSET.xyxy;
P *= P;
P = P.xzxz * P.yyww;
float3 lowz_mod = float3(1.0 / (SOMELARGEFLOATS.xyz + gridcell.zzz * ZINC.xyz));
float3 highz_mod = float3(1.0 / (SOMELARGEFLOATS.xyz + gridcell_inc1.zzz * ZINC.xyz));
lowz_hash_0 = frac(P * lowz_mod.xxxx);
highz_hash_0 = frac(P * highz_mod.xxxx);
lowz_hash_1 = frac(P * lowz_mod.yyyy);
highz_hash_1 = frac(P * highz_mod.yyyy);
lowz_hash_2 = frac(P * lowz_mod.zzzz);
highz_hash_2 = frac(P * highz_mod.zzzz);
}
float3 Interpolation_C2(float3 x) { return x * x * x * (x * (x * 6.0 - 15.0) + 10.0); }
// http://briansharpe.files.wordpress.com/2011/11/perlinsample.jpg
//
float Perlin3D(float3 P)
{
// establish our grid cell and unit position
float3 Pi = floor(P);
float3 Pf = P - Pi;
float3 Pf_min1 = Pf - 1.0;
//
// classic noise.
// requires 3 random values per point. with an efficent hash function will run faster than improved noise
//
// calculate the hash.
// ( various hashing methods listed in order of speed )
float4 hashx0, hashy0, hashz0, hashx1, hashy1, hashz1;
FAST32_hash_3D(Pi, hashx0, hashy0, hashz0, hashx1, hashy1, hashz1);
// calculate the gradients
float4 grad_x0 = hashx0 - 0.49999;
float4 grad_y0 = hashy0 - 0.49999;
float4 grad_z0 = hashz0 - 0.49999;
float4 grad_x1 = hashx1 - 0.49999;
float4 grad_y1 = hashy1 - 0.49999;
float4 grad_z1 = hashz1 - 0.49999;
float4 grad_results_0 = rsqrt(grad_x0 * grad_x0 + grad_y0 * grad_y0 + grad_z0 * grad_z0) * (float2(Pf.x, Pf_min1.x).xyxy * grad_x0 + float2(Pf.y, Pf_min1.y).xxyy * grad_y0 + Pf.zzzz * grad_z0);
float4 grad_results_1 = rsqrt(grad_x1 * grad_x1 + grad_y1 * grad_y1 + grad_z1 * grad_z1) * (float2(Pf.x, Pf_min1.x).xyxy * grad_x1 + float2(Pf.y, Pf_min1.y).xxyy * grad_y1 + Pf_min1.zzzz * grad_z1);
// Classic Perlin Interpolation
float3 blend = Interpolation_C2(Pf);
float4 res0 = lerp(grad_results_0, grad_results_1, blend.z);
float2 res1 = lerp(res0.xy, res0.zw, blend.y);
float final = lerp(res1.x, res1.y, blend.x);
final *= 1.1547005383792515290182975610039; // (optionally) scale things to a strict -1.0->1.0 range *= 1.0/sqrt(0.75)
return final;
}
float PerlinBillowed(float3 p, int octaves, float3 offset, float frequency, float amplitude, float lacunarity, float persistence)
{
float sum = 0;
for (int i = 0; i < octaves; i++)
{
float h = 0;
h = abs(Perlin3D((p + offset) * frequency));
sum += h * amplitude;
frequency *= lacunarity;
amplitude *= persistence;
}
return sum;
}
ENDCG
SubShader
{
Tags { "RenderType"="Opaque" "Queue"="Transparent" }
LOD 100
Pass
{
ZWrite off
Blend [_Src] [_Des]
ColorMask RGB
AlphaToMask off
CGPROGRAM
// Upgrade NOTE: excluded shader from DX11; has structs without semantics (struct v2f members pos)
#pragma vertex vert
#pragma fragment frag
// make fog work
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float4 uv : TEXCOORD0;
float2 uv_alpha : TEXCOORD1;
float2 uv_alpha1 : TEXCOORD2;
// add more vertex color
float4 color :COLOR;
float4 texcoord :TEXCOORD3;
};
struct v2f
{
float2 uv : TEXCOORD0;
float2 uv_alpha1 : TEXCOORD1;
float2 uv_alpha2 : TEXCOORD2;
UNITY_FOG_COORDS(1)
// add more vertex color
float4 color :COLOR;
float4 vertex : SV_POSITION;
float3 pos :TEXCOORD3;
};
sampler2D _AlphaMap1;
sampler2D _AlphaMap2;
sampler2D _MainTex;
sampler2D _SubTex;
sampler2D _BlendMap;
float4 _MoveAlpha;
float4 _MainTex_ST;
float4 _SubTex_ST;
float4 _AlphaMap1_ST;
float4 _AlphaMap2_ST;
float _Blend;
float _Timex;
float _SpeedMainU, _SpeedSubU, _SpeedMainV, _SpeedSubV;
float _SpeedMainAlphaU, _SpeedSubAlphaU, _SpeedMainAlphaV, _SpeedSubAlphaV;
float _SpeedBlendU, _SpeedBlendV;
// for noise map
fixed _Octaves;
float _Frequency;
float _Amplitude;
float3 _Offset;
float _Lacunarity;
float _Persistence;
float _AnimSpeed;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv.xy,_MainTex);
o.uv_alpha1 = TRANSFORM_TEX(v.uv_alpha, _AlphaMap1);
o.uv_alpha2 = TRANSFORM_TEX(v.uv_alpha1, _AlphaMap2);
o.pos = float3(v.texcoord.xy, _Time.y * _AnimSpeed);
//pass vertex color
o.color =v.color;
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
float h = 1; // PerlinBillowed(i.pos, _Octaves, _Offset, _Frequency, _Amplitude, _Lacunarity, _Persistence);
float4 color = float4(h, h, h, h);
// sample the texture
fixed2 _MainSpeed = fixed2(i.uv.x+_SpeedMainU*_Time.y,i.uv.y+_SpeedMainV*_Time.y);
fixed2 _SubSpeed = fixed2(i.uv.x +_SpeedSubU*_Time.y,i.uv.y+_SpeedSubV*_Time.y);
fixed2 AlphaSpeed1 = fixed2(i.uv_alpha1.x+_SpeedMainAlphaU*_Time.y,i.uv_alpha1.y+_SpeedMainAlphaV*_Time.y);
fixed2 AlphaSpeed2 = fixed2(i.uv_alpha2.x + _SpeedSubAlphaU *_Time.y,i.uv_alpha2.y+ _SpeedSubAlphaV *_Time.y);
//Alpha1
fixed4 Alpha1 = tex2D(_AlphaMap1, AlphaSpeed1);
//Alpha2
fixed4 Alpha2 = tex2D(_AlphaMap2, AlphaSpeed2);
//BlendMap
fixed4 Blendmap = tex2D(_BlendMap,i.uv.xy+float2(_SpeedBlendU*_Time.y,_SpeedBlendV*_Time.y));
fixed4 MainColor = tex2D(_MainTex,_MainSpeed)*Alpha1;
fixed4 SubColor = tex2D(_SubTex,_SubSpeed)*Alpha2;
// animate main alpha
//Final
fixed4 BlendColor =lerp(SubColor*color,MainColor,Blendmap*_Blend)*i.color.a;
fixed4 col =tex2D(_MainTex,i.uv);
// apply fog
UNITY_APPLY_FOG(i.fogCoord, BlendColor);
return BlendColor*i.color;
}
ENDCG
}
}
CustomEditor "CustomGUIShader"
}