Unity Hvordan lage en Shader
Shader er et lite skript som inneholder matematiske beregninger og algoritmer for å beregne fargen på hver piksel som gjengis, basert på lysinndata og materialkonfigurasjon.
Unity bruker Shaders som er skrevet på følgende språk:
- Et programmeringsspråk kalt HLSL brukes til å skrive shader-programmene selv.
- Et Unity-spesifikt språk kalt ShaderLab brukes til å definere et Shader-objekt, som fungerer som en beholder for shader-programmene.
Følg trinnene nedenfor for å lage en skyggelegging i Unity:
Lag en Shader
- Høyreklikk på prosjektvisningen -> 'Create' -> 'Shader'
Avhengig av Unity-versjonen du bruker, kan Shader-alternativene variere, men her er hva hvert av alternativene betyr:
- 'Standard Surface Shader': Denne shaderen er designet for å fungere med Unity's Physical Based Rendering (PBR) system. Det lar utviklere lage materialer som reagerer realistisk på lysforholdene. Den støtter ulike gjengivelsesfunksjoner som normal kartlegging, speilhøydepunkter og refleksjoner. Det er en allsidig shader som gir en god balanse mellom realisme og ytelse.
- 'Unlit Shader': Som navnet antyder, tar en uopplyst skygge ikke lysforhold i betraktning. Den brukes ofte til å gjengi effekter som ikke trenger realistisk belysning, for eksempel UI-elementer, partikkelsystemer eller spesialeffekter. Uopplyste shaders er vanligvis mer effektive og kan være nyttige i situasjoner der det krever full kontroll over utseendet til et objekt uten noen lysberegninger.
- 'Image Effect Shader': bildeeffekten shaders brukes til å bruke etterbehandling-effekter på hele skjermen eller spesifikke gjengivelsesmål. De lar utviklere endre det endelige gjengitte bildet etter at hovedgjengivelsen er fullført. Eksempler på bildeeffekter inkluderer uskarphet, fargegradering, forvrengning eller stiliserte filtre. De kan brukes til å forbedre den visuelle kvaliteten eller lage spesifikke kunstneriske effekter.
- 'Compute Shader': En dataskyggelegging er en type skyggelegging som kjører på GPUen, men som ikke opererer direkte på piksler. Den brukes til generelle beregninger på parallelle data, slik at utviklere kan utføre komplekse beregninger eller simuleringer effektivt. Compute shaders brukes ofte til oppgaver som fysikksimuleringer, prosedyregenerering eller databehandling.
- 'Ray Tracing Shader': Ray tracing shaders bruker ray tracing teknologi, som simulerer oppførselen til lys mer nøyaktig sammenlignet med tradisjonelle rasteriseringsteknikker. Ray tracing shaders brukes vanligvis for å oppnå svært realistisk belysning, refleksjoner og skygger i sanntidsapplikasjoner. De krever kraftig maskinvare og brukes ofte i grafikkintensive felt som spill eller arkitektonisk visualisering.
- Etter å ha valgt skyggelegging, skriv inn et hvilket som helst navn og trykk Enter
Den nye Shader er opprettet og kan åpnes i et hvilket som helst skriptredigeringsprogram og modifiseres for å passe dine behov.
Standard 'Standard Surface Shader':
Shader "Custom/NewSurfaceShader"
{
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
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
// Physically based Standard lighting model, and enable shadows on all light types
#pragma surface surf Standard fullforwardshadows
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
sampler2D _MainTex;
struct Input
{
float2 uv_MainTex;
};
half _Glossiness;
half _Metallic;
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
void surf (Input IN, inout SurfaceOutputStandard o)
{
// Albedo comes from a texture tinted by color
fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
o.Albedo = c.rgb;
// Metallic and smoothness come from slider variables
o.Metallic = _Metallic;
o.Smoothness = _Glossiness;
o.Alpha = c.a;
}
ENDCG
}
FallBack "Diffuse"
}Standard 'Unlit Shader':
Shader "Unlit/NewUnlitShader"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
}
SubShader
{
Tags { "RenderType"="Opaque" }
LOD 100
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
// make fog work
#pragma multi_compile_fog
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
UNITY_FOG_COORDS(1)
float4 vertex : SV_POSITION;
};
sampler2D _MainTex;
float4 _MainTex_ST;
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = TRANSFORM_TEX(v.uv, _MainTex);
UNITY_TRANSFER_FOG(o,o.vertex);
return o;
}
fixed4 frag (v2f i) : SV_Target
{
// sample the texture
fixed4 col = tex2D(_MainTex, i.uv);
// apply fog
UNITY_APPLY_FOG(i.fogCoord, col);
return col;
}
ENDCG
}
}
}Standard 'Image Effect Shader':
Shader "Hidden/NewImageEffectShader"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
}
SubShader
{
// No culling or depth
Cull Off ZWrite Off ZTest Always
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
struct appdata
{
float4 vertex : POSITION;
float2 uv : TEXCOORD0;
};
struct v2f
{
float2 uv : TEXCOORD0;
float4 vertex : SV_POSITION;
};
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
o.uv = v.uv;
return o;
}
sampler2D _MainTex;
fixed4 frag (v2f i) : SV_Target
{
fixed4 col = tex2D(_MainTex, i.uv);
// just invert the colors
col.rgb = 1 - col.rgb;
return col;
}
ENDCG
}
}
}Standard 'Compute Shader':
// Each #kernel tells which function to compile; you can have many kernels
#pragma kernel CSMain
// Create a RenderTexture with enableRandomWrite flag and set it
// with cs.SetTexture
RWTexture2D<float4> Result;
[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
// TODO: insert actual code here!
Result[id.xy] = float4(id.x & id.y, (id.x & 15)/15.0, (id.y & 15)/15.0, 0.0);
}Standard 'Ray Tracing Shader':
RWTexture2D<float4> RenderTarget;
#pragma max_recursion_depth 1
[shader("raygeneration")]
void MyRaygenShader()
{
uint2 dispatchIdx = DispatchRaysIndex().xy;
RenderTarget[dispatchIdx] = float4(dispatchIdx.x & dispatchIdx.y, (dispatchIdx.x & 15)/15.0, (dispatchIdx.y & 15)/15.0, 0.0);
}Konklusjon
Hver shader-type har sine egne styrker og bruksområder. Det er viktig å velge riktig skyggelegging basert på dine spesifikke krav og de visuelle effektene du ønsker å oppnå i prosjektet.