Home/ Questions/Q 8717757
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-06-13T06:22:16+00:00

The program reads vertices and indices form a textile, and stores the vertices in

  • 0

The program reads vertices and indices form a textile, and stores the vertices in a vector, and indices in an array. Heres is quad.txt –

4 2 numVertices numIndices

-1 -1 0 v1 v2 v3

1 -1 0

1 1 0

-1 1 0

1 2 3

1 3 4

I then render the object to screen – No problem. But when I try to calculate the normals and flat shade the object I get problems. The object is rendered with GL_TRINANGLES. It looks like this https://i.stack.imgur.com/9tXD4.jpg (didn’t have enough reputation to upload it directly…)

It’s like the triangles get shaded separately… Anyway here is the code:

#include "Object.h"
#include <vector>
#include <iostream>
#include <fstream>
#include <cstring>
#include <glm.hpp>


using namespace std;

const int NMAX = 20000;

GLuint indicesArr[NMAX];

vector<glm::vec3> drawFigure;   glm::vec3 figure;
vector<glm::vec3>Vertices;      glm::vec3 vertex;
vector<glm::vec3>Normals;       glm::vec3 normal;
vector<glm::vec3>Temp;          glm::vec3 temp;


int numVertices, numIndices;

//slices = number of subdivisions around the axis
Object::Object() :
mIsInitialised(false)
{
}

Object::~Object()
{
if(mIsInitialised)
{
    drawFigure.clear();
    Vertices.clear();
    Normals.clear();
    Temp.clear();
}
}


bool Object::loadTxtFile(const string &filename)
{
ifstream in(filename);
in >> numVertices >> numIndices;

while (!in.eof())
{
    for (unsigned int i = 1; i <= numVertices; i++)
    {
        in >> vertex.x >> vertex.y >> vertex.z;
        Vertices.push_back(vertex);
    }

    for (unsigned int i = 1; i <= numIndices * 3; i++)
        in >> indicesArr[i];
}

for (unsigned int i = 1; i <= (numIndices * 3); i++)
{
    figure.x = Vertices[indicesArr[i] - 1].x;
    figure.y = Vertices[indicesArr[i] - 1].y;
    figure.z = Vertices[indicesArr[i] - 1].z;
    drawFigure.push_back(figure);
}

for (unsigned int i = 0; i < (numIndices * 3); i+=3)
{
    temp.x = drawFigure[i].x;
    temp.y = drawFigure[i].y;
    temp.z = drawFigure[i].z;
    Temp.push_back(temp);

    temp.x = drawFigure[i + 1].x;
    temp.y = drawFigure[i + 1].y;
    temp.z = drawFigure[i + 1].z;
    Temp.push_back(temp);

    temp.x = drawFigure[i + 2].x;
    temp.y = drawFigure[i + 2].y;
    temp.z = drawFigure[i + 2].z;
    Temp.push_back(temp);

    normal = glm::normalize(glm::cross(Temp[i + 2] - Temp[i], Temp[i + 1] - Temp[i]));
    Normals.push_back(normal);
}
mIsInitialised = true;
return true;  //Return true if successfully loaded
}


void Object::draw()
{

if(!mIsInitialised) { return; }

//Tell OpenGL about our vertex and colour data
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, &drawFigure.front());

glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, &Normals.front());

//draw the .txt-file
glDrawArrays(GL_TRIANGLES, 0, (numIndices * 3));

//restore the state GL back
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    You need one normal per vertex. You are currently calculating is one normal per triangle. Take a look at the following post about computing the normals: http://devmaster.net/forums/topic/1065-calculating-normals-of-a-mesh/

    As the post describe there is two ways to compute the normal per vertex:

    1. The vertex normal is the average of the adjacent face normals (See #1 in the devmaster post)
    2. The vertex normal is the angle weighted average of the adjacent face normals (See #6 in the devmaster post)
    • 0