Lab-03-B

01: Setup

Your lab02a project should have the ability to load a simple model and render it.
Create a new project called lab03b_models by copying/pasting your lab02 project.
Delete all of the source files in the new project, and rebuild the project as follows:

main.cpp:

#include "libopengl.h"

void renderScene(void)
{
  glClear( GL_COLOR_BUFFER_BIT);

  glFlush();
}

void setupRC()
{
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

  glColor3f(0.0f, 1.0f, 0.0f);

  glOrtho(-1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f);
}

int main(int argc, char* argv[])
{
  glutInit(&amp;argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutCreateWindow("lab04");
  glutInitWindowSize(800, 600);
  glutDisplayFunc(renderScene);
  setupRC();
  glutMainLoop();

  return 0;
}

simple.h

#pragma once

void loadAndDraw(char* fileName);

simple.cpp

#include "simple.h"
#include "libopengl.h"
#include <fstream>
#include <vector>

using namespace std;

void loadAndDraw(char * fileName)
{
  fstream inStream;
  inStream.open(fileName, ios::in);
  if (inStream.fail())
    return;
  GLint numpolys, numLines;
  inStream >> numpolys;
  for (int j = 0; j < numpolys; j++)
  {
    inStream >> numLines;
    glBegin( GL_LINE_STRIP);
    for (int i = 0; i < numLines; i++)
    {
      float x, y;
      inStream >> x >> y;
      glVertex2f(x, y);
    }
    glEnd();
  }
  inStream.close();
}

Build and test.
Download bighouse.txt
Make the appropriate call to load and draw the house in the renderScene method.

02: Simple Model

Introduce the following abstraction into simple.h:

struct Vertex
{
  float x;
  float y;
};

struct LineStrip
{
  int size;
  Vertex *vertices;
};

struct Model
{
  int size;
  LineStrip* lineStrips;
};

Reflect on the contents of bighouse.txt, and relate these structures to its content.
Introduce the following function on simple.cpp:

Model loadSimple(char *fileName)
{
  Model model;

  fstream inStream;
  inStream.open(fileName, ios::in);
  if (inStream.fail())
    exit(1);
  inStream >> model.size;
  model.lineStrips = new LineStrip[model.size];
  for (int polyIndex = 0; polyIndex < model.size; polyIndex++)
  {
    inStream >> model.lineStrips[polyIndex].size;
    model.lineStrips[polyIndex].vertices = new Vertex[model.lineStrips[polyIndex].size];
    for (int vertexIndex = 0; vertexIndex < model.lineStrips[polyIndex].size; vertexIndex++)
    {
      inStream >> model.lineStrips[polyIndex].vertices[vertexIndex].x >> model.lineStrips[polyIndex].vertices[vertexIndex].y;
    }
  }
  inStream.close();

  return model;
}

Place the function prototype in simple.h, and in main.cpp call this function to load the bighouse model.
Use the debugger to verify that it has been loaded successfully.

03: Simple Render

Here is a method to render the simple model:

void renderSimple(Model &amp;model)
{
  for (int polyIndex=0; polyIndex < model.size; polyIndex++)
  {
    glBegin( GL_LINE_STRIP);
    for (int vertexIndex = 0; vertexIndex < model.lineStrips[polyIndex].size; vertexIndex++)
    {
      glVertex2f(model.lineStrips[polyIndex].vertices[vertexIndex].x, model.lineStrips[polyIndex].vertices[vertexIndex].y);
    }
    glEnd();
  }
}

Implement in your project and render the model.

04: Improved Model

We can improve and simplify this model by moving to STL.
Crete a new header file -model.h - and rework the model to use vectors:

struct Vertex
{
  float x;
  float y;
};

struct LineStrip
{
  vector<Vertex> vertices;
};

struct Model
{
  vector<LineStrip> lineStrips;
};

Create a new model.cpp file and rework the load method:

Model loadModel(char *fileName)
{
  Model model;

  fstream inStream;
  inStream.open(fileName, ios::in);
  if (inStream.fail())
    exit(1);
  int numberPolys;
  inStream >> numberPolys;
  for (int polyIndex = 0; polyIndex <  numberPolys; polyIndex++)
  {
    LineStrip LineStrip;
    int numberVertices;
    inStream >> numberVertices;
    for (int vertexIndex = 0; vertexIndex < numberVertices; vertexIndex++)
    {
      Vertex vertex;
      inStream >> vertex.x >> vertex.y;
      LineStrip.vertices.push_back(vertex);
    }
    model.lineStrips.push_back(LineStrip);
  }
  inStream.close();

  return model;
}

05: Improved Render

Implement this model in renderer:

void renderModel(Model &amp;model)
{
  for (unsigned int polyIndex=0; polyIndex < model.lineStrips.size(); polyIndex++)
  {
    glBegin( GL_LINE_STRIP);
    for (unsigned int vertexIndex = 0; vertexIndex < model.lineStrips[polyIndex].vertices.size(); vertexIndex++)
    {
      glVertex2f(model.lineStrips[polyIndex].vertices[vertexIndex].x, model.lineStrips[polyIndex].vertices[vertexIndex].y);
    }
    glEnd();
  }
}

Build and test.
Compare these methods with the simple versions.

06: Model Abstractions

Rethinking the model abstractions, we can introduce behavior into the structures already developed:

struct Vertex
{
  float x;
  float y;

  Vertex(istream&amp; is);
  void render();
};

struct LineStrip
{
  vector<Vertex> vertices;

  LineStrip(istream&amp; is);
  void render();
};

struct Model
{
  vector<LineStrip> lineStrips;

  Model(istream&amp; is);
  void render();
};

Each of the above takes a reference to an input stream in its constructor, and also implements a render method

07: Model Implementation

Vertex

The implementation of Vertex is the simplest:

Vertex::Vertex(istream &amp;is)
{
  is >> x >> y;
}
void Vertex::render()
{
  glVertex2f(x, y);
}

Note that its constructor reads the cordinates from the stream

LineStrip

LineStrip::LineStrip(istream &amp;is)
{
  int size;
  is >> size;
  for (int i = 0; i < size; i++)
  {
    Vertex vertex(is);
    vertices.push_back(vertex);
  }
}

void LineStrip::render()
{
  glBegin( GL_LINE_STRIP);
  for (unsigned int i = 0; i < vertices.size(); i++)
  {
    vertices[i].render();
  }
  glEnd();
}

Model


Model::Model(istream &amp;is)
{
  int size;
  is >> size;
  for (int i = 0; i < size; i++)
  {
    LineStrip LineStrip(is);
    lineStrips.push_back(LineStrip);
  }
}

void Model::render()
{
  for (unsigned int i = 0; i < lineStrips.size(); i++)
  {
    lineStrips[i].render();
  }
}

In the Model constructor we assume that the stream is already opened successfully.

Test

Here are the relevant parts of the main program to load an display the model.

Model *model;

void renderScene(void)
{
  glClear( GL_COLOR_BUFFER_BIT);

  model->render();

  glFlush();
}

void setupRC()
{
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

  glColor3f(0.0f, 1.0f, 0.0f);

  glOrtho(-1.0f, +1.0f, -1.0f, +1.0f, -1.0f, +1.0f);

  fstream modelStream;
  modelStream.open("bighouse.txt", ios::in);
  if (modelStream.fail())
    exit(1);
  model = new Model(modelStream);
}

08: Model File Format

Time for a rethink. Have a look at the following file format:

#scale
150 150
#number of entities
4
# 1st entity
# 0 = line strip
0
# number of vertices
6
# vertices
40 40
40 90
70 120
100 90
100 40
40 40
# 2nd entity
# 0 = line strip
0
# number of vertices
4
# vertices
50 100
50 120
60 120
60 110

This format is a little more flexible - it has room for comments (lines beginning with a #), and also it has room for extension. Currently it supports line strips(via the index 0), but we could extend this later. It also has some meta information like the scale of the drawing (max x and y values);
We need a simple way of skiping comment lines on input of the first character in the line. This function here should be adequate:

void skipComment(istream &amp;is)
{
  char ch;
  is >> ch;
  if (ch == '#')
  {
    do
    {
      string buf;
      getline(is, buf);
      is >> ch;
    } while (ch == '#');
  }
  is.putback(ch);
}

This method will skip over any line beginning with at #, and ensure that the current read cusor is left at the start if a non-comment line. Note the last line puts a character back in the readbuffer so it can be read again.

09: Revised Model Definition

Bearing in mind the revised file formant, we will pave the way for an alternative shape by introducing a "marker" for primitive type:

enum EntityType {LineStripId, TriangleId};

... and also placeholders for the scale in the model:

struct Model
{
  int maxX, maxY;
  vector<LineStrip> lines;

  Model(istream&amp; is);
  void render();
}

10: Revised Model Implementation

To suppoer the new format, every time we read we need to skip comments.
So in Vertex:

Vertex::Vertex(istream &amp;is)
{
  skipComment(is);
  is >> x >> y;
}

LineStrip:

LineStrip::LineStrip(istream &amp;is)
{
  int size;
  skipComment(is);
  is >> size;
  for (int i = 0; i < size; i++)
  {
    Vertex vertex(is);
    vertices.push_back(vertex);
  }
}

In Model we also need to read the new scale parameters:

Model::Model(istream &amp;is)
{
  int size;
  skipComment(is);
  is >> maxX >> maxY;
  skipComment(is);
  is >> size;

and also, in the for loop, we need to read the type marker and only create a LineStrip if this is what is indicated:

    int typeId;
    skipComment(is);
    is >> typeId;
    switch (typeId)
    {
      case LineStripId: { LineStrip line(is);
                          lines.push_back(line);
                          break;
                        }
    }

The above case statement has only one math - for our singe supported entity type - the Line Strip.
All the render methods should be unchanged from the previous version.

11: Exercise: Model Extension

Introduce a new entity type - Triangle - which can have code 1.
it will always have three vertices.
Use this sample here as a guide:

#scale
150 150
#number of entities
4
# 1st entity
# 0 = line strip
0
# number of vertices
6
# vertices
40 40
40 90
70 120
100 90
100 40
40 40
# 2nd entity
# 0 = line strip
0
# number of vertices
4
# vertices
50 100
50 120
60 120
60 110
# 3rd entity
# 1 = triangle
1
# 3 vertices
20 10
100 22
22 22
# 1 = triangle
1
# 3 vertices
120 10
10 22
102 22

Create a new struct Triangle to model this.
Implement triangle
Store a list of triangles in the model, and extend the render method to display them

12: Exercise: Model Revision

Structurally, our solution to date looks like this:

Our rendering method in the Model class may look like this:

void Model::render()
{
  for (unsigned int i = 0; i < lines.size(); i++)
  {
    lines[i].render();
  }
  for (unsigned int i = 0; i < triangles.size(); i++)
  {
    triangles[i].render();
  }
}

Implement a refactoring to this structure here:

This should deliver a consequent simplification of the render method:

void Model::render()
{
  for (unsigned int i=0; i<entities.size(); i++)
  {
    entities[i]->render();
  }
}

00: Objectives

01: Setup

main.cpp:

simple.h

simple.cpp

02: Simple Model

03: Simple Render

04: Improved Model

05: Improved Render

06: Model Abstractions

07: Model Implementation

Vertex

LineStrip

Model

Test

08: Model File Format

09: Revised Model Definition

10: Revised Model Implementation

11: Exercise: Model Extension

12: Exercise: Model Revision