CODEWITHSUNDEEP
c++openglgraphics
Anonymous
Anonymous

Reputation: 1560

Calculating Normals for Surface in Open GL

I am trying to add shading/lighting to my terrain generator. But for some reason my output still looks blocky even after I calculate surface normals. 

set<pair<int,int> >::const_iterator it;

for ( it = mRandomPoints.begin(); it != mRandomPoints.end(); ++it )
{
    for ( int i = 0; i < GetXSize(); ++i )
    {
        for ( int j = 0; j < GetZSize(); ++j )
        {
            float pd = sqrt(pow((*it).first - i,2) + pow((*it).second - j,2))*2 / mCircleSize;
            if(fabs(pd) <= 1.0)
            {
                mMap[i][j][2] += mCircleHeight/2 + cos(pd*3.14)*mCircleHeight/2; ;
            }

        }
    }
}

/*
    The three points being considered to compute normals are 
    (i,j)
    (i+1,j)
    (i, j+1)
*/

for ( int i = 0; i < GetXSize() -1 ; ++i )
{
    for ( int j = 0; j < GetZSize() - 1; ++j )
    {
        float b[] = {mMap[i+1][j][0]-mMap[i][j][0], mMap[i+1][j][1]-mMap[i][j][1], mMap[i+1][j][2]-mMap[i][j][2] };
        float c[] = {mMap[i][j+1][0]-mMap[i][j][0], mMap[i][j+1][1]-mMap[i][j][1], mMap[i][j+1][2]-mMap[i][j][2] };
        float a[] = {b[1]*c[2] - b[2]*c[1], b[2]*c[0]-b[0]*c[2], b[0]*c[1]-b[1]*c[0]};

        float Vnorm = sqrt(pow(a[0],2) + pow(a[1],2) + pow(a[2],2));

        mNormalMap[i][j][0] = a[0]/Vnorm;
        mNormalMap[i][j][1] = a[1]/Vnorm;
        mNormalMap[i][j][2] = a[2]/Vnorm;

    }
}

Then when drawing this I use the following

float*** normal = map->GetNormalMap();

for (int i = 0 ; i < map->GetXSize() - 1; ++i)
{
    glBegin(GL_TRIANGLE_STRIP);

    for (int j = 0; j < map->GetZSize() - 1; ++j)
    {

        glNormal3fv(normal[i][j]);


        float color = 1 - (terrain[i][j][2]/height);
        glColor3f(color,color, color);
        glVertex3f(terrain[i][j][0], terrain[i][j][2], terrain[i][j][1]);
        glVertex3f(terrain[i+1][j][0], terrain[i+1][j][2], terrain[i+1][j][1]);
        glVertex3f(terrain[i][j+1][0], terrain[i][j+1][2], terrain[i][j+1][1]);
        glVertex3f(terrain[i+1][j+1][0], terrain[i+1][j+1][2], terrain[i+1][j+1][1]);
    }

    glEnd();
}

EDIT: Initialization Code

glFrontFace(GL_CCW);
glCullFace(GL_FRONT); // glCullFace(GL_BACK); 
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);
glMatrixMode(GL_PROJECTION);

Am I calculating the Normals Properly?

Upvotes: 3

Views: 580

Answers (2)

num3ric
num3ric

Reputation: 696

In addition to what Bovinedragon suggested, namely glShadeModel(GL_SMOOTH);, you should probably use per-vertex normals. This means that each glVertex3f would be preceded by a glNormal3fv call, which would define the average normal of all adjacent faces. To obtain it, you can simply add up these neighbouring normal vectors and normalize the result.

enter image description here

Reference this question: Techniques to smooth face edges in OpenGL

Upvotes: 8

Bovinedragon
Bovinedragon

Reputation: 307

Have you set glShadeModel to GL_SMOOTH?

See: http://www.khronos.org/opengles/documentation/opengles1_0/html/glShadeModel.html

This settings also effects vertex colors in addition to lighting. You seem to say it was blocky even before lighting which makes me think this is the issue.

Upvotes: 2

Related Questions