Unity Shader sheet record

关注

转载最新推荐文章于 2026-09-21 16:13:26 发布 901 阅读 AI 写同款· GEO 优化 ›

// This cheatsheet primarily focuses on VERTEX/FRAMGENT shaders and not on SURFACE shaders,
// but some of the surface shader things are mentioned in a separate category on the bottom. see SURFACE

// #STRUCTURE

// #VERT/FRAG shader

Shader "Custom/Name"
{
   Properties // See PROPERTIES
   {

   }

Tags // See TAGS
Blend // See BLEND MODES

   Pass
   {
       CGPROGRAM

#include // See INCLUDES

#pragma vertex vert // See PRAGMAS
#pragma fragment frag

// custom variables

struct appdata { }; // not necessary if using one of predefined ones, see #APPDATA

       struct v2f { }; // see #STRUCTS

       v2f vert (appdata v) { };

       fixed4 frag (v2f i) : SV_Target { };

       ENDCG
   }

Pass // Another pass...
{

}
}

// #PROPERTIES

Properties
{
   // Syntax: _VariableName ("Label in the inspector", Type) = default value
   _RangedFloat ("Ranged Float", Range (min, max)) = number
   _Float ("Float", Float) = number
   _Int ("Int", Int) = number
   _Color ("Some Color", Color) = (1,1,1,1)
   _Vector ("Some Vector", Vector) = (0,0,0,0)
   _Texture ("Texture", 2D) = "white" {} // "", “white” (1,1,1,1), “black” (0,0,0,0), “gray” (0.5,0.5,0.5,0.5), “bump” (0.5,0.5,1,0.5) or “red” (1,0,0,0)
   _Cubemap ("Cubemap", CUBE) = "" {}
   _3DTexture ("3DTexture", 3D) = "defaulttexture" {}

   // Standard properties:
   // Unity's builtin shaders use _MainTex ss the main diffuse/albedo slot,
   // so it is advised to use this
   _MainTex ("Main Tex", 2D) = "white" {}
   _BumpMap ("Bumpmap", 2D) = "bump" {}

   // Attiributes:
   [HideInInspector]
   [NoScaleOffset] // no texture tiling/offset fields in inspector
   [Normal] // expects a normal map and adds a "Fix Now" button to convert
   [HDR] // expects an HDR
   [Gamma] // indicates that a float/vector property is specified as sRGB value in the UI (just like colors are), and possibly needs conversion according to color space used
   [PerRendererData] // indicates that a texture property will be coming from per-renderer data in the form of a MaterialPropertyBlock. Material inspector changes the texture slot UI for these properties.

   // Sliders
   [PowerSlider(3.0)] _Shininess ("Shininess", Range (0.01, 1)) = 0.08 // A slider with "power of" (in this case ^3) response curve
   [IntRange] _Alpha ("Alpha", Range (0, 255)) = 100 // integer slider for specified range (0 to 255)

   // Decorators
   [Space(50)] _Prop2 ("Prop2", Float) = 0 // creates space before property
   [Header(A group of things)] _Prop1 ("Prop1", Float) = 0 // creates a header before property

[Enum(UnityEngine.Rendering.BlendMode)] _Blend ("Blend mode", Float) = 1 // blend mode popup menu
[Enum(One,1,SrcAlpha,5)] _Blend2 ("Blend mode subset", Float) = 1 // a subset of blend mode values, just "One" (value 1) and "SrcAlpha" (value 5)

   // multi_compile Shader Keywords
   [Toggle(THINGY)] _Fancy ("Thingy", Float) = 0 // toggles a THINGY multi_compile shader keyword, see #MULTI_COMPILE
   [KeywordEnum(None, Add, Multiply)] _Overlay ("Overlay mode", Float) = 0
}

// They would be accessed in HSLS code as:
half _Float;
fixed _Float;
float _Float;

int _Int;
uint _Int;

// half, fixed, float + 2,3,4 are all possible combinations for example:
fixed4 _Color; // low precision type is usually enough for colors
float4 _Vector;

float4x4 _Matrix;

sampler2D _Texture;
samplerCUBE _Cubemap;
sampler3D _3DTexture;

// Tiling and Offset information can be obtain by [TEXTURE NAME]_ST, that needs to be defined separately
float4 _Texture_ST; // (x = x tiling, y = y tiling, z = x offset, w = y offset)

// Texture size can be obtained through the Vector4 [TEXTURE NAME]_TexelSize
float4 _Texture_TexelSize; // x = 1.0/width, y = 1.0/height, z = width, w = height

// Never personally used, see in official docs
float4 _Texture_HDR

// #TAGS

Tags {
   "Queue" = "Background" | "Geometry" | "AlphaTest" | "Transparent" | "Overlay"
   // special cases with +number, e.g. "Geometry+1"
   "RenderType" = "Transparent" | "TransparentCutout" | "Background" | "Overlay"
                   | "TreeOpaque" | "TreeTransparentCutout" | "TreeBillboard" | "Grass" | "GrassBillboard"
   "IgnoreProjector" = "True"
   "DisableBatching" = "True" | "False" | "LODFading"
   "ForceNoShadowCasting" = "True"
   "IgnoreProjector" = "True"
   "CanUseSpriteAtlas" = "False" // if the shader is meant for sprites, and will not work when they are packed into atlases
   "PreviewType" = "Sphere" | "Plane" | "Skybox" // how should the inspector preview the material, Plane is 2D
}

// incomplete

// #BLEND MODES

Blend Off

Blend SrcAlpha OneMinusSrcAlpha // Traditional transparency
Blend One OneMinusSrcAlpha // Premultiplied transparency
Blend One One // Additive
Blend OneMinusDstColor One // Soft Additive
Blend DstColor Zero // Multiplicative
Blend DstColor SrcColor // 2x Multiplicative

BlendOp colorOp // provide a custom operation
BlendOp colorOp, alphaOp
AlphaToMask On | Off // aka Alpha to coverage, allows MSAA to be used on pixels of an alpha test shader

// #Culling & Z

// #PRAGMAS ==

// Pragmas are compilation directives
// They written inside the CGPROGRAM ENDCG block
#pragma vertex name // function that acts on every mesh vertex
#pragma fragment name // function that acts on every visible pixel
#pragma geometry name // DX10 geometry shader function. Acts per triangle. Turns on #pragma target 4.0
// Used for tessellation:
#pragma hull name // DX11 hull shader function. Acts once per patch. Turns on #pragma target 5.0
#pragma domain name // DX11 domain shader function. Turns on #pragma target 5.0
// Shader keywords:
#pragma multi_compile KEYWORD1 KEYWORD2 // enables multiple shader variants, see MULTI_COMPILE
#pragma skip_variants KEYWORD2 KEYWORD3 // skips compiling variants that you are sure are not used in the project
#pragma hardware_tier_variants renderer // automatically creates 3 variants: UNITY_HARDWARE_TIER1, UNITY_HARDWARE_TIER2 and UNITY_HARDWARE_TIER3
#pragma shader_feature KEYWORD // similar to multi_compile but unused variants will not be included in the build

// #VERTEX STRUCTS

// built-in shortcut appdatas:
appdata_base // position, normal and one texture coordinate.
appdata_tan // position, tangent, normal and one texture coordinate.
appdata_full // position, tangent, normal, four texture coordinates and color.
appdata_img // vertex shader input with position and one texture coordinate.

// or custom struct like:
struct appdata {
// built in types:
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
fixed4 color : COLOR;

float4 texcoord : TEXCOORD0; // or some people write "uv"
float3 mycustomthing : TEXCOORD1; // for other custom things use TEXCOORD-number
};

// this is what appdata_full has:
struct appdata_full {
float4 vertex : POSITION;
float4 tangent : TANGENT;
float3 normal : NORMAL;
float4 texcoord : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
fixed4 color : COLOR;
#if defined(SHADER_API_XBOX360)
half4 texcoord2 : TEXCOORD2;
half4 texcoord3 : TEXCOORD3;
half4 texcoord4 : TEXCOORD4;
half4 texcoord5 : TEXCOORD5;
#endif
};

// #STRUCTS
// #VERTEX TO FRAGMENT STRUCT

// COLOR0, COLOR2.. etc is used for low precision 0-1 values
// TEXCOORD0, TEXCOORD1.. etc is used for high precision
// ^ this only matters on older, dx9 hardware

// Note: COLOR is the same as COLOR0, the same goes for TEXCOORD and TEXCOORD0 (TODO: check if true)

struct v2f {
float4 pos : SV_POSITION;
fixed4 color : COLOR; // this didn't neeed to be COLOR (see above)

float4 uv : TEXCOORD0;
float3 normal : TEXCOORD1;

uint vid : SV_VertexID // vertex ID, needs to be uint, requires #pragma target 3.5
}; // NOTE THE SEMICOLON HERE AFTER STRUCT!

// #VERTEX SHADER

// If you only need position, you can return just a float4 in clip space
float4 vert (float4 vertex : POSITION) : SV_POSITION
{
return UnityObjectToClipPos(vertex);
}

// if you have more data, you need to return a custom structure (see VERTEX TO FRAGMENT STRUCT)

// The values output from the vertex shader will be interpolated across the face of the rendered triangles,
// and the values at each pixel will be passed as inputs to the fragment shader.

v2f vert (appdata_base v)
{
v2f o;
o.pos = UnityObjectToClipPos(v.vertex); // clip pos, NOT object position
// uv
o.uv = float4( v.texcoord.xy, 0, 0 );
// vertex color
o.color = v.color;

// VIEW (camera) - camera view
o.viewDir = normalize(WorldSpaceViewDir(v.vertex));
return o;
} // NO SEMICOLON AFTER FUNCTIONS!

o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
vs
o.vertex = UnityObjectToClipPos(v.vertex);
?

// #FRAGMENT SHADER

// usually, you would use : SV_Target semantic, like:
fixed4 frag (v2f i) : SV_Target
{
return i.color // to visualize vertex color for eg.
}

// ---------

// but you can also return custom structure if you need additional colors (as in multiple render targets):
struct fragOutput
{
   fixed4 color : SV_Target;
   fixed4 color2 : SV_Target0; // for additional render targets .. add as many SV_TargetN as you need
   fixed4 depth : SV_Depth; // overrides the z buffer value. Note on some GPUs it turns off depth buffer optimizations
};

fragOutput frag (v2f i)
{
   fragOutput o;
   o.color = fixed4(i.uv, 0, 0);
   o.color2 = i.color;
   o.depth = 0;
   return o;
}

// ---------

// You can use VPOS to obtain screen space vertex position in pixels
// requires #pragma target 3.0
fixed4 frag (v2f i, UNITY_VPOS_TYPE screenPos : VPOS) : SV_Target
{
return fixed4(screenPos.xy, 0, 0); // X Y is in pixels!
}

// You can use VFACE to obtain face facing
// VFACE input positive for frontbaces,negative for backfaces
// requires #pragma target 3.0
fixed4 frag (fixed facing : VFACE) : SV_Target
{
return facing > 0 ? _ColorFront : _ColorBack;
}

// ---------

// #BUILT-IN FUNCTIONS

// #INCLUDES

#include HLSLSupport.cginc // (automatically included) Helper macros and definitions for cross-platform shader compilation.
#include UnityShaderVariables.cginc // (automatically included) Commonly used global variables.

#include UnityCG.cginc // commonly used helper functions.
#include AutoLight.cginc // lighting & shadowing functionality, e.g. surface shaders use this file internally.
#include Lighting.cginc // standard surface shader lighting models; automatically included when you’re writing surface shaders.
#include TerrainEngine.cginc // helper functions for Terrain & Vegetation shaders.

// Vertex transformation functions in UnityCG.cginc
float4 UnityObjectToClipPos(float3 pos) // Transforms a point from object space to the camera’s clip space in homogeneous coordinates. This is the equivalent of mul(UNITY_MATRIX_MVP, float4(pos, 1.0)), and should be used in its place.
float3 UnityObjectToViewPos(float3 pos) // Transforms a point from object space to view space. This is the equivalent of mul(UNITY_MATRIX_MV, float4(pos, 1.0)).xyz, and should be used in its place.

// Generic helper functions in UnityCG.cginc
float3 WorldSpaceViewDir (float4 v)   // Returns world space direction (not normalized) from given object space vertex position towards the camera.
float3 ObjSpaceViewDir (float4 v)   // Returns object space direction (not normalized) from given object space vertex position towards the camera.
float2 ParallaxOffset (half h, half height, half3 viewDir)   // calculates UV offset for parallax normal mapping.
fixed Luminance (fixed3 c)   // Converts color to luminance (grayscale).
fixed3 DecodeLightmap (fixed4 color)   // Decodes color from Unity lightmap (RGBM or dLDR depending on platform).
float4 EncodeFloatRGBA (float v)   // Encodes [0..1) range float into RGBA color, for storage in low precision render target.
float DecodeFloatRGBA (float4 enc)   // Decodes RGBA color into a float.
float2 EncodeFloatRG (float v)   // Encodes [0..1) range float into a float2.
float DecodeFloatRG (float2 enc)   // Decodes a previously-encoded RG float.
float2 EncodeViewNormalStereo (float3 n)   // Encodes view space normal into two numbers in 0..1 range.
float3 DecodeViewNormalStereo (float4 enc4)   // Decodes view space normal from enc4.xy.

// Only in forward rendering
float3 WorldSpaceLightDir (float4 v)   //Computes world space direction (not normalized) to light, given object space vertex position.
float3 ObjSpaceLightDir (float4 v)   //Computes object space direction (not normalized) to light, given object space vertex position.
float3 Shade4PointLights (...)   //Computes illumination from four point lights, with light data tightly packed into vectors. Forward rendering uses this to compute per-vertex lighting

// Screen-space helper functions in UnityCG.cginc
float4 ComputeScreenPos (float4 clipPos)   // Computes texture coordinate for doing a screenspace-mapped texture sample. Input is clip space position. The function takes care of platform differences in render texture coordinates.
float4 ComputeGrabScreenPos (float4 clipPos)   //Computes texture coordinate for sampling a GrabPass texure. Input is clip space position. The function takes care of platform differences in render texture coordinates.
float3 ShadeVertexLights (float4 vertex, float3 normal)   // Computes illumination from four per-vertex lights and ambient, given object space position & normal.

UnityObjectToWorldNormal(normal); // To convert normals to world space

tex2D(_Tex, float2); // Texture sampling

// #BUILT-IN VARIABLES

// #Transformations
// TODOL CHeck if these still work
UNITY_MATRIX_MVP   // Current model * view * projection matrix.
UNITY_MATRIX_MV   // Current model * view matrix.
UNITY_MATRIX_V   // Current view matrix.
UNITY_MATRIX_P   // Current projection matrix.
UNITY_MATRIX_VP   // Current view * projection matrix.
UNITY_MATRIX_T_MV   // Transpose of model * view matrix.
UNITY_MATRIX_IT_MV   // Inverse transpose of model * view matrix.

unity_WorldToObject // Inverse of current world matrix. _World2Object is obsolete
unity_ObjectToWorld // Current model matrix. _Object2World is obsolete

// To get UVs
newUV = TRANSFORM_TEX(oldUV, _MainTex); // replace with the name of your texture
// also remember to declare the float4 _MainTex_ST; variable before using the macro

// #Camera & Screen
_WorldSpaceCameraPos   // float3   World space position of the camera.
_ProjectionParams   // float4   x is 1.0 (or –1.0 if currently rendering with a flipped projection matrix), y is the camera’s near plane, z is the camera’s far plane and w is 1/FarPlane.
_ScreenParams   // float4   x is the camera’s render target width in pixels, y is the camera’s render target height in pixels, z is 1.0 + 1.0/width and w is 1.0 + 1.0/height.
_ZBufferParams   // float4   Used to linearize Z buffer values. x is (1-far/near), y is (far/near), z is (x/far) and w is (y/far).
unity_OrthoParams   // float4   x is orthographic camera’s width, y is orthographic camera’s height, z is unused and w is 1.0 when camera is orthographic, 0.0 when perspective.
unity_CameraProjection   // float4x4   Camera’s projection matrix.
unity_CameraInvProjection   // float4x4   Inverse of camera’s projection matrix.
unity_CameraWorldClipPlanes[6]   // float4   Camera frustum plane world space equations, in this order: left, right, bottom, top, near, far.

// #Time
_Time   // float4   Time since level load (t/20, t, t*2, t*3), use to animate things inside the shaders.
_SinTime   // float4   Sine of time: (t/8, t/4, t/2, t).
_CosTime   // float4   Cosine of time: (t/8, t/4, t/2, t).
unity_DeltaTime   // float4   Delta time: (dt, 1/dt, smoothDt, 1/smoothDt).

// #Lights
_LightColor0 // (declared in Lighting.cginc)   fixed4   Light color
_WorldSpaceLightPos0   // float4   Directional lights: (world space direction, 0). Other lights: (world space position, 1).
_LightMatrix0 // (declared in AutoLight.cginc)   float4x4   World-to-light matrix. Used to sample cookie & attenuation textures.
// forward only:
unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0   // float4   (ForwardBase pass only) world space positions of first four non-important point lights.
unity_4LightAtten0   // float4   (ForwardBase pass only) attenuation factors of first four non-important point lights.
unity_LightColor   // half4[4]   (ForwardBase pass only) colors of of first four non-important point lights.
// deffered:
_LightColor   //float4   Light color.
_LightMatrix0   //float4x4   World-to-light matrix. Used to sample cookie & attenuation textures.
// vertex lit:
unity_LightColor   // half4[8]   Light colors.
unity_LightPosition   // float4[8]   View-space light positions. (-direction,0) for directional lights; (position,1) for point/spot lights.
unity_LightAtten   // half4[8]   Light attenuation factors. x is cos(spotAngle/2) or –1 for non-spot lights; y is 1/cos(spotAngle/4) or 1 for non-spot lights; z is quadratic attenuation; w is squared light range.
unity_SpotDirection   // float4[8]   View-space spot light positions; (0,0,1,0) for non-spot lights.

// #Ambient
unity_AmbientSky   // fixed4   Sky ambient lighting color in gradient ambient lighting case.
unity_AmbientEquator   // fixed4   Equator ambient lighting color in gradient ambient lighting case.
unity_AmbientGround   // fixed4   Ground ambient lighting color in gradient ambient lighting case.

// #Fog
// UNITY_LIGHTMODEL_AMBIENT   // fixed4   Ambient lighting color (sky color in gradient ambient case). Legacy variable.
unity_FogColor   // fixed4   Fog color.
unity_FogParams   // float4   Parameters for fog calculation: (density / sqrt(ln(2)), density / ln(2), –1/(end-start), end/(end-start)). x is useful for Exp2 fog mode, y for Exp mode, z and w for Linear mode.

// #LOD
unity_LODFade // float4 Level-of-detail fade when using LODGroup. x is fade (0..1), y is fade quantized to 16 levels, z and w unused.

//-------------------
//-- #TRANSPARENCY --
//-------------------

// #ALPHA TEST TRANSPARENCY == // (aka #CUTOFF, #CUTOUT)

// To make a thing transparent:
// Make sure you use have these 2 tags:
Tags {
"Queue" = "AlphaTest"
"RenderType" = "TransparentCutout"
}

// In frag shader add:
clip(col.a - 0.5); // this 0.5 is the cutoff value, you can put it in a variable or property

// #ALPHA BLEND TRANSPARENCY

Tags {
"Queue"="Transparent"
"RenderType"="Transparent"
}

// Use one of the Blend modes see BLEND MODES
Blend SrcAlpha OneMinusSrcAlpha
ColorMask RGB
ZWrite Off
//Cull Off // optional

//----------
//-- #FOG --
//----------

// Unity provides some useful macros for implementing built-in fog that can be configured in Lighting tab
#pragma multi_compile_fog

#include "UnityCG.cginc"

// inside your v2f struct add:
struct v2f {
...
UNITY_FOG_COORDS(1) // the number (1) is an unused TEXCOORD-number, so if you already have TEXCOORD1, use (2)
}

// in the vert shader add UNITY_TRANSFER_FOG
v2f vert (appdata_t v) {
   v2f o;
   ...
   UNITY_TRANSFER_FOG(o,o.vertex);
   return o;
}

// add UNITY_APPLY_FOG to your frag shader like
fixed4 frag (v2f i) : SV_Target {
   ...
   UNITY_APPLY_FOG(i.fogCoord, col); // i.fogCoord is generated by UNITY_FOG_COORDS
   return col;
}

//-----------------------------------
//-- #GPU INSTANCING - #INSTANCING --
//-----------------------------------

#pragma multi_compile_instancing

#include "UnityCG.cginc"

struct appdata_t {
...
UNITY_VERTEX_INPUT_INSTANCE_ID
};

// It seems that this block required even tho you don't have any per instance properties
UNITY_INSTANCING_BUFFER_START(Props)
UNITY_DEFINE_INSTANCED_PROP(fixed4, _Color) // Make _Color an instanced property (i.e. an array)
#define _Color_arr Props
UNITY_INSTANCING_BUFFER_END(Props)

v2f vert (appdata_t v)
{
   v2f o;
   UNITY_SETUP_INSTANCE_ID(v);
   ...
   return o;
}

//-------------------------------
//-- #VR - #STEREO SINGLE PASS --
//-------------------------------

// To support stereo single pass you need to put these macros to pass the eye index to the fragment shader.
// For example, if you’re using any of the view or projection matrices or the camera position in the fragment shader
// these need the eye index to give the correct value, otherwise you’ll always access the left eye.

#include "UnityCG.cginc"

struct appdata_t {
...
UNITY_VERTEX_INPUT_INSTANCE_ID
}

struct v2f {
...
UNITY_VERTEX_OUTPUT_STEREO
}

v2f vert (appdata_t v)
{
   v2f o;
   UNITY_SETUP_INSTANCE_ID(); // for single pass instanced. Not necessary?
   UNITY_INITIALIZE_OUTPUT(v2f, o); // for single pass instanced. Not necessary?
   UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
   ...
   return o;
}

// in frag shader, eye can be accessed with
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i)
// but it is not necessary, unless you are writing a post shader for example

//---------------------------------------------------
//-- #MULTI_COMPILE #SHADER KEYWORDS #KEYWORDS ------
//---------------------------------------------------

// using multi_compile directives enables making multiple shader variants #pragma multi_compile VARIANT_1 VARIANT_2 etc..

//-------------
// 2 VARIANTS

// with 2 variants, using __ will assume the "off" variant, you can write it like:
#pragma multi_compile __ THINGY

// use in code as:
#if defined(THINGY)
// do something when enabled
#else
// do something when disabled
#endif

// to create a property that will toggle it:
[Toggle(THINGY)] _Thingy("Thingy", Float) = 0 // the name of the property (_Thingy in this case) doesn't seem to be relevant

// or you can toggle from code using Shader.EnableKeyword/DisableKeyword or Material.EnableKeyword/DisableKeyword

//--------------------
// MULTIPLE VARIANTS

#pragma multi_compile _SOMETHING_THIS _SOMETHING_ELSE _SOMETHING_OTHERWISE

// use similar to the above:
#if defined(_SOMETHING_THIS)
// do something only when SOMETHING_1 is defined
#endif

// Auto-property for more than 2 variants.
// Each name will enable "property name" + underscore + "enum name", uppercased, shader keyword. Up to 9 names can be provided.
[KeywordEnum(This, Else, Otherwise)] _Something("Something?", Float) = 0 // Here the property name IS relevant

//-------------------------------
//-- #SHADOW CASTING ------------
//-------------------------------

// incomplete, not tested

Pass
{
Tags{ "LightMode" = "ShadowCaster" }

   Fog{ Mode Off }
   ZWrite On ZTest Less Cull Off
   Offset 1, 1

   CGPROGRAM

       #pragma vertex vert
       #pragma fragment frag
       #pragma multi_compile_shadowcaster
       #pragma fragmentoption ARB_precision_hint_fastest

       #include "UnityCG.cginc"

       struct v2f
       {
           V2F_SHADOW_CASTER;
       };

       v2f vert(appdata_base v)
       {
           v2f o;
           TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
           return o;
       }

       float4 frag(v2f i) : COLOR
       {
           SHADOW_CASTER_FRAGMENT(i)
       }

ENDCG
}

//-----------------------------------------------//
//-----------------------------------------------//
//---------- SURFACE SHADERS ------------//
//-----------------------------------------------//
//-----------------------------------------------//

// #SURFACE SHADERS

Shader "Example/Diffuse Simple"
{
   Properties // See PROPERTIES
   {

   }

SubShader // Note, SubShader, unlike "Pass" in vert/frag shaders
{
Tags // see tags. Note, tags inside the SubShader {} unlike vert/frag shaders

   CGPROGRAM
   #pragma surface surf Lambert

   struct Input {
   float4 color : COLOR;
   };

   void surf (Input IN, inout SurfaceOutput o) {
   o.Albedo = 1;
   }

ENDCG
}
Fallback "Diffuse"
}

//
IN.worldNormal
IN.viewDir

收录于