戰(zhàn)魂小筑

bool CMaxMesh::__cacl_tbn(sFace_t& face,bool isSkin)

{

    Point3  normal[3];

    Point3  Tangent; 

    Point3  p[3];

    assign(normal[0],m_MeshData.m_VertexData.m_Normals[face.vert[0]]);

    assign(normal[1],m_MeshData.m_VertexData.m_Normals[face.vert[1]]);

    assign(normal[2],m_MeshData.m_VertexData.m_Normals[face.vert[2]]);

    if(isSkin == false)

    {

        assign(p[0],m_MeshData.m_VertexData.m_Positons[face.vert[0]]);

        assign(p[1],m_MeshData.m_VertexData.m_Positons[face.vert[1]]);

        assign(p[2],m_MeshData.m_VertexData.m_Positons[face.vert[2]]);

    }

    else

    {

        assign(p[0],m_MeshData.m_VertexData.m_VertexWeights[face.vert[0]].m_InitPos);

        assign(p[1],m_MeshData.m_VertexData.m_VertexWeights[face.vert[1]].m_InitPos);

        assign(p[2],m_MeshData.m_VertexData.m_VertexWeights[face.vert[2]].m_InitPos);

    }

    sUVCoord_t uv[3];

    uv[0] = m_MeshData.m_VertexData.m_UVChannels[0][face.vert[0]];

    uv[1] = m_MeshData.m_VertexData.m_UVChannels[0][face.vert[1]];

    uv[2] = m_MeshData.m_VertexData.m_UVChannels[0][face.vert[2]];

    Point3  e1 = p[1] - p[0];

    Point3  e2 = p[2] - p[0];

    sUVCoord_t u1 = { uv[1].u - uv[0].u , uv[1].v - uv[0].v};

    sUVCoord_t u2 = { uv[2].u - uv[0].u , uv[2].v - uv[0].v};

    float det =  ( u1.u * u2.v - u2.u * u1.v);

    if(det == 0.0f)

    {

        Tangent = e1;

    }

    else

    {

        Tangent = u2.v * e1 - u1.v * e2;

    }

    //從Normal 和 Tangent里重新計算出Tangent,因為面的Tangent和頂點的Normal可能不垂直

    Point3 final_tangent;

    for(int i = 0 ;i < 3 ; ++i)

    {

        Point3 binormal  = CrossProd(normal[i],Tangent);

        final_tangent = CrossProd(binormal,normal[i]);

        final_tangent.Normalize();

        m_MeshData.m_VertexData.m_Tangents[face.vert[i]].x += final_tangent.x;

        m_MeshData.m_VertexData.m_Tangents[face.vert[i]].y += final_tangent.y;

        m_MeshData.m_VertexData.m_Tangents[face.vert[i]].z += final_tangent.z;

    }

    return true;

}

float4x4 matViewProjection;

float3 GlobalAmbient;

float3 LightColor;

float3 LightPosition;

float4 EyePosition;

float3 Ke;

float3 Ka;

float3 Kd;

float3 Ks;

float Shininess;

void vs_main( 

   in float4 InPosition : POSITION,

   in float3 InNormal : NORMAL,

   out float4 OutPosition : POSITION,

   out float4 OutColor : COLOR0

 )

{

   OutPosition = mul( InPosition, matViewProjection );

   float3 P = InPosition.xyz;

   float3 N = InNormal;

   // Compute the emissive term

   float3 Emissive = Ke;

    // Compute the ambient term

   float3 Ambient = Ka * GlobalAmbient;

   // Compute the diffuse term

   float3 L = normalize( LightPosition - P );

   float DiffuseLight = max( dot( N, L ), 0 );

   float3 Diffuse = Kd * LightColor * DiffuseLight;

   // Compute the specular term

   float3 V = normalize( EyePosition - P );

   float3 H = normalize( L + V );

   float SpecularLight = pow( max( dot( N, H ), 0 ), Shininess );

   if ( DiffuseLight <= 0 )  SpecularLight = 0;

   float3 Specular = Ks * LightColor * SpecularLight;

   OutColor.xyz = Emissive +  Ambient + Diffuse + Specular;

   OutColor.w = 1;   

}

float4 ps_main( float4 OutColor : COLOR0 ) : COLOR0

{   

   return( OutColor );

}