Problems creating a 3D/2D mix game

RafaelDeJota · Jun 19, 2019

Hey,

I am a game art student and I usually don't have to get very deep into unity to get my part of projects done. However, I decided to challenge myself to make a game in unity by myself. Game play wise things have been smooth, but graphics, ironically have become a problem.
I want to recreate or emulate, the graphic style of games like "The Last Light" and "Octopath Traveller", mixing 3D environments and pixel art. My problem is with the characters, they use sprite shaders by default, which don't react to light, so i had to change it to something else. But nothing seems to work 100%.

If I use other sprite shaders, the depth of field will affect them in weird way. The parts of the sprite that are over far away objects will blur even if the sprite itself is in a distance that the effect should not happen.

If I try with a "standard material" with cut out, the deph of field works ok but the sprite cant be flipped, since the normal's now point backwards, so I cant play the animations to the other direction.

The closest I've come to a solution was a double sided shader, but the ones that I've come across have a pretty fatal flaw, the lighting from the behind becomes the one in the front. I think the normals in the back face are inverted and I dont know almost anything about shaders to be able to fix this.

Any help would be great!

kdgalla · Jun 19, 2019

RafaelDeJota said: ↑

If I try with a "standard material" with cut out, the deph of field works ok but the sprite cant be flipped, since the normal's now point backwards, so I cant play the animations to the other direction.
Click to expand...

How are you flipping these? If you have a quad and rotate 180 it won't work, but if you scale the quad by (-1,1,1) then the quad will be reversed, but the normal will still face the same direction.

RafaelDeJota · Jun 19, 2019

I have scaled it by (-1,1,1), that is the weird part. The lighting from the back part, with the yellow tint is showing in the front.
You can see it here:
there is a yellow light above and behind these two objects. The one on the right has been scaled by (-1,1,1)

And here is the back view with the inverted one on the left, not being affected by the light right next to it

kdgalla · Jun 19, 2019

Are you using normal maps?

RafaelDeJota · Jun 19, 2019

yes

kdgalla · Jun 19, 2019

Ah, I didn't realize that at first. I don't think normal maps work flipped. You might have to make a separate set of sprites for each direction.

RafaelDeJota · Jun 19, 2019

Yeah, its the only option apparently, the resolution of the characters is so small that this will not have much impact on size, but it sure will be annoying having to duplicate them on the sprite sheet.
Thanks for the help anyway.

If else anyone come across this, this is the double sided shader i was using, it can be freely downloaded here https://assetstore.unity.com/packages/vfx/shaders/double-sided-shaders-23087

If anyone finds whats making this happen it would make my life a quite bit easier.

Code (CSharp):

Shader "Ciconia Studio/Double Sided/Transparent/Diffuse Bump Cutout" {

Properties {

_Color ("Diffuse Color", Color) = (1,1,1,1)

_MainTex ("Diffuse map (Cutout A)", 2D) = "white" {}

_BumpMap ("Normal map", 2D) = "bump" {}

_NormalIntensity ("Normal Intensity", Range(0, 2)) = 1

_SpecGlossMap ("Specular map", 2D) = "white" {}

_SpecColor ("Specular Color", Color) = (1,1,1,1)

_SpecularIntensity ("Specular Intensity", Range(0, 2)) = 0.2

_Glossiness ("Glossiness", Range(0, 1)) = 0.5

[HideInInspector]_Cutoff ("Alpha cutoff", Range(0,1)) = 0.5

}

SubShader {

Tags {

"Queue"="AlphaTest"

"RenderType"="TransparentCutout"

}

Pass {

Name "FORWARD"

Tags {

"LightMode"="ForwardBase"

}

Cull Off

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

#define _GLOSSYENV 1

#include "UnityCG.cginc"

#include "AutoLight.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "UnityStandardBRDF.cginc"

#pragma multi_compile_fwdbase_fullshadows

#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

#pragma multi_compile_fog

#pragma only_renderers d3d9 d3d11 glcore gles gles3 metal d3d11_9x xboxone ps4 psp2 n3ds wiiu

#pragma target 3.0

uniform sampler2D _MainTex; uniform float4 _MainTex_ST;

uniform float4 _Color;

uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;

uniform float _NormalIntensity;

uniform sampler2D _SpecGlossMap; uniform float4 _SpecGlossMap_ST;

uniform float _SpecularIntensity;

uniform float _Glossiness;

struct VertexInput {

float4 vertex : POSITION;

float3 normal : NORMAL;

float4 tangent : TANGENT;

float2 texcoord0 : TEXCOORD0;

float2 texcoord1 : TEXCOORD1;

float2 texcoord2 : TEXCOORD2;

};

struct VertexOutput {

float4 pos : SV_POSITION;

float2 uv0 : TEXCOORD0;

float2 uv1 : TEXCOORD1;

float2 uv2 : TEXCOORD2;

float4 posWorld : TEXCOORD3;

float3 normalDir : TEXCOORD4;

float3 tangentDir : TEXCOORD5;

float3 bitangentDir : TEXCOORD6;

LIGHTING_COORDS(7,8)

UNITY_FOG_COORDS(9)

#if defined(LIGHTMAP_ON) || defined(UNITY_SHOULD_SAMPLE_SH)

float4 ambientOrLightmapUV : TEXCOORD10;

#endif

};

VertexOutput vert (VertexInput v) {

VertexOutput o = (VertexOutput)0;

o.uv0 = v.texcoord0;

o.uv1 = v.texcoord1;

o.uv2 = v.texcoord2;

#ifdef LIGHTMAP_ON

o.ambientOrLightmapUV.xy = v.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;

o.ambientOrLightmapUV.zw = 0;

#endif

#ifdef DYNAMICLIGHTMAP_ON

o.ambientOrLightmapUV.zw = v.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;

#endif

o.normalDir = UnityObjectToWorldNormal(v.normal);

o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );

o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);

o.posWorld = mul(unity_ObjectToWorld, v.vertex);

float3 lightColor = _LightColor0.rgb;

o.pos = UnityObjectToClipPos( v.vertex );

UNITY_TRANSFER_FOG(o,o.pos);

TRANSFER_VERTEX_TO_FRAGMENT(o)

return o;

}

float4 frag(VertexOutput i, float facing : VFACE) : COLOR {

float isFrontFace = ( facing >= 0 ? 1 : 0 );

float faceSign = ( facing >= 0 ? 1 : -1 );

i.normalDir = normalize(i.normalDir);

i.normalDir *= faceSign;

float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);

float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));

float3 normalLocal = lerp(float3(0,0,1),_BumpMap_var.rgb,_NormalIntensity);

float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals

float3 viewReflectDirection = reflect( -viewDirection, normalDirection );

float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));

clip(_MainTex_var.a - 0.5);

float3 lightDirection = normalize(_WorldSpaceLightPos0.xyz);

float3 lightColor = _LightColor0.rgb;

float3 halfDirection = normalize(viewDirection+lightDirection);

////// Lighting:

UNITY_LIGHT_ATTENUATION(attenuation,i, i.posWorld.xyz);

float3 attenColor = attenuation * _LightColor0.xyz;

float Pi = 3.141592654;

float InvPi = 0.31830988618;

///////// Gloss:

float gloss = _Glossiness;

float perceptualRoughness = 1.0 - _Glossiness;

float roughness = perceptualRoughness * perceptualRoughness;

float specPow = exp2( gloss * 10.0 + 1.0 );

/////// GI Data:

UnityLight light;

#ifdef LIGHTMAP_OFF

light.color = lightColor;

light.dir = lightDirection;

light.ndotl = LambertTerm (normalDirection, light.dir);

#else

light.color = half3(0.f, 0.f, 0.f);

light.ndotl = 0.0f;

light.dir = half3(0.f, 0.f, 0.f);

#endif

UnityGIInput d;

d.light = light;

d.worldPos = i.posWorld.xyz;

d.worldViewDir = viewDirection;

d.atten = attenuation;

#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)

d.ambient = 0;

d.lightmapUV = i.ambientOrLightmapUV;

#else

d.ambient = i.ambientOrLightmapUV;

#endif

#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION

d.boxMin[0] = unity_SpecCube0_BoxMin;

d.boxMin[1] = unity_SpecCube1_BoxMin;

#endif

#if UNITY_SPECCUBE_BOX_PROJECTION

d.boxMax[0] = unity_SpecCube0_BoxMax;

d.boxMax[1] = unity_SpecCube1_BoxMax;

d.probePosition[0] = unity_SpecCube0_ProbePosition;

d.probePosition[1] = unity_SpecCube1_ProbePosition;

#endif

d.probeHDR[0] = unity_SpecCube0_HDR;

d.probeHDR[1] = unity_SpecCube1_HDR;

Unity_GlossyEnvironmentData ugls_en_data;

ugls_en_data.roughness = 1.0 - gloss;

ugls_en_data.reflUVW = viewReflectDirection;

UnityGI gi = UnityGlobalIllumination(d, 1, normalDirection, ugls_en_data );

lightDirection = gi.light.dir;

lightColor = gi.light.color;

////// Specular:

float NdotL = saturate(dot( normalDirection, lightDirection ));

float LdotH = saturate(dot(lightDirection, halfDirection));

float4 _SpecGlossMap_var = tex2D(_SpecGlossMap,TRANSFORM_TEX(i.uv0, _SpecGlossMap));

float3 specularColor = ((_SpecGlossMap_var.rgb*_SpecularIntensity)*_SpecColor.rgb);

float specularMonochrome;

float3 diffuseColor = (_MainTex_var.rgb*_Color.rgb); // Need this for specular when using metallic

diffuseColor = EnergyConservationBetweenDiffuseAndSpecular(diffuseColor, specularColor, specularMonochrome);

specularMonochrome = 1.0-specularMonochrome;

float NdotV = abs(dot( normalDirection, viewDirection ));

float NdotH = saturate(dot( normalDirection, halfDirection ));

float VdotH = saturate(dot( viewDirection, halfDirection ));

float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, roughness );

float normTerm = GGXTerm(NdotH, roughness);

float specularPBL = (visTerm*normTerm) * UNITY_PI;

#ifdef UNITY_COLORSPACE_GAMMA

specularPBL = sqrt(max(1e-4h, specularPBL));

#endif

specularPBL = max(0, specularPBL * NdotL);

#if defined(_SPECULARHIGHLIGHTS_OFF)

specularPBL = 0.0;

#endif

half surfaceReduction;

#ifdef UNITY_COLORSPACE_GAMMA

surfaceReduction = 1.0-0.28*roughness*perceptualRoughness;

#else

surfaceReduction = 1.0/(roughness*roughness + 1.0);

#endif

specularPBL *= any(specularColor) ? 1.0 : 0.0;

float3 directSpecular = attenColor*specularPBL*FresnelTerm(specularColor, LdotH);

half grazingTerm = saturate( gloss + specularMonochrome );

float3 indirectSpecular = (gi.indirect.specular);

indirectSpecular *= FresnelLerp (specularColor, grazingTerm, NdotV);

indirectSpecular *= surfaceReduction;

float3 specular = (directSpecular + indirectSpecular);

/////// Diffuse:

NdotL = max(0.0,dot( normalDirection, lightDirection ));

half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);

float nlPow5 = Pow5(1-NdotL);

float nvPow5 = Pow5(1-NdotV);

float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;

float3 indirectDiffuse = float3(0,0,0);

indirectDiffuse += gi.indirect.diffuse;

diffuseColor *= 1-specularMonochrome;

float3 diffuse = (directDiffuse + indirectDiffuse) * diffuseColor;

/// Final Color:

float3 finalColor = diffuse + specular;

fixed4 finalRGBA = fixed4(finalColor,1);

UNITY_APPLY_FOG(i.fogCoord, finalRGBA);

return finalRGBA;

}

ENDCG

}

Pass {

Name "FORWARD_DELTA"

Tags {

"LightMode"="ForwardAdd"

}

Blend One One

Cull Off

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

#define _GLOSSYENV 1

#include "UnityCG.cginc"

#include "AutoLight.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "UnityStandardBRDF.cginc"

#pragma multi_compile_fwdadd_fullshadows

#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

#pragma multi_compile_fog

#pragma only_renderers d3d9 d3d11 glcore gles gles3 metal d3d11_9x xboxone ps4 psp2 n3ds wiiu

#pragma target 3.0

uniform sampler2D _MainTex; uniform float4 _MainTex_ST;

uniform float4 _Color;

uniform sampler2D _BumpMap; uniform float4 _BumpMap_ST;

uniform float _NormalIntensity;

uniform sampler2D _SpecGlossMap; uniform float4 _SpecGlossMap_ST;

uniform float _SpecularIntensity;

uniform float _Glossiness;

struct VertexInput {

float4 vertex : POSITION;

float3 normal : NORMAL;

float4 tangent : TANGENT;

float2 texcoord0 : TEXCOORD0;

float2 texcoord1 : TEXCOORD1;

float2 texcoord2 : TEXCOORD2;

};

struct VertexOutput {

float4 pos : SV_POSITION;

float2 uv0 : TEXCOORD0;

float2 uv1 : TEXCOORD1;

float2 uv2 : TEXCOORD2;

float4 posWorld : TEXCOORD3;

float3 normalDir : TEXCOORD4;

float3 tangentDir : TEXCOORD5;

float3 bitangentDir : TEXCOORD6;

LIGHTING_COORDS(7,8)

UNITY_FOG_COORDS(9)

};

VertexOutput vert (VertexInput v) {

VertexOutput o = (VertexOutput)0;

o.uv0 = v.texcoord0;

o.uv1 = v.texcoord1;

o.uv2 = v.texcoord2;

o.normalDir = UnityObjectToWorldNormal(v.normal);

o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );

o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);

o.posWorld = mul(unity_ObjectToWorld, v.vertex);

float3 lightColor = _LightColor0.rgb;

o.pos = UnityObjectToClipPos( v.vertex );

UNITY_TRANSFER_FOG(o,o.pos);

TRANSFER_VERTEX_TO_FRAGMENT(o)

return o;

}

float4 frag(VertexOutput i, float facing : VFACE) : COLOR {

float isFrontFace = ( facing >= 0 ? 1 : 0 );

float faceSign = ( facing >= 0 ? 1 : -1 );

i.normalDir = normalize(i.normalDir);

i.normalDir *= faceSign;

float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);

float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

float3 _BumpMap_var = UnpackNormal(tex2D(_BumpMap,TRANSFORM_TEX(i.uv0, _BumpMap)));

float3 normalLocal = lerp(float3(0,0,1),_BumpMap_var.rgb,_NormalIntensity);

float3 normalDirection = normalize(mul( normalLocal, tangentTransform )); // Perturbed normals

float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));

clip(_MainTex_var.a - 0.5);

float3 lightDirection = normalize(lerp(_WorldSpaceLightPos0.xyz, _WorldSpaceLightPos0.xyz - i.posWorld.xyz,_WorldSpaceLightPos0.w));

float3 lightColor = _LightColor0.rgb;

float3 halfDirection = normalize(viewDirection+lightDirection);

////// Lighting:

UNITY_LIGHT_ATTENUATION(attenuation,i, i.posWorld.xyz);

float3 attenColor = attenuation * _LightColor0.xyz;

float Pi = 3.141592654;

float InvPi = 0.31830988618;

///////// Gloss:

float gloss = _Glossiness;

float perceptualRoughness = 1.0 - _Glossiness;

float roughness = perceptualRoughness * perceptualRoughness;

float specPow = exp2( gloss * 10.0 + 1.0 );

////// Specular:

float NdotL = saturate(dot( normalDirection, lightDirection ));

float LdotH = saturate(dot(lightDirection, halfDirection));

float4 _SpecGlossMap_var = tex2D(_SpecGlossMap,TRANSFORM_TEX(i.uv0, _SpecGlossMap));

float3 specularColor = ((_SpecGlossMap_var.rgb*_SpecularIntensity)*_SpecColor.rgb);

float specularMonochrome;

float3 diffuseColor = (_MainTex_var.rgb*_Color.rgb); // Need this for specular when using metallic

diffuseColor = EnergyConservationBetweenDiffuseAndSpecular(diffuseColor, specularColor, specularMonochrome);

specularMonochrome = 1.0-specularMonochrome;

float NdotV = abs(dot( normalDirection, viewDirection ));

float NdotH = saturate(dot( normalDirection, halfDirection ));

float VdotH = saturate(dot( viewDirection, halfDirection ));

float visTerm = SmithJointGGXVisibilityTerm( NdotL, NdotV, roughness );

float normTerm = GGXTerm(NdotH, roughness);

float specularPBL = (visTerm*normTerm) * UNITY_PI;

#ifdef UNITY_COLORSPACE_GAMMA

specularPBL = sqrt(max(1e-4h, specularPBL));

#endif

specularPBL = max(0, specularPBL * NdotL);

#if defined(_SPECULARHIGHLIGHTS_OFF)

specularPBL = 0.0;

#endif

specularPBL *= any(specularColor) ? 1.0 : 0.0;

float3 directSpecular = attenColor*specularPBL*FresnelTerm(specularColor, LdotH);

float3 specular = directSpecular;

/////// Diffuse:

NdotL = max(0.0,dot( normalDirection, lightDirection ));

half fd90 = 0.5 + 2 * LdotH * LdotH * (1-gloss);

float nlPow5 = Pow5(1-NdotL);

float nvPow5 = Pow5(1-NdotV);

float3 directDiffuse = ((1 +(fd90 - 1)*nlPow5) * (1 + (fd90 - 1)*nvPow5) * NdotL) * attenColor;

diffuseColor *= 1-specularMonochrome;

float3 diffuse = directDiffuse * diffuseColor;

/// Final Color:

float3 finalColor = diffuse + specular;

fixed4 finalRGBA = fixed4(finalColor * 1,0);

UNITY_APPLY_FOG(i.fogCoord, finalRGBA);

return finalRGBA;

}

ENDCG

}

Pass {

Name "ShadowCaster"

Tags {

"LightMode"="ShadowCaster"

}

Offset 1, 1

Cull Off

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

#define _GLOSSYENV 1

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "UnityStandardBRDF.cginc"

#pragma fragmentoption ARB_precision_hint_fastest

#pragma multi_compile_shadowcaster

#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

#pragma multi_compile_fog

#pragma only_renderers d3d9 d3d11 glcore gles gles3 metal d3d11_9x xboxone ps4 psp2 n3ds wiiu

#pragma target 3.0

uniform sampler2D _MainTex; uniform float4 _MainTex_ST;

struct VertexInput {

float4 vertex : POSITION;

float2 texcoord0 : TEXCOORD0;

float2 texcoord1 : TEXCOORD1;

float2 texcoord2 : TEXCOORD2;

};

struct VertexOutput {

V2F_SHADOW_CASTER;

float2 uv0 : TEXCOORD1;

float2 uv1 : TEXCOORD2;

float2 uv2 : TEXCOORD3;

float4 posWorld : TEXCOORD4;

};

VertexOutput vert (VertexInput v) {

VertexOutput o = (VertexOutput)0;

o.uv0 = v.texcoord0;

o.uv1 = v.texcoord1;

o.uv2 = v.texcoord2;

o.posWorld = mul(unity_ObjectToWorld, v.vertex);

o.pos = UnityObjectToClipPos( v.vertex );

TRANSFER_SHADOW_CASTER(o)

return o;

}

float4 frag(VertexOutput i, float facing : VFACE) : COLOR {

float isFrontFace = ( facing >= 0 ? 1 : 0 );

float faceSign = ( facing >= 0 ? 1 : -1 );

float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));

clip(_MainTex_var.a - 0.5);

SHADOW_CASTER_FRAGMENT(i)

}

ENDCG

}

Pass {

Name "Meta"

Tags {

"LightMode"="Meta"

}

Cull Off

CGPROGRAM

#pragma vertex vert

#pragma fragment frag

#define SHOULD_SAMPLE_SH ( defined (LIGHTMAP_OFF) && defined(DYNAMICLIGHTMAP_OFF) )

#define _GLOSSYENV 1

#include "UnityCG.cginc"

#include "Lighting.cginc"

#include "UnityPBSLighting.cginc"

#include "UnityStandardBRDF.cginc"

#include "UnityMetaPass.cginc"

#pragma fragmentoption ARB_precision_hint_fastest

#pragma multi_compile_shadowcaster

#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON

#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE

#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON

#pragma multi_compile_fog

#pragma only_renderers d3d9 d3d11 glcore gles gles3 metal d3d11_9x xboxone ps4 psp2 n3ds wiiu

#pragma target 3.0

uniform sampler2D _MainTex; uniform float4 _MainTex_ST;

uniform float4 _Color;

uniform sampler2D _SpecGlossMap; uniform float4 _SpecGlossMap_ST;

uniform float _SpecularIntensity;

uniform float _Glossiness;

struct VertexInput {

float4 vertex : POSITION;

float2 texcoord0 : TEXCOORD0;

float2 texcoord1 : TEXCOORD1;

float2 texcoord2 : TEXCOORD2;

};

struct VertexOutput {

float4 pos : SV_POSITION;

float2 uv0 : TEXCOORD0;

float2 uv1 : TEXCOORD1;

float2 uv2 : TEXCOORD2;

float4 posWorld : TEXCOORD3;

};

VertexOutput vert (VertexInput v) {

VertexOutput o = (VertexOutput)0;

o.uv0 = v.texcoord0;

o.uv1 = v.texcoord1;

o.uv2 = v.texcoord2;

o.posWorld = mul(unity_ObjectToWorld, v.vertex);

o.pos = UnityMetaVertexPosition(v.vertex, v.texcoord1.xy, v.texcoord2.xy, unity_LightmapST, unity_DynamicLightmapST );

return o;

}

float4 frag(VertexOutput i, float facing : VFACE) : SV_Target {

float isFrontFace = ( facing >= 0 ? 1 : 0 );

float faceSign = ( facing >= 0 ? 1 : -1 );

float3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

UnityMetaInput o;

UNITY_INITIALIZE_OUTPUT( UnityMetaInput, o );

o.Emission = 0;

float4 _MainTex_var = tex2D(_MainTex,TRANSFORM_TEX(i.uv0, _MainTex));

float3 diffColor = (_MainTex_var.rgb*_Color.rgb);

float4 _SpecGlossMap_var = tex2D(_SpecGlossMap,TRANSFORM_TEX(i.uv0, _SpecGlossMap));

float3 specColor = ((_SpecGlossMap_var.rgb*_SpecularIntensity)*_SpecColor.rgb);

float specularMonochrome = max(max(specColor.r, specColor.g),specColor.b);

diffColor *= (1.0-specularMonochrome);

float roughness = 1.0 - _Glossiness;

o.Albedo = diffColor + specColor * roughness * roughness * 0.5;

return UnityMetaFragment( o );

}

ENDCG

}

}

FallBack "Diffuse"

}

Search Unity

Unity ID

Useful Searches

Problems creating a 3D/2D mix game

RafaelDeJota

kdgalla

RafaelDeJota

kdgalla

RafaelDeJota

kdgalla

RafaelDeJota