VISIT OF A 3D HOUSE USING OPENGL

erectboboSoftware and s/w Development

Dec 14, 2013 (3 years and 8 months ago)

361 views

Visit of a 3D House Using OpenGL

Page
1

of
12

VISIT OF A 3D HOUSE USING OPENGL


Francois Uzan and Weijian Chai



Abstract



This paper introduces the basic application of computer
graphics using OpenGL. Some basic 3D visualization tools of OpenGL
are reviewed first. Then, we build a simple tool
-
kit to

design a 3D
scene. The user can visit the 3D house we built with a flying camera.
We also build a little “library” to manipulate points, vectors and
matrices.



Key Words



OpenGL, 3D scene, drawing functions, flying camera.




1.

INTRODUCTION

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

2

2.

A “FLAT” HOUSE

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

3

3.

ADDING SOME PERSPECTIVE

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

4

4.

BUILDING A CAMERA

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

7

5.

LIGHTING THE SCENE

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

8

6.

TOOLS TO BUILD OUR HOUSE

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

9

7.

TO A BETTER HOUSE

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

10

8.

RESULTS AND CONCLUSION
................................
...............

11


Visit of a 3D House Using OpenGL

Page
2

of
12


1.

INTRODUCTION


Because playing games on personal computers
has become so
popular, and so many dazzling animations are appearing in movies,
peoples are particularly interested in developing 3D graphics
applications. OpenGL is a very useful tool to design a 3D scene.


OpenGL emerged from Silicon Graphics, Inc., in 1
992 and has become
a widely adopted graphics application programming interface (API). It
provides the actual drawing tools through a collection of functions that
are called within an application. It is available (usually through free
downloads over the Int
ernet) for all types of computer systems.
OpenGL is easy to install and learn. One aspect of OpenGL that makes
it so well suited for use in a computer graphics is its “device
independence”, or portability. An OpenGL program can be developed
and run on diff
erent computers.


OpenGL offers a rich and highly usable API for 2D, 3D graphics and
image manipulation. Using it, people can progress rapidly and produce
stunning animation in a short period.


Transformations are of central importance in computer graphics
. We
use affine transformations in 3D case, including translate, scale,
rotations in 3D. We have designed tools used to shift, scale, and rotate
figures through the “current transformation,” and OpenGL’s matrix
operations are used to facilitate this featur
e. An overview of the
OpenGL viewing pipeline is developed, and the roles of the model
view, projection, and view port transformations are described briefly.
The drawing of 3D objects using OpenGL’s tools is developed.


We also designed tools for the flex
ible viewing of the 3D scene. The
“flying camera” that forms perspective views is defined, and its
relationship to the parallel views of the scene is also discussed.


Several convenient classes are built, for example, wall class, table
class, TV class, cam
era class, light class and so on. These classes
make it easy to build a 3D scene and to “fly” the camera through a
scene in an animation.


Our last try is to make a better house through adding lights and simple
shadows. Also we try to alter the surface mat
erial properties of
objects. These ways make our 3D scene looks more realistic. Methods
for adding these features are presented. But the main purpose of this
Visit of a 3D House Using OpenGL

Page
3

of
12

paper is to implement the computer graphics through designing a 3D
scene and visit the scene in an

animation. We did not focus on a
perfect, very realistic and beautiful scene.


2.

A “FLAT” HOUSE


In this part, we first try to use the basic 3D drawing functions of
OpenGL to draw a simple “house”. This house only has three walls and
one object inside. W
e use parallel projections to visualize an example
3D scene comprised of simple wire
-
frame objects.


This “flat house” drawing based on the simple “parallel projection”,
shown in figure 1. The view volume is a rectangular parallelepiped (i.e.
a box), whose

four sidewalls are determined by the border of the
window and whose other two walls are determined by a near plane and
a far plane. So the 3D point (x, y, z) projects to (x, y, 0) in this
projection.


OpenGL provides three functions glScaled (..), glRotat
ed (..), and
glTranslated (..) for applying modeling transformations to a shape.
OpenGL also provides functions for defining the view volume and its
position in the scene. These functions are used in our design of the
house and camera. We followed the grap
hics pipeline implemented by
OpenGL as follows so far:







modelview projection viewport viewport


matrix matrix matrix


FIGURE 1 The OpenGL pipeline


There are two

functions that we would like to introduce :
glPushMatrix
() and
glPopMarix
().These two functions are used to
manage several different stacks of matrices. Most objects need their
own modeling matrix in order to rotate and position them as desired.
Before ea
ch modeling transformation is established, a
glPushMatrix
()
is used to remember the current transformation, and after the object
has been drawn, the current transformation is restored with a
glPopMatrix
(). Thus, the code to draw object is enclosed within i
n a
glPushMatrix
() and
glPopMatrix
() pair.


VM


P

clip


V
p

Visit of a 3D House Using OpenGL

Page
4

of
12

3.

ADDING SOME PERSPECTIVE


We are now able to represent a 3D scene but this scene is not
very…realistic. For example when you’re getting further to an object,
its size doesn’t diminish! It’s a very inconvenient “fe
ature” when you
want to move around a scene.


To solve this problem we must use a perspective projection instead of
a parallel one. The main idea is to understand the difference between
parallel and perspective projection.

The best way to understand this d
ifference is to use drawings:


Parallel projection
























FIGURE 2 Parallel projection



With a parallel projection, the viewer loose information concerning
distances of objects.



Window

Near
Plane


Far
Plane

Window

Principles of parallel projection

Visit of a 3D House Using OpenGL

Page
5

of
12

Perspective Projection



























FIGURE 3 Perspective projection


With the perspective projection, the impression of distance is
conserved. The view is more realistic.


How to do it with OpenGL


First we built a little library comprised of several basic classes we’ll
need:



Poin
t3

: can be translated



Vector3

: can be normalized, cross & dot product available



Matrix3

: can be applied to a point.



Then we’ll have to design our camera, and we’ll need to deal with
several basic notion:



The
Eye
: it represents the position of our cam
era

Window

Window

Near
Plane


Far
Plane

Principles of perspective
projection

Visit of a 3D House Using OpenGL

Page
6

of
12



The
View Volume
: it is a truncated pyramid whose apex is at
the eye



The
View Angle
: it defines the opening of the pyramid



The
Near Plane

and the
Far Plane
: those two planes intersect
the pyramid to form a rectangular window. An object is visible if
loc
ated between those two windows.



The
Aspect Ratio
: each of the previously defined windows has a
height and width that give its aspect ratio



The
View Plane
: When points are inside the View Volume, they
are projected over this View Plane


The way points are p
rojected over the view planes differentiate the
parallel projection from the perspective projection.
















FIGURE 4 Non
-
linear projection over a plane


It’s important to notice that this is
not

a linear transform: we will have
to
use homogeneous divide.


To specify what values we will work with, our
Camera::setShape

function uses the GL_PROJECTION matrix provided by OpenGL and 4
arguments:



The View Angle



The Aspect Ratio



The Near Plane location



The Far Plane location


With the
gluP
erspective

function:


glMatrixMode(GL_PROJECTION)

;


glLoadIdentity()

;

Q

P

P


Q


Eye

Window

Non
-
linear projection over a plane

Visit of a 3D House Using OpenGL

Page
7

of
12


gluPerspective(viewAngle, aspectRatio, NearPlane, FarPlane)


We now have a well defined view volume and we have to build and set
our camera in order to choose what we want to see.



4.

B
UILDING A CAMERA


Basically what we now want to say is: “I’m here, standing this way and
I’m looking there”.


Thus, we need to specify:



An eye point that will represent the camera location



A lookAt point that will represent the point I’m looking at



A upVec
tor that will represent the way we’re standing (Where is
up and where is down).


Those values will determine where our camera is and how to aim it by
building the modelview matrix. OpenGl provide the function
gluLookAt

to do so, but we preferred to specif
y by ourselves what the modelview
matrix would look like.


This matrix has to perform two transformations:



Convert the world coordinates to camera coordinates



Transform the camera’s coordinates system into the generic
position for the camera.


That’s what
the
Camera::setModelViewMatrix

function does: with the
function
Camera::set
() we specify where is the eye, the
lookAt

point
and the
upVector

and then we call the
setModelViewMatrix

function
that set the viewmodel matrix.


How to control our camera


Our cam
era has 4 main functions:



Moving backward and forward: keys “i” and “j”



Moving up and down: keys “a” and “z”



Looking up and down: keys “s” and “x”



Looking left and right: keys “j” and “l”



Go back to original position by pressing the space bar

To perform th
ose movement we have build our own function
comKey
.

This function “listens” to the key events; when an event is received,
two function can be called:

Visit of a 3D House Using OpenGL

Page
8

of
12



P
oint3::translate(int sens,float step, Vector3 direction)

: this
function translate a point in a direction

defined by the Vector3
direction, backward or forward. The amplitude of the move is
determined by the step value.



Camera::rotate(Point3 *point1,Point3 * point2, float stepAngle,


int rotation type, Vector3& vUp, Vector3& direction):
this



function perform either an horizontal or a vertical rotation


(determined by the rotation value) of point1 against point2 of a


stepAngle

angle

After vertical rotation, the
vUp

vector is updated. After each move of
the camera, our image
is redisplayed with the
glutPostRedisplay
()
function.












FIGURE 5 The possible movements of the camera


There is a major problem that we have not dealt with: the user can
walk “through” a wall. We plan to deal with this issue l
ater but for now
the camera is totally free and has basically no restrictions.


5.

LIGHTING THE SCENE


Now we need to add some light sources to light our scene. Basically
we put at least one light in each room in our 3D house and we need to
compute the ambien
t, diffuse, and specular light contribution to the
scene. Here is the formula to sum the three light contributions


diffuse, specular, and ambient


to form the total amount of light
I

that reaches the eye from point
P
,



Camera

The possible movements of the camera

Object

Camera

Object

Visit of a 3D House Using OpenGL

Page
9

of
12

How to do
it with OpenGL


We use several functions provided in OpenGL:

a.

Creating a Light Source

We can define up to eight sources, which are referred by the names
GL_LIGHT0, GL_LIGHT1, etc. Each source is invested with various
properties and must be enabled. Each pro
perty has a default value.
We can use the array
myLightPosition
[] specified the location of the
light source and it is passed to
glLightfv
() along with the name
GL_LIGHT0, to attach it to the particular source denoted by
GL_LIGHT0.


b.

Deciding the properties

of Light

Some sources, such as a desk lamp, are in the scene, whereas others,
like the sun, are infinitely remote. OpenGL allows you to create both
types by using homogeneous coordinates to specify the position of the
source. So we have (x,y,z,1): a local

light source at the position
(x,y,z) and (x,y,z,0): a vector to an infinitely remote light source in
the direction (x,y,z). Arrays are defined to hold the colors emitted by
light sources and are passed to
glLightfv
().


c.

Lighting model

OpenGL allows three
parameters to be set that specify general rules
for applying the lighting model. These parameters are passed to
variations of the function
glLightModel
. In order to make the objects in
the scene visible even if we have not invoked any of the lighting
funct
ions, we set the ambient source to a non
-
zero value. After we
built the light class, we can still move the light sources through
translating, rotating and so on.


6.

TOOLS TO BUILD OUR HOUSE


We’re now going to build several objects we’ll assemble to build ou
r
house.



Walls
: that’s the basis of our house. Basically they’re just
scalable boxes



Room
: comprised of walls. Each room has a door that can face
any direction.



Couch:

if stretched, can become a seat



Chair



Table



TV


Basically, all those objects have 2 main

methods:

Visit of a 3D House Using OpenGL

Page
10

of
12



One to initialize the main characteristics of the objects
(proportional size of the object, location of the center of the
object)



One to display it at a selected altitude (useful if we have a multi
-
stories house)


We build our objects thanks to s
caled translated or rotated shapes.
They are initially facing one direction but their
set() method has an
argument that allows us to rotate the object around the y axis.

Since polygonal meshes were out of the scope of our paper, we
designed very basic piec
es of furniture, essentially made of cubes.


Here is the basic “blue print” of our house:














FIGURE 6 The blue print of the house


We’ve decided to build a “proportionnal ” house: we start with two
dimensions,
dimHomeX &
dimHomeZ

and all the oth
er dimensions in
the house (the width and length of rooms, their location) are
proportional to those two dimensions.
Our rooms and walls are stored
in arrays. All the elements of our scene are initialized in the
sceneDisplay

function.


7.

TO A BETTER HOUSE


F
or the moment the house is pretty…simple.

Several improvements can be made:




We could try to add texture on the walls, instead of plain colors



All our objects are comprised of cubes. A more precise study on
3d solid based on polygonal meshes could allow us

to built more
realistic objects.

Visit of a 3D House Using OpenGL

Page
11

of
12



If we had more time we could build families of objects built of
the inheritance structure of C++



We could design several pre
-
designed path for the camera, like
circles around the house or a specific visit



A deeper work on
the light could allow us to offer a time or
weather based light.


8.

RESULTS AND CONCLUSION


Our initial project was more ambitious than the one we finally realized.

We spent a lot of time studying the basis of OpenGL and designing the
camera and the light. W
e finally decided that rather than focusing on
designing very detailed pieces of furniture or adding useless
capabilities to our camera, we would focus on our first goal: building a
basic house and being able to walk through it.


Here are a couple of scre
en captures that present the project in its
latest version:




General view of the house

The TV set



The table and its chairs

The couch and the seats

Visit of a 3D House Using OpenGL

Page
12

of
12



The bedroom



FIGURE 7 The

screen captures

of the house


Through the whole process, we now h
ave a good understanding of the
computer graphics, how it can be implemented to draw pictures and
how the graphics pipeline works.


Rather than “digging” into specific aspect of OpenGL, we tried to
present several basic features of this powerful tool. So,
if we want to
use it to fulfill some goals in the future, we know which aspect we
should plunge into. Further effort can be made to a more realistic and
beautiful scene with a more powerful camera.


REFERENCES


1.

COMPUTER GRAPHICS USING OPENGL, F.S.HILL, JR.
, Prentice
Hall

2.

http://www.opengl.org/

3.

http://www.sgi.com/software/opengl

4.

OPENGL PROGRAMMING GUIDE: SECOND EDITION, MASS:
ADDISION


WESLEY DEVELOPERS PRESS, WOO, MASON,
et.al. 1997