Problem: Unity only showing the back face only of my model

Hi I have a major problem on my project that I am stuck with and have a deadline of the 24 Nov fast approaching and wonder if anyone can help or has had this same problem of mine.

I have a model of a engine part of a motorbike in a .IGS file format, that renders completely fine in Cinema 4D, however when putting it into Unity it only show the back faces of the model.

I have tried changing the normals, aligning them in Cinema 4D and putting it back into Unity but there is no change.

Also when putting the IGS file into Cinema 4D it comes up with a list of IGS import options. Is there something that I need to select in that at all that I have missed?

I would be grateful for any help. thanks.

I'm quite sure that Unity only shows the front faces of your model. Which means you'll have to flip them in Cinema 4D (there should be some operation called flip normals or flip faces).

You can also try and get Unity to render both faces. You can do this by either writing your own shader (if you don't know how, you might wanna check out the node based shader editor.

Alternatively you can use one of the Unity shaders that already renders both sides (although they all don't do lighting).

Or.. you just go to one of the forum threads where this has been thoroughly discussed already and copy a shader from there.

I had the exact same problem. I had a model that rendered perfectly in Cinema 4D but when I exported it to Unity it was invisible. After a while I figured out the model's normals were reversed. I also tried to align the normals and reverse them but that didn't solve it.

However, I found a solution. I hope it works for you too because this one is quite simple and then you shouldn't worry about shaders. What I did: I selected the polygons in my model and used the function "Triangulate". When I exported this triangulated model, everything worked perfectly.

Side note: I exported my models in the .FBX format, don't know if that has anything to do with it but you could try that.

Btw, you could turn on backface culling in Cinema 4D, this way Cinema 4D will make backfaces invisible, just like Unity and you don't get any unexpected results. To turn it on go to Display -> Backface Culling.

Grettings from Mxico

1.- Open your model in cinema

2.- Select al poligons in your mesh

3.- In functions pull down use align normals *and reverse* if necesary. (negative is blue and not render in unity, positive is orange)

4.- save your model and try it in unity

5.- if some holes keep in your model back to cinema and triangulate the model (save a copy before this).

good luck!!

if u still facing problem after making normals into reverse, just extrude ur mesh to 1 percent. then u can see clear in unity.

I know the post is old, but since no one really gave an answer that you could solve without using extra 3D software, I’ll give these solutions:

-First of all, there was a way to invert the faces by using a script, so that if you imported a model into Unity and the faces were flipped, you could fix them by attaching a script. I just can’t remember where I’ve seen it.
Anyways, the first easy method (that I remember) is to shut the CULL OFF, so here is a shader that will do that (it’s the fully functional Standard Shader with Cull OFF):

//Save as 'StandardCullOFF.shader' and add to a mesh
Shader "StandardCullOFF"
    {
    	Properties
    	{
    		_Color("Color", Color) = (1,1,1,1)
    		_MainTex("Albedo", 2D) = "white" {}
    		
    		_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
    
    		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
    		_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
    		[Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0
    
    		[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
    		_MetallicGlossMap("Metallic", 2D) = "white" {}
    
    		[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
    		[ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
    
    		_BumpScale("Scale", Float) = 1.0
    		_BumpMap("Normal Map", 2D) = "bump" {}
    
    		_Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
    		_ParallaxMap ("Height Map", 2D) = "black" {}
    
    		_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
    		_OcclusionMap("Occlusion", 2D) = "white" {}
    
    		_EmissionColor("Color", Color) = (0,0,0)
    		_EmissionMap("Emission", 2D) = "white" {}
    		
    		_DetailMask("Detail Mask", 2D) = "white" {}
    
    		_DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
    		_DetailNormalMapScale("Scale", Float) = 1.0
    		_DetailNormalMap("Normal Map", 2D) = "bump" {}
    
    		[Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0
    
    
    		// Blending state
    		 _Mode ("__mode", Float) = 0.0
    		 _SrcBlend ("__src", Float) = 1.0
    		 _DstBlend ("__dst", Float) = 0.0
    		 _ZWrite ("__zw", Float) = 1.0
    	}
    
    	CGINCLUDE
    		#define UNITY_SETUP_BRDF_INPUT MetallicSetup
    	ENDCG
    
    	SubShader
    	{
    		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
    		LOD 300
    	
    
    		// ------------------------------------------------------------------
    		//  Base forward pass (directional light, emission, lightmaps, ...)
    		Pass
    		{
    			
    			Name "FORWARD" 
    			Tags { "LightMode" = "ForwardBase" }
    
    			Blend [_SrcBlend] [_DstBlend]
    			ZWrite [_ZWrite]
    			Cull Off
    
    			CGPROGRAM
    			#pragma target 3.0
    
    			// -------------------------------------
    
    			#pragma shader_feature _NORMALMAP
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _EMISSION
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature ___ _DETAIL_MULX2
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
    			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
    			#pragma shader_feature _PARALLAXMAP
    
    			#pragma multi_compile_fwdbase
    			#pragma multi_compile_fog
    
    			#pragma vertex vertBase
    			#pragma fragment fragBase
    			#include "UnityStandardCoreForward.cginc"
    
    			ENDCG
    		}
    		// ------------------------------------------------------------------
    		//  Additive forward pass (one light per pass)
    		Pass
    		{
    			Name "FORWARD_DELTA"
    			Tags { "LightMode" = "ForwardAdd" }
    			Blend [_SrcBlend] One
    			Fog { Color (0,0,0,0) } // in additive pass fog should be black
    			ZWrite Off
    			ZTest LEqual
    
    			CGPROGRAM
    			#pragma target 3.0
    
    			// -------------------------------------
    
    
    			#pragma shader_feature _NORMALMAP
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
    			#pragma shader_feature ___ _DETAIL_MULX2
    			#pragma shader_feature _PARALLAXMAP
    
    			#pragma multi_compile_fwdadd_fullshadows
    			#pragma multi_compile_fog
    
    
    			#pragma vertex vertAdd
    			#pragma fragment fragAdd
    			#include "UnityStandardCoreForward.cginc"
    
    			ENDCG
    		}
    		// ------------------------------------------------------------------
    		//  Shadow rendering pass
    		Pass {
    			Name "ShadowCaster"
    			Tags { "LightMode" = "ShadowCaster" }
    
    			ZWrite On ZTest LEqual
    
    			CGPROGRAM
    			#pragma target 3.0
    
    			// -------------------------------------
    
    
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _PARALLAXMAP
    			#pragma multi_compile_shadowcaster
    
    			#pragma vertex vertShadowCaster
    			#pragma fragment fragShadowCaster
    
    			#include "UnityStandardShadow.cginc"
    
    			ENDCG
    		}
    		// ------------------------------------------------------------------
    		//  Deferred pass
    		Pass
    		{
    			Name "DEFERRED"
    			Tags { "LightMode" = "Deferred" }
    
    			CGPROGRAM
    			#pragma target 3.0
    			#pragma exclude_renderers nomrt
    
    
    			// -------------------------------------
    
    			#pragma shader_feature _NORMALMAP
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _EMISSION
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
    			#pragma shader_feature ___ _DETAIL_MULX2
    			#pragma shader_feature _PARALLAXMAP
    
    			#pragma multi_compile ___ UNITY_HDR_ON
    			#pragma multi_compile ___ LIGHTMAP_ON
    			#pragma multi_compile ___ DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
    			#pragma multi_compile ___ DYNAMICLIGHTMAP_ON
    
    			#pragma vertex vertDeferred
    			#pragma fragment fragDeferred
    
    			#include "UnityStandardCore.cginc"
    
    			ENDCG
    		}
    
    		// ------------------------------------------------------------------
    		// Extracts information for lightmapping, GI (emission, albedo, ...)
    		// This pass it not used during regular rendering.
    		Pass
    		{
    			Name "META" 
    			Tags { "LightMode"="Meta" }
    
    			Cull Off
    
    			CGPROGRAM
    			#pragma vertex vert_meta
    			#pragma fragment frag_meta
    
    			#pragma shader_feature _EMISSION
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature ___ _DETAIL_MULX2
    
    			#include "UnityStandardMeta.cginc"
    			ENDCG
    		}
    	}
    
    	SubShader
    	{
    		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
    		LOD 150
    
    		// ------------------------------------------------------------------
    		//  Base forward pass (directional light, emission, lightmaps, ...)
    		Pass
    		{
    			Name "FORWARD" 
    			Tags { "LightMode" = "ForwardBase" }
    
    			Blend [_SrcBlend] [_DstBlend]
    			ZWrite [_ZWrite]
    
    			CGPROGRAM
    			#pragma target 2.0
    			
    			#pragma shader_feature _NORMALMAP
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _EMISSION 
    			#pragma shader_feature _METALLICGLOSSMAP 
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
    			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
    			// SM2.0: NOT SUPPORTED shader_feature ___ _DETAIL_MULX2
    			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
    
    			#pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
    
    			#pragma multi_compile_fwdbase
    			#pragma multi_compile_fog
    
    			#pragma vertex vertBase
    			#pragma fragment fragBase
    			#include "UnityStandardCoreForward.cginc"
    
    			ENDCG
    		}
    		// ------------------------------------------------------------------
    		//  Additive forward pass (one light per pass)
    		Pass
    		{
    			Name "FORWARD_DELTA"
    			Tags { "LightMode" = "ForwardAdd" }
    			Blend [_SrcBlend] One
    			Fog { Color (0,0,0,0) } // in additive pass fog should be black
    			ZWrite Off
    			ZTest LEqual
    			
    			CGPROGRAM
    			#pragma target 2.0
    
    			#pragma shader_feature _NORMALMAP
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
    			#pragma shader_feature ___ _DETAIL_MULX2
    			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
    			#pragma skip_variants SHADOWS_SOFT
    			
    			#pragma multi_compile_fwdadd_fullshadows
    			#pragma multi_compile_fog
    			
    			#pragma vertex vertAdd
    			#pragma fragment fragAdd
    			#include "UnityStandardCoreForward.cginc"
    
    			ENDCG
    		}
    		// ------------------------------------------------------------------
    		//  Shadow rendering pass
    		Pass {
    			Name "ShadowCaster"
    			Tags { "LightMode" = "ShadowCaster" }
    			
    			ZWrite On ZTest LEqual
    
    			CGPROGRAM
    			#pragma target 2.0
    
    			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma skip_variants SHADOWS_SOFT
    			#pragma multi_compile_shadowcaster
    
    			#pragma vertex vertShadowCaster
    			#pragma fragment fragShadowCaster
    
    			#include "UnityStandardShadow.cginc"
    
    			ENDCG
    		}
    
    		// ------------------------------------------------------------------
    		// Extracts information for lightmapping, GI (emission, albedo, ...)
    		// This pass it not used during regular rendering.
    		Pass
    		{
    			Name "META" 
    			Tags { "LightMode"="Meta" }
    
    			Cull Off
    
    			CGPROGRAM
    			#pragma vertex vert_meta
    			#pragma fragment frag_meta
    
    			#pragma shader_feature _EMISSION
    			#pragma shader_feature _METALLICGLOSSMAP
    			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
    			#pragma shader_feature ___ _DETAIL_MULX2
    
    			#include "UnityStandardMeta.cginc"
    			ENDCG
    		}
    	}
    
    
    	FallBack "VertexLit"
    	CustomEditor "StandardShaderGUI"
    }
    
-Another thing that seemed to work for people is a 'camera script'. I haven't tried it but it's supposed to fix the flipped face problem in Unity:

    // backface1.cs  -- C# Script
    // Attach this script to the camera, this script
    // will make all rendering be flipped "inside out",
    // i.e. back faces of objects will be rendered instead
    // of front faces.
    
    using UnityEngine;
    
    [ExecuteInEditMode]
    public class backface1 : MonoBehaviour
    {
        private bool oldCulling;
        public void OnPreRender()
        {
            oldCulling = GL.invertCulling;
            GL.invertCulling = true;
        }
    
        public void OnPostRender()
        {
            GL.invertCulling = oldCulling;
        }
    }

Cheers for the feedback guys much appreciated. Being a complete newbie to Unity and Cinema 4D, by any chance is there a tool or shortcut in Cinema 4D that will make all the normals of an object face the same way even though there half of the normal are facing the right way and the other half facing the other way, because when you go to reverse the normals if reverse both lots, vice versa ?????

I have the same problem. I’ve removed the front polygon from a Cube object. The outer polygons (normals) are visible however the inside isn’t. Is there a way to apply the normals to both sides of a poly?