Jump to content

  • Log In with Google      Sign In   
  • Create Account

Assimp and Flipping Normals


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
7 replies to this topic

#1 markypooch   Members   -  Reputation: 414

Like
0Likes
Like

Posted 25 June 2014 - 10:11 PM

Hello all,

 

I am using Assimp for my models in my game. I am loading obj models exported from blender, into my classes through a model loader that utilizes Assimp.

 

I've run into an issue. Now right off the bat I know my shaders are correct, and the trasformation of lights are as well (in my Vertex Shader) since the only meshes that have the soon to be metioned issue are models exported and imported through Assimp.

 

It seems as if assimp is flipping my models normal vectors! Check the two images below, and it seems as if the backside of my model''s normals are pointing inward!

 

[code=auto:0]

 

vsOut.pos = mul(vertex.pos, worldMat);
    vsOut.pos = mul(vsOut.pos , viewMat);
    vsOut.pos = mul(vsOut.pos , projMat);

    vsOut.color = vertex.color;    
    vsOut.wPos   = mul(vertex.pos, worldMat);

    cameraPos = mul(vsOut.pos, worldMat);
    cameraPos = mul(cameraPos, viewMat);

    vsOut.viewDir = camPos.xyz - vsOut.wPos.xyz;
    vsOut.viewDir = normalize(vsOut.viewDir);

    vsOut.norm  = mul(vertex.norm, worldMat);
    vsOut.norm  = normalize(vsOut.norm);

 

[code=auto:0]

 

These are my preprocess flags for Assimp and This is how I load the normals in code

 

[code=auto:0]

 

unsigned int processFlags =
    aiProcess_CalcTangentSpace         |
    aiProcess_JoinIdenticalVertices    |
    aiProcess_ConvertToLeftHanded      | // convert everything to D3D left handed space (by default right-handed, for OpenGL)
    aiProcess_SortByPType              |
    aiProcess_ImproveCacheLocality     |
    aiProcess_RemoveRedundantMaterials |
    aiProcess_FindDegenerates          |
    aiProcess_FindInvalidData          |
    aiProcess_TransformUVCoords        |
    aiProcess_FindInstances            |
    aiProcess_LimitBoneWeights         |
    aiProcess_SplitByBoneCount         |
    aiProcess_FixInfacingNormals       |
    0;

 

 

 

...........................................

 

 

vertexVectorL.at(i).norm               = XMFLOAT3(mesh->mNormals[i].x, mesh->mNormals[i].y, mesh->mNormals[i].z);

 

[code=auto:0]

 

Has anyone else heard about assimp doing this? It's been throwing me for a loop for a while now.

If something looks off in my code give me a hint or point me in the right direction!

 

 

P.s. I've included screen shots of the issue
      Thanks for any reply an advance!

 

-Marcus

 

asd.png

sd.png

 

 

Attached Thumbnails

  • asd.png
  • sd.png


Sponsor:

#2 Krohm   Crossbones+   -  Reputation: 3129

Like
0Likes
Like

Posted 25 June 2014 - 10:39 PM

The walls look ok to me. Are they going to the same pipeline?

Are you sure the normals are ok in DCC? Sometimes they don't quite get the right "outside".



#3 tonemgub   Members   -  Reputation: 1141

Like
0Likes
Like

Posted 26 June 2014 - 12:37 AM

http://assimp.sourceforge.net/lib_html/data.html

 

By default, all 3D data is provided in a right-handed coordinate system such as OpenGL uses.



#4 Kimmi   Members   -  Reputation: 553

Like
0Likes
Like

Posted 26 June 2014 - 01:39 AM

The importer flags looks ok for me. I also checked if this is an known issue in our issue-database on github. Do you have the same effect if you try to illuminate your model standalone? 

 

Kimmi


A complicate solution may indicate a not understood problem.


@KimKulling

#5 Kimmi   Members   -  Reputation: 553

Like
0Likes
Like

Posted 26 June 2014 - 03:55 AM

 

http://assimp.sourceforge.net/lib_html/data.html

 

By default, all 3D data is provided in a right-handed coordinate system such as OpenGL uses.

 

Seems so that he has enabled the conversion already ( see the selected importer flags ), but this would be my first guess as well :-).

 

Kimmi


A complicate solution may indicate a not understood problem.


@KimKulling

#6 tonemgub   Members   -  Reputation: 1141

Like
0Likes
Like

Posted 26 June 2014 - 04:26 AM

The aiProcess_FixInfacingNormals flag may be relevant here: http://assimp.sourceforge.net/lib_html/postprocess_8h.html#a64795260b95f5a4b3f3dc1be4f52e410a620b08f185e87a67a3efd9295eed6e82



#7 markypooch   Members   -  Reputation: 414

Like
0Likes
Like

Posted 26 June 2014 - 06:10 AM

In Blender when I'm creating the meshes, they are iron-maidening correctly with their normals.

Krohm did bring up a point. I am using two seperate shaders for Mesh's without textures and those WITH textures (diffuse, normal, spec, ect.)

 

So I am for my models using a seperate shader (so seperate pipeline) for rendering without textures. BUT for all intents and purposes the code should be indentical

minus the Texture2D type and mulitplication of that and the final fragment color.

 

I'll check my material shader and ill post here. Ill be gone for most of the day. Work and all that fun stuff, so thanks for the replies!

 

[/code]

 

///////////////////////////////////////////////////////
//
//                Material Shader
//
////////////////////////////////////////////////////////


//Load Unused Texture Sampler into GPU Register(s0)
//Load clamp Sampler for Shadow Map into GPU Register(s1)
//////////////////////////////////////////////////////////////////
SamplerState            colorSampler        : register(s0);
SamplerState            sampleTypeClamp        : register(s1);

//CONSTANT BUFFERS=========================
//CB's for Matrices, allows C++ Code to send constants
//to the shader and bind them into Registers (b0, b1, b2 respectively)
//===========================================================
cbuffer world : register(b0)
{
    matrix worldMat;
}

cbuffer view  : register(b1)
{
    matrix viewMat;
}

cbuffer proj  : register(b2)
{
    matrix projMat;
}

cbuffer lView : register(b3)
{
    matrix lightViewMat;
}

cbuffer lProj : register(b4)
{
    matrix lightProjMat;
}

cbuffer camBuffer : register(b5)
{
    float3 camPos;
    float  pad;
};
//==================================================

//Structures for Shader Constants
//===================================
struct Light
{
    float3 dir;
    float3 pos;
    float  range;
    float3 att;
    float4 diffuse;
    float4 ambient;
};
//===================================

//Load the main light into the shader and bind it to register b0
cbuffer LightCB  : register(b0)
{
    Light light[6];
}


//Structures for Vertex and Pixel
/////////////////////////////////////////
struct VS_Input
{
    float4 pos       : POSITION;
    float4 color     : COLOR;
    float3 norm      : NORMAL;
};

struct PS_Input
{
    float4 pos            : SV_POSITION;
    float4 wPos            : POSITION;
    float4 color        : COLOR;
    float3 norm            : NORMAL;

    float4 lightViewP    : TEXCOORD1;
    float3 lightPos     : TEXCOORD2;
    float3 viewDir      : TEXCOORD3;
};
///////////////////////////////////////////

//Vertex Shader
///////////////////////////////////
PS_Input VS(VS_Input vertex)
{
    //Init Output Struct
    /////////////////////////////////////
    PS_Input vsOut     = (PS_Input)0;
    vertex.pos.w = 1.0f;
    float4   cameraPos = 0.0f;

    //Transform Vertices into worldSpace
    ///////////////////////////////////////////
    vsOut.pos = mul(vertex.pos, worldMat);
    vsOut.pos = mul(vsOut.pos , viewMat);
    vsOut.pos = mul(vsOut.pos , projMat);

    //Transform LightMatrix into worldSpace - ShadowMapping
    ///////////////////////////////////////////
    vsOut.lightViewP = mul(vertex.pos, worldMat);
    vsOut.lightViewP = mul(vsOut.lightViewP, lightViewMat);
    vsOut.lightViewP = mul(vsOut.lightViewP, lightProjMat);

    //Transform VertexNormal into WorldSpace, normalize it
    //////////////////////////////////////////
    vsOut.norm = mul(vertex.norm, worldMat);
    vsOut.norm = normalize(vsOut.norm);
    
    //Grab the relative worldSpace position of a vertice (Usefull for lighting calculations)
    /////////////////////////////////////////
    vsOut.wPos   = mul(vertex.pos, worldMat);

    //Transform cameraPosition to worldSpace - SpecularMapping
    ////////////////////////////////////////
    vsOut.viewDir = camPos.xyz - vsOut.wPos.xyz;
    vsOut.viewDir = normalize(vsOut.viewDir);

    vsOut.color   = vertex.color;

    //Return output structure as Input into PixelShader
    ////////////////////////////////////////
    return vsOut;
}
//////////////////////////////////
//

//
float4 PS(PS_Input texel) : SV_TARGET
{
    //texel.lightViewP.xyz /= texel.lightViewP.w;
    
    //Variable Initalization
    /////////////////////////////////////////////////
    float2 projectTexCoord = float2(0.0f, 0.0f);
    float  bias            = 0.0000003f;
    float  lightIntensity  = 0.0f;
    float  depthValue      = 0.0f;
    float  lightDepthValue = 0.0f;
    float4 color           = float4(0.0f, 0.0f, 0.0f, 0.0f);
    float4 lightObject     = light[5].diffuse;
    float4 specular        = float4(0.0f, 0.0f, 0.0f, 0.0f);
    bool   lightHit        = false;
    /////////////////////////////////////////////////

    //Grab the lightPosition at the vertex
    /////////////////////////////////////////
    texel.lightPos = light[5].pos.xyz - texel.wPos.xyz;
    texel.lightPos = normalize(texel.lightPos);
    /////////////////////////////////////////

    //return lightObject;
    lightIntensity = saturate(dot(texel.norm, light[5].pos));

    texel.lightViewP.xyz /= texel.lightViewP.w;
 
    //if position is not visible to the light - dont illuminate it
    //results in hard light frustum
    if( texel.lightViewP.x < -1.0f || texel.lightViewP.x > 1.0f ||
        texel.lightViewP.y < -1.0f || texel.lightViewP.y > 1.0f ||
        texel.lightViewP.z < 0.0f  || texel.lightViewP.z > 1.0f )
    {
        
        lightObject = light[5].ambient;
    }
 
    //transform clip space coords to texture space coords (-1:1 to 0:1)
    texel.lightViewP.x = texel.lightViewP.x/2 + 0.5;
    texel.lightViewP.y = texel.lightViewP.y/-2 + 0.5;
 
    texel.lightViewP.z -= bias;

    //sample shadow map - point sampler
    float shadowMapDepth = colorMap.Sample(sampleTypeClamp, texel.lightViewP).r;
 
    //if clip space z value greater than shadow map value then pixel is in shadow
    if ( shadowMapDepth < texel.lightViewP.z)
    {
        lightObject = light[5].ambient;
    }

    float4 color2 = lightObject;
    color = saturate(color2 + lightObject) * texel.color;

    float4 finalColor = float4(0.0f, 0.0f, 0.0f, 0.0f);

        
    [unroll]
    for (int i = 0; i < 5; i++)
    {
        float3 lightToPixelVec = light[i].dir - texel.wPos;
        //Find the distance between the light pos and pixel pos
        float d = length(lightToPixelVec);

        //If pixel is too far, return pixel color with ambient light
        if( d > 100.0f)
            continue;
        
        //Turn lightToPixelVec into a unit length vector describing
        //the pixels direction from the lights position
        lightToPixelVec /= d;
    
        //Calculate how much light the pixel gets by the angle
        //in which the light strikes the pixels surface
        float howMuchLight = dot(lightToPixelVec, texel.norm);

        //If light is striking the front side of the pixel
        if( howMuchLight > 0.0f )
        {    
            //Add light to the finalColor of the pixel
            finalColor += howMuchLight * texel.color * light[i].diffuse;
        
            //Calculate Light's Falloff factor
            finalColor /= light[i].att[0] + (light[i].att[1] * d) + (light[i].att[2] * (d*d));
        }    
        
        //make sure the values are between 1 and 0, and add the ambient
        color = saturate(color + finalColor);
    }
    
    //color += float4(0.5f, 0.0f, 0.0f, 1.0f);
    return color;
}

 

[/code]

 

P.s. It seems I have forgotten how to do the code brackets :P

 

Marcus


Edited by markypooch, 26 June 2014 - 06:11 AM.


#8 tonemgub   Members   -  Reputation: 1141

Like
0Likes
Like

Posted 27 June 2014 - 01:51 AM

If you want to be absolutely sure that the normals are the problem, and not your lighting implementation, you could add a geometry shader with a LineStream to render the normals for each vertex...

Or you could output the normal as color from the pixel shader to get an idea if the normals are ok.

 

Or use another program that can display normals, to inspect the normals from the obj file (just in case Blender is messing them up).

 

Anyway, it sounds to me like you're already certain that the normals from assimp are the problem... In that case, maybe assimp simply doesn't handle them properly with the aiProcess_ConvertToLeftHanded flag. You should find a way to export your models as left-handed - I think MeshLab can do that. Or you could remove the aiProcess_ConvertToLeftHanded flag and transform the vertices to left-handed yourself.

 

You should also try removing aiProcess_FixInfacingNormals. Their documentation says: "Generally it is recommended to enable this step, although the result is not always correct."

 

Plenty of things you could do... :)


Edited by tonemgub, 27 June 2014 - 02:22 AM.





Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS