void LightingScene::init()
{
mode=1;
// Enables lighting computations
glEnable(GL_LIGHTING);
// Sets up some lighting parameters
// Computes lighting only using the front face normals and materials
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
// Define ambient light (do not confuse with ambient component of individual lights)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight);
// Declares and enables two lights, with null ambient component
light0 = new CGFlight(GL_LIGHT0, light0_pos);
light0->setAmbient(ambientNull);
//light0->setSpecular(yellow);
lightsState.clear();
lights.clear();
lights.push_back(light0);
lightsState.push_back(1);
light0->disable();
light0->enable();
light1 = new CGFlight(GL_LIGHT1, light1_pos);
light1->setAmbient(ambientNull);
lights.push_back(light1);
lightsState.push_back(1);
light1->disable();
light1->enable();
light2 = new CGFlight(GL_LIGHT2, light2_pos);
light2->setAmbient(ambientNull);
light2->setKc(0);
light2->setKl(1);
light2->setKq(0);
lights.push_back(light2);
lightsState.push_back(1);
light2->disable();
light2->enable();
light3 = new CGFlight(GL_LIGHT3, light3_pos);
light3->setAmbient(ambientNull);
//light3->setSpecular(yellow);
light3->setKc(0);
light3->setKl(0);
light3->setKq(1);
lights.push_back(light3);
lightsState.push_back(1);
light3->disable();
light3->enable();
// Uncomment below to enable normalization of lighting normal vectors
glEnable (GL_NORMALIZE);
//Declares scene elements
table = new myTable();
wall = new Plane();
boardA = new Plane(BOARD_A_DIVISIONS);
boardB = new Plane(BOARD_B_DIVISIONS);
cilindro = new myCylinder(10, 5, false);
cilindro2 = new myCylinder(10, 5, true);
semiEsfera = new mySphere(100, 10);
relogio=new myClock();
robot = new myRobot();
robot->setRotation(200);
robot->setX(7);
robot->setY(0);
robot->setZ(7);
//Declares materials
materialA = new CGFappearance(ambA,difA,specA,shininessA);
materialB = new CGFappearance(ambB,difB,specB,shininessB);
materialC = new CGFappearance(ambC,difC,specC,shininessC);
materialD = new CGFappearance(ambD,difD,specD,shininessD);
tableAppearance = new CGFappearance(ambTable, difTable, specTable, shininessTable);
tableAppearance->setTexture("../textures/table.png");
boardAppearance = new CGFappearance(ambBoard, difBoard, specBoard, shininessBoard);
boardAppearance->setTexture("../textures/board.png");
slidesAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides);
slidesAppearance->setTexture("../textures/slides.png");
windowAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides);
windowAppearance->setTexture("../textures/window.png");
landscapeAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides);
landscapeAppearance->setTexture("../textures/landscape.jpg");
floorAppearance = new CGFappearance(ambTable, difTable, specTable, shininessTable);
floorAppearance->setTexture("../textures/floor.png");
relogioAppearance = new CGFappearance(ambBoard, difBoard, specBoard, shininessBoard);
relogioAppearance->setTexture("../textures/clock.png");
robotAppearance = new CGFappearance(ambSlides, difSlides, specSlides, shininessSlides);
robotAppearance->setTexture("../textures/robot1.jpg");
// Flat Shading
//glShadeModel(GL_FLAT);
//glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
setUpdatePeriod(100);
sceneVar = 0;
}
void Scene::init() {
//background
glClearColor(0,0,0,0);
//shading
glShadeModel(GL_SMOOTH);
//cullface
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
//cullorder
glFrontFace(GL_CCW);
// Enables lighting computations
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
// Sets up some lighting parameters
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
float ambient[4] = {1,1,1,1};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
setUpdatePeriod(30);
root = new Node();
textures["menuTex"] = new CGFtexture("../../YASF/imgs/menu.jpg");
float colorA[4] = {1,1,1,1};
float ambientA[4] = {1,1,1,1};
float diffuseA[4] = {1,1,1,1};
float specularA[4] = {1,1,1,1};
appearances["menu"] = new Appearance(colorA, ambientA, diffuseA, specularA, 1, textures["menuTex"], 1, 1);
appearances["menu_default"] = new Appearance(colorA, ambientA, diffuseA, specularA, 0);
Node* menuRoot = new Node();
root->addChildNode(menuRoot);
//Menu
Node* menuBase = new Node();
float xy1[2] = {0,0};
float xy2[2] = {5,4};
Rect* menu = new Rect(xy1, xy2);
menuBase->addChildPrimitive(menu);
menuBase->setAppearance(appearances["menu"]);
menuRoot->addChildNode(menuBase);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glTranslated(-9002.5,0,0);
GLfloat transformationMatrix[16];
glGetFloatv(GL_MODELVIEW_MATRIX, transformationMatrix);
menuRoot->setTransformations(transformationMatrix);
glPopMatrix();
//Minus
Node* minus = new Node();
float xy3[2] = {0.35, 0.2};
float xy4[2] = {0.85, 0.7};
Rect* minusRect = new Rect(xy3, xy4);
minus->addChildPrimitive(minusRect);
minus->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(minus);
//Plus
Node* plus = new Node();
float xy5[2] = {0.85, 0.2};
float xy6[2] = {1.35, 0.7};
Rect* plusRect = new Rect(xy5, xy6);
plus->addChildPrimitive(plusRect);
plus->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(plus);
//Replay
Node* replay = new Node();
float xy19[2] = {2.95, 0.2};
float xy20[2] = {3.95, 0.7};
Rect* replayRect = new Rect(xy19, xy20);
replay->addChildPrimitive(replayRect);
replay->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(replay);
//PVP
Node* pvp = new Node();
float xy7[2] = {1.8, 2.1};
float xy8[2] = {5, 2.8};
Rect* pvpRect = new Rect(xy7, xy8);
pvp->addChildPrimitive(pvpRect);
pvp->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(pvp);
//PVC
Node* pvc = new Node();
float xy9[2] = {1.8, 1.4};
float xy10[2] = {5, 2.1};
Rect* pvcRect = new Rect(xy9, xy10);
pvc->addChildPrimitive(pvcRect);
pvc->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(pvc);
//CVC
Node* cvc = new Node();
float xy11[2] = {1.8, 0.7};
float xy12[2] = {5, 1.4};
Rect* cvcRect = new Rect(xy11, xy12);
cvc->addChildPrimitive(cvcRect);
cvc->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(cvc);
//SET1
Node* set1 = new Node();
float xy13[2] = {0.15, 1.2};
float xy14[2] = {0.65, 1.7};
Rect* set1Rect = new Rect(xy13, xy14);
set1->addChildPrimitive(set1Rect);
set1->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(set1);
//SET2
Node* set2 = new Node();
float xy15[2] = {0.65, 1.2};
float xy16[2] = {1.1, 1.7};
Rect* set2Rect = new Rect(xy15, xy16);
set2->addChildPrimitive(set2Rect);
set2->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(set2);
//SET3
Node* set3 = new Node();
float xy17[2] = {1.1, 1.2};
float xy18[2] = {1.6, 1.7};
Rect* set3Rect = new Rect(xy17, xy18);
set3->addChildPrimitive(set3Rect);
set3->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(set3);
//EASY
Node* easy = new Node();
float xy21[2] = {2.0, 2.95};
float xy22[2] = {2.8, 3.35};
Rect* easyRect = new Rect(xy21, xy22);
easy->addChildPrimitive(easyRect);
easy->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(easy);
//MEDIUM
Node* medium = new Node();
float xy23[2] = {2.9, 2.95};
float xy24[2] = {3.9, 3.35};
Rect* mediumRect = new Rect(xy23, xy24);
medium->addChildPrimitive(mediumRect);
medium->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(medium);
//hard
Node* hard = new Node();
float xy25[2] = {4.0, 2.95};
float xy26[2] = {4.8, 3.35};
Rect* hardRect = new Rect(xy25, xy26);
hard->addChildPrimitive(hardRect);
hard->setAppearance(appearances["menu_default"]);
menuRoot->addChildNode(hard);
// Transparent
set1->setTransparent(true);
set2->setTransparent(true);
set3->setTransparent(true);
minus->setTransparent(true);
plus->setTransparent(true);
pvp->setTransparent(true);
pvc->setTransparent(true);
cvc->setTransparent(true);
replay->setTransparent(true);
easy->setTransparent(true);
medium->setTransparent(true);
hard->setTransparent(true);
// Picking
int* picking = new int(2);
picking[0] = -1;
picking[1] = 1;
set1->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 2;
set2->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 3;
set3->setPickingNames(vector<int>(picking, picking + 2));
picking[0] = -2;
picking[1] = -1;
minus->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 1;
plus->setPickingNames(vector<int>(picking, picking + 2));
picking[0] = -3;
picking[1] = 1;
pvp->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 2;
pvc->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 3;
cvc->setPickingNames(vector<int>(picking, picking + 2));
picking[1] = 4;
replay->setPickingNames(vector<int>(picking, picking + 2));
picking[0] = -4;
picking[1] = 1;
easy->setPickingNames(vector<int>(picking, picking + 2));
picking[0] = -4;
picking[1] = 2;
medium->setPickingNames(vector<int>(picking, picking + 2));
picking[0] = -4;
picking[1] = 3;
hard->setPickingNames(vector<int>(picking, picking + 2));
//Cameras
float pos1[3] = {-9000,2,2.5};
float pos2[3] = {-9000,2,0};
CGFscene::activeCamera = new CameraPerspective(1.0, 100.0, 90.0, pos1, pos2);
//Lights
float pos[3] = {5,2,5};
float specular0[4] = {0,0,0,0};
lightings["menu_omni"] = new LightOmni(GL_LIGHT0, "true", pos, ambientA, diffuseA, specular0);
}
void RAS_OpenGLRasterizer::SetAmbient(float factor)
{
float ambient[] = {m_ambr * factor, m_ambg * factor, m_ambb * factor, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
}
void
Init(void)
{
int i;
float top_y = 1.0;
float bottom_y = 0.0;
float top_z = 0.15;
float bottom_z = 0.69;
float spacing = 2.5;
static float lmodel_ambient[] =
{0.0, 0.0, 0.0, 0.0};
static float lmodel_twoside[] =
{GL_FALSE};
static float lmodel_local[] =
{GL_FALSE};
static float light0_ambient[] =
{0.1, 0.1, 0.1, 1.0};
static float light0_diffuse[] =
{1.0, 1.0, 1.0, 0.0};
static float light0_position[] =
{0.8660254, 0.5, 1, 0};
static float light0_specular[] =
{1.0, 1.0, 1.0, 0.0};
static float bevel_mat_ambient[] =
{0.0, 0.0, 0.0, 1.0};
static float bevel_mat_shininess[] =
{40.0};
static float bevel_mat_specular[] =
{1.0, 1.0, 1.0, 0.0};
static float bevel_mat_diffuse[] =
{1.0, 0.0, 0.0, 0.0};
srand48(0x102342);
ReInit();
for (i = 0; i < RINGS; i++) {
rgb_colors[i][0] = rgb_colors[i][1] = rgb_colors[i][2] = 0;
}
rgb_colors[BLUERING][2] = 255;
rgb_colors[REDRING][0] = 255;
rgb_colors[GREENRING][1] = 255;
rgb_colors[YELLOWRING][0] = 255;
rgb_colors[YELLOWRING][1] = 255;
mapped_colors[BLUERING] = BLUE;
mapped_colors[REDRING] = RED;
mapped_colors[GREENRING] = GREEN;
mapped_colors[YELLOWRING] = YELLOW;
mapped_colors[BLACKRING] = BLACK;
dests[BLUERING][0] = -spacing;
dests[BLUERING][1] = top_y;
dests[BLUERING][2] = top_z;
dests[BLACKRING][0] = 0.0;
dests[BLACKRING][1] = top_y;
dests[BLACKRING][2] = top_z;
dests[REDRING][0] = spacing;
dests[REDRING][1] = top_y;
dests[REDRING][2] = top_z;
dests[YELLOWRING][0] = -spacing / 2.0;
dests[YELLOWRING][1] = bottom_y;
dests[YELLOWRING][2] = bottom_z;
dests[GREENRING][0] = spacing / 2.0;
dests[GREENRING][1] = bottom_y;
dests[GREENRING][2] = bottom_z;
theTorus = glGenLists(1);
glNewList(theTorus, GL_COMPILE);
FillTorus(0.1, 8, 1.0, 25);
glEndList();
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glClearDepth(1.0);
if (rgb) {
glClearColor(0.5, 0.5, 0.5, 0.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT0);
glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, lmodel_local);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT, GL_AMBIENT, bevel_mat_ambient);
glMaterialfv(GL_FRONT, GL_SHININESS, bevel_mat_shininess);
glMaterialfv(GL_FRONT, GL_SPECULAR, bevel_mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, bevel_mat_diffuse);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
} else {
glClearIndex(BACKGROUND);
glShadeModel(GL_FLAT);
}
glMatrixMode(GL_PROJECTION);
gluPerspective(45, 1.33, 0.1, 100.0);
glMatrixMode(GL_MODELVIEW);
}
GLvoid CLightModel::SetGlobalAmbient( GLfloat* ambient )
{
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, ambient );
}
void Tracks::draw(GLuint tex)
{
glPushMatrix();
glEnable(GL_LIGHTING); //Enable lighting
glEnable(GL_LIGHT0); //Enable light #0
//Add ambient light
GLfloat ambientColor[] = {0.75f, 0.75f, 0.75f, 0.5f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);
//Add positioned light
GLfloat lightColor0[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat lightPos0[] = {0.0f, 3.0f, 0.0f, 1.0f};
GLfloat spot_direction[] = { 0.0, -1.0, 0.0 };
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 30.0);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
////Add ambient light
//GLfloat ambientColor[] = {1.0f, 1.0f, 1.0f, 0.5f};
////glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);
//
////Add directed light
//GLfloat lightColor1[] = {0.85f, 0.85f, 0.85f, 1.0f};
//GLfloat lightPos1[] = {0.0f, 2.0f, -3.0f, 0.0f};
//glLightfv(GL_LIGHT1, GL_SPECULAR, lightColor1);
//glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);
glBegin(GL_QUADS); //Begin quadrilateral coordinates
//top
//glColor3f(1.0f, 0.0f, 0.0f);
glNormal3f(0.0, 1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
//bottom
//glColor3f(1.0f, 0.0f, 0.0f);
glNormal3f(0.0, -1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//back
//glColor3f(1.0f, 0.5f, 0.0f);
glNormal3f(0.0, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
//front
//glColor3f(1.0f, 0.0f, 0.5f);
glNormal3f(0.0, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//right 1
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
//right 2
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
//right 3
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
//left 1
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
//left 2
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//left 3
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glEnd(); //End quadrilateral coordinates
glTranslatef(0.7, 0.0, 0.0);
glBegin(GL_QUADS); //Begin quadrilateral coordinates
//top
//glColor3f(1.0f, 0.0f, 0.0f);
glNormal3f(0.0, 1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
//bottom
//glColor3f(1.0f, 0.0f, 0.0f);
glNormal3f(0.0, -1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//back
//glColor3f(1.0f, 0.5f, 0.0f);
glNormal3f(0.0, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
//front
//glColor3f(1.0f, 0.0f, 0.5f);
glNormal3f(0.0, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//right 1
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
//right 2
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, 0.25f);
//right 3
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.25f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.25f, 0.0f, -0.25f);
//left 1
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
//left 2
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, 0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, 0.25f);
//left 3
//glColor3f(0.5f, 0.5f, 1.0f);
glNormal3f(-1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.45f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(-0.45f, 0.15f, -0.25f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.45f, 0.0f, -0.25f);
glEnd(); //End quadrilateral coordinates
glTranslatef(-0.7, 0.0, 0.0);
glBegin(GL_QUADS);
//bottom
//glColor3f(0.5f, 0.0f, 0.0f);
glNormal3f(0.0, -1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.35f, 0.15f, -0.35f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(0.35f, 0.15f, -0.35f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(0.35f, 0.15f, 0.35f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.35f, 0.15f, 0.35f);
//top
//glColor3f(1.0f, 0.0f, 1.0f);
glNormal3f(0.0, 1.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.35f, 1.0f, -0.35f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(0.35f, 1.0f, -0.35f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(0.35f, 1.0f, 0.35f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.35f, 1.0f, 0.35f);
//back
//glColor3f(1.0f, 0.5f, 0.0f);
glNormal3f(0.0, 0.0f, -1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.35f, 0.15f, -0.35f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(0.35f, 0.15f, -0.35f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(0.35f, 1.0f, -0.35f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.35f, 1.0f, -0.35f);
//front
//glColor3f(1.0f, 0.0f, 0.5f);
glNormal3f(0.0, 0.0f, 1.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(-0.35f, 0.15f, 0.35f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(0.35f, 0.15f, 0.35f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(0.35f, 1.0f, 0.35f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-0.35f, 1.0f, 0.35f);
//right
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(1.0, 0.0f, 0.0f);
glTexCoord2f(0.0f, 0.0f);
glVertex3f(0.35f, 1.0f, -0.35f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(0.35f, 1.0f, 0.35f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(0.35f, 0.15f, 0.35f);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(0.35f, 0.15f, -0.35f);
//left
//glColor3f(1.0f, 0.5f, 0.5f);
glNormal3f(-1.0, 0.0f, 0.0f);
glVertex3f(-0.35f, 1.0f, -0.35f);
glVertex3f(-0.35f, 1.0f, 0.35f);
glVertex3f(-0.35f, 0.15f, 0.35f);
glVertex3f(-0.35f, 0.15f, -0.35f);
glEnd();
glDisable(GL_TEXTURE_2D);
//4
glPushMatrix();
glBegin(GL_QUADS);
glColor3d(1,1,1);
glVertex3f(-0.1f, 1.01f, 0.1f);
glVertex3f(-0.1f, 1.01f, 0.2f);
glVertex3f(0.1f, 1.01f, 0.2f);
glVertex3f(0.1f, 1.01f, 0.1f);
//glColor3f(0.0f, 1.0f, 0.0f);
glVertex3f(-0.0f, 1.01f, -0.15f);
glVertex3f(-0.0f, 1.01f, 0.3f);
glVertex3f(0.1f, 1.01f, 0.3f);
glVertex3f(0.1f, 1.01f, -0.15f);
//glColor3f(0.0f, 1.0f, 0.0f);
glVertex3f(-0.25f, 1.01f, -0.15f);
glVertex3f(-0.25f, 1.01f, 0.2f);
glVertex3f(-0.1f, 1.01f, 0.2f);
glVertex3f(-0.1f, 1.01f, -0.15f);
glEnd();
glPopMatrix();
glDisable(GL_LIGHTING);
glPopMatrix();
}
void LightingScene::init()
{
sceneVar=0;
light0On = 1;
light1On = 1;
light2On = 0;
light3On = 0;
clockAnimation = true;
// Enables lighting computations
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
// Sets up some lighting parameters
// Computes lighting only using the front face normals and materials
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
// Define ambient light (do not confuse with ambient component of individual lights)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight);
// Declares and enables two lights, with null ambient component
glShadeModel(GL_SMOOTH);
light0 = new CGFlight(GL_LIGHT0, light0_pos);
light0->setAmbient(ambientNull);
light0->setSpecular(yellow);
if (light0On == 0)
light0->disable();
else
light0->enable();
light1 = new CGFlight(GL_LIGHT1, light1_pos);
light1->setAmbient(ambientNull);
if (light1On == 0)
light1->disable();
else
light1->enable();
light2 = new CGFlight(GL_LIGHT2, light2_pos);
light2->setAmbient(ambientNull);
if (light2On == 0)
light2->disable();
else
light2->enable();
light3 = new CGFlight(GL_LIGHT3, light3_pos);
light3->setAmbient(ambientNull);
light3->setSpecular(yellow);
light3->setKc(0);
light3->setKl(0);
light3->setKq(1);
if (light3On == 0)
light3->disable();
else
light3->enable();
// Uncomment below to enable normalization of lighting normal vectors
// glEnable (GL_NORMALIZE);
//Declares scene elements
table = new myTable();
wall = new Plane();
clock = new myClock();
cylinder = new myCylinder(10,10, true);
cylinder1 = new myCylinder(10,10,false);
robot = new myRobot(10);
boardA = new Plane(BOARD_A_DIVISIONS);
boardB = new Plane(BOARD_B_DIVISIONS);
//Declares materials
materialA = new CGFappearance(ambientNull,difA,specA,shininessA);
materialB = new CGFappearance(ambientNull,difB,specB,shininessB);
//Declares Textures
tableAppearence = new CGFappearance(ambientNull,difA,specA,shininessA);
tableAppearence->setTexture("table.png");
tableAppearence->setTextureWrap(GL_REPEAT,GL_REPEAT);
slidesAppearence = new CGFappearance(ambientNull,difSlides,specSlides,shininessSlides);
slidesAppearence->setTexture("slides.png");
slidesAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP);
boardAppearence = new CGFappearance(ambientNull,difBoard,specBoard,shininessBoard);
boardAppearence->setTexture("board.png");
boardAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP);
robotAppearence = new CGFappearance (ambientNull, difA , specA, shininessA);
robotAppearence->setTexture("robot1.jpg");
robotAppearence->setTextureWrap(GL_CLAMP,GL_CLAMP);
setUpdatePeriod(100);
}
//////////////////////////////////////////////////////////////////
// This function does any needed initialization on the rendering
// context.
void SetupRC()
{
M3DVector3f vPoints[3] = {{ 0.0f, -0.4f, 0.0f },
{ 10.0f, -0.4f, 0.0f },
{ 5.0f, -0.4f, -5.0f }};
int iSphere;
int i;
// Grayish background
glClearColor(fLowLight[0], fLowLight[1], fLowLight[2], fLowLight[3]);
// Clear stencil buffer with zero, increment by one whenever anybody
// draws into it. When stencil function is enabled, only write where
// stencil value is zero. This prevents the transparent shadow from drawing
// over itself
glStencilOp(GL_INCR, GL_INCR, GL_INCR);
glClearStencil(0);
glStencilFunc(GL_EQUAL, 0x0, 0x01);
// Cull backs of polygons
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE_ARB);
// Setup light parameters
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fNoLight);
glLightfv(GL_LIGHT0, GL_AMBIENT, fLowLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, fBrightLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, fBrightLight);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
// Calculate shadow matrix
M3DVector4f pPlane;
m3dGetPlaneEquation(pPlane, vPoints[0], vPoints[1], vPoints[2]);
m3dMakePlanarShadowMatrix(mShadowMatrix, pPlane, fLightPos);
// Mostly use material tracking
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_SPECULAR, fBrightLight);
glMateriali(GL_FRONT, GL_SHININESS, 128);
// Randomly place the sphere inhabitants
for(iSphere = 0; iSphere < NUM_SPHERES; iSphere++)
{
// Pick a random location between -20 and 20 at .1 increments
spheres[iSphere].SetOrigin(((float)((rand() % 400) - 200) * 0.1f), 0.0, (float)((rand() % 400) - 200) * 0.1f);
}
// Set up texture maps
glEnable(GL_TEXTURE_2D);
glGenTextures(NUM_TEXTURES, textureObjects);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
for(i = 0; i < NUM_TEXTURES; i++)
{
GLbyte *pBytes;
GLint iWidth, iHeight, iComponents;
GLenum eFormat;
glBindTexture(GL_TEXTURE_2D, textureObjects[i]);
// Load this texture map
pBytes = gltLoadTGA(szTextureFiles[i], &iWidth, &iHeight, &iComponents, &eFormat);
gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes);
free(pBytes);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
// Create display lists
groundList = glGenLists(3);
sphereList = groundList + 1;
torusList = sphereList + 1;
// Create sphere display list
glNewList(sphereList, GL_COMPILE);
gltDrawSphere(0.1f, 40, 20);
glEndList();
// Create torus display list
glNewList(torusList, GL_COMPILE);
gltDrawTorus(0.35, 0.15, 61, 37);
glEndList();
// Create the ground display list
glNewList(groundList, GL_COMPILE);
DrawGround();
glEndList();
}
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR cmdLine,
int cmdShow)
{
//Set our window settings
const int windowWidth = 1024;
const int windowHeight = 768;
const int windowBPP = 16;
//This is our window
static cWNDManager* pgmWNDMgr = cWNDManager::getInstance();
//The example OpenGL code
windowOGL theOGLWnd;
//Attach our example to our window
pgmWNDMgr->attachOGLWnd(&theOGLWnd);
// Sphere
cSphere theEarth(3,30,30);
cSphere theMoon(1, 20, 20);
cSphere theSun(6, 60, 60);
float rotationAngleEarth = 0;
float rotationAngleMoon = 0;
//Attempt to create the window
if (!pgmWNDMgr->createWND(windowWidth, windowHeight, windowBPP))
{
//If it fails
MessageBox(NULL, "Unable to create the OpenGL Window", "An error occurred", MB_ICONERROR | MB_OK);
pgmWNDMgr->destroyWND(); //Reset the display and exit
return 1;
}
if (!theOGLWnd.initOGL()) //Initialize our example
{
MessageBox(NULL, "Could not initialize the application", "An error occurred", MB_ICONERROR | MB_OK);
pgmWNDMgr->destroyWND(); //Reset the display and exit
return 1;
}
// Crate Texture map
cTexture earthTexture;
earthTexture.createTexture("Images/Earth.png");
cTexture moonTexture;
moonTexture.createTexture("Images/Moon.png");
cTexture sunTexture;
sunTexture.createTexture("Images/sun.png");
theSun.initialise(sunTexture.getTexture(), glm::vec3(0, 0, 0), glm::vec3(0, 0, 0));
theEarth.initialise(earthTexture.getTexture(), glm::vec3(30, 0, 0), glm::vec3(0, 0, 0));
float earthRotSpeed = 3.0f;
GLfloat earthOrbit = 0.0f;
theMoon.initialise(moonTexture.getTexture(), glm::vec3(-3, 0, 8), glm::vec3(0, 0, 0));
float moonRotSpeed = 5.0f;
GLfloat moonOrbit = 0.0f;
// Create Materials for lights
cMaterial sunMaterial(lightColour4(0.0f, 0.0f, 0.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0, 0, 0, 1.0f), 5.0f);
cMaterial earthMaterial(lightColour4(0.2f, 0.2f, 0.2f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0, 0, 0, 1.0f), 50.0f);
cMaterial moonMaterial(lightColour4(0.1f, 0.1f, 0.1f, 1.0f), lightColour4(1.0f, 1.0f, 1.0f, 1.0f), lightColour4(0.2f, 0.2f, 0.2f, 1.0f), lightColour4(0, 0, 0, 1.0f), 10.0f);
// Create Light
cLight moonLight(GL_LIGHT0, lightColour4(0, 0, 0, 1), lightColour4(1, 1, 1, 1), lightColour4(1, 1, 1, 1), glm::vec4(0, 0, 20, 1),
glm::vec3(0.0, 0.0, 1.0), 0.0f, 180.0f, 1.0f, 0.0f, 0.0f);
cLight sunLight(GL_LIGHT0, lightColour4(0, 0, 0, 1), lightColour4(1, 1, 1, 1), lightColour4(1, 1, 1, 1), glm::vec4(0, 0, 20, 1),
glm::vec3(0.0, 0.0, 1.0), 0.0f, 180.0f, 1.0f, 0.0f, 0.0f);
//Define Ambient light for scene
GLfloat g_Ambient[] = { 0.2, 0.2, 0.2, 1.0 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, g_Ambient);
//This is the mainloop, we render frames until isRunning returns false
while (pgmWNDMgr->isWNDRunning())
{
pgmWNDMgr->processWNDEvents(); //Process any window events
//We get the time that passed since the last frame
float elapsedTime = pgmWNDMgr->getElapsedSeconds();
// Lab code goes here
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
theOGLWnd.initOGL();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -100.0f);
glRotatef(-90.0f, 1, 0, 0);
// Sun setup
sunLight.lightOn();
theSun.setRotAngle(theSun.getRotAngle());
theSun.prepare(theSun.getRotAngle());
sunMaterial.useMaterial();
theSun.render(theSun.getRotAngle());
// Earth's orbit
glPushMatrix();
glTranslatef(0, 0, 0);
glRotatef(earthOrbit*10, 0.0f, 1.0f, 0.0f);
rotationAngleEarth += (earthRotSpeed*elapsedTime);
theEarth.setRotAngle(theEarth.getRotAngle() + (earthRotSpeed*elapsedTime));
theEarth.prepare(rotationAngleEarth); //Do any pre-rendering logic
earthMaterial.useMaterial(); // Set the material for use
theEarth.render(theEarth.getRotAngle()); //Render the scene
glPopMatrix();
// Moon's orbit
glPushMatrix();
moonLight.lightOn();
glTranslatef(0, 0, 0);
glRotatef(earthOrbit*10, 0.0f, 1.0f, 0.0f);
glTranslatef(theEarth.getPosition().x, theEarth.getPosition().y, theEarth.getPosition().z);
glRotatef(moonOrbit*10, 0.0f, 1.0f, 0.0f);
glTranslatef(10.0f, 0.0f, 0.0f);
rotationAngleMoon += (moonRotSpeed*elapsedTime);
theMoon.setRotAngle(theMoon.getRotAngle() + (moonRotSpeed*elapsedTime));
theMoon.prepare(rotationAngleMoon);
moonMaterial.useMaterial();
theMoon.render(theMoon.getRotAngle());
glPopMatrix();
pgmWNDMgr->swapBuffers();
moonOrbit += (5.0f) * elapsedTime;
if (moonOrbit > 360.0f)
{
moonOrbit -= 360.0f;
}
earthOrbit += (5.0f) * elapsedTime;
if (earthOrbit > 360.0f)
{
earthOrbit -= 360.0f;
}
}
theOGLWnd.shutdown(); //Free any resources
pgmWNDMgr->destroyWND(); //Destroy the program window
return 0; //Return success
}
static void Init(void)
{
static float ambient[] = {0.1, 0.1, 0.1, 1.0};
static float diffuse[] = {0.5, 1.0, 1.0, 1.0};
static float position[] = {90.0, 90.0, 150.0, 0.0};
static float front_mat_shininess[] = {30.0};
static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0};
static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0};
static float back_mat_shininess[] = {50.0};
static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0};
static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
static float lmodel_twoside[] = {GL_TRUE};
glClearColor(0.0, 0.0, 0.0, 0.0);
glFrontFace(GL_CW);
glEnable(GL_DEPTH_TEST);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
glEnable(GL_CLIP_PLANE0);
if (rgb) {
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest);
glTexImage2D(GL_TEXTURE_2D, 0, 3, CHECKIMAGEWIDTH, CHECKIMAGEHEIGHT, 0,
GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)checkImage);
glEnable(GL_TEXTURE_2D);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
} else {
SetGreyRamp();
/* commented out by BrianP because it's the wrong way to handle a 4-bit visual!
if (doubleBuffer) {
colorIndexes[1] = 10;
colorIndexes[2] = 15;
}
*/
glMaterialiv(GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes);
}
BuildLists();
dithering = GL_TRUE;
shade = GL_TRUE;
doStipple = GL_FALSE;
polyMode = GL_BACK;
}
static void Init(void)
{
float ambient[] = {0.0, 0.0, 0.0, 1.0};
float diffuse[] = {1.0, 1.0, 1.0, 1.0};
float specular[] = {1.0, 1.0, 1.0, 1.0};
float position[] = {0.0, 0.0, 4.0, 0.0};
float fog_color[] = {0.0, 0.0, 0.0, 1.0};
float mat_ambient[] = {0.0, 0.0, 0.0, 1.0};
float mat_shininess[] = {90.0};
float mat_specular[] = {1.0, 1.0, 1.0, 1.0};
float mat_diffuse[] = {0.8, 0.8, 0.8, 1.0};
float lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0};
float lmodel_twoside[] = {GL_TRUE};
int w, h;
GLenum format;
GLubyte *image;
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
SetDefaultSettings();
image = LoadRGBImage(imageFileName, &w, &h, &format);
if (!image) {
printf("Error: couldn't load %s\n", imageFileName);
exit(1);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
gluBuild2DMipmaps(GL_TEXTURE_2D, format, w, h,
GL_RGB, GL_UNSIGNED_BYTE, image);
free(image);
glFogf(GL_FOG_DENSITY, 0.125);
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, 4.0);
glFogf(GL_FOG_END, 8.5);
glFogfv(GL_FOG_COLOR, fog_color);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glEnable(GL_LIGHT0);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glShadeModel(GL_SMOOTH);
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glFrontFace(GL_CW);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glTexGeniv(GL_S, GL_TEXTURE_GEN_MODE, sphereMap);
glTexGeniv(GL_T, GL_TEXTURE_GEN_MODE, sphereMap);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, sWrapMode);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tWrapMode);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textureEnvironment);
BuildLists();
}
void UpdateDisplay( void )
{
// Get window size
glfwGetWindowSize( &width, &height );
// Set viewport
glViewport( 0, 0, width, height );
// Clear display
glClearColor( 0.02f, 0.02f, 0.02f, 0.0f );
glClearDepth( 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Setup projection matrix
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective(
55.0f, // Angle of view
(GLfloat)width/(GLfloat)height, // Aspect
1.0f, // Near Z
100.0f // Far Z
);
// Setup modelview matrix
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
switch( camerapos )
{
default:
case CAMERA_CLASSIC:
gluLookAt(
0.0f, 0.0f, 2.5f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f
);
break;
case CAMERA_ABOVE:
gluLookAt(
0.0f, 0.0f, 2.5f,
(float)ball.xpos, (float)ball.ypos, 0.0f,
0.0f, 1.0f, 0.0f
);
break;
case CAMERA_SPECTATOR:
gluLookAt(
0.0f, -2.0, 1.2f,
(float)ball.xpos, (float)ball.ypos, 0.0f,
0.0f, 0.0f, 1.0f
);
break;
}
// Enable depth testing
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
// Enable lighting
glEnable( GL_LIGHTING );
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, env_ambient );
glLightModeli( GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE );
glLightfv( GL_LIGHT1, GL_POSITION, light1_position );
glLightfv( GL_LIGHT1, GL_DIFFUSE, light1_diffuse );
glLightfv( GL_LIGHT1, GL_AMBIENT, light1_ambient );
glEnable( GL_LIGHT1 );
// Front face is counter-clock-wise
glFrontFace( GL_CCW );
// Enable face culling (not necessary, but speeds up rendering)
glCullFace( GL_BACK );
glEnable( GL_CULL_FACE );
// Draw Player 1
glMaterialfv( GL_FRONT, GL_DIFFUSE, player1_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, player1_ambient );
DrawBox( -1.f, (GLfloat)player1.ypos-PLAYER_YSIZE, 0.f,
-1.f+PLAYER_XSIZE, (GLfloat)player1.ypos+PLAYER_YSIZE, 0.1f );
// Draw Player 2
glMaterialfv( GL_FRONT, GL_DIFFUSE, player2_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, player2_ambient );
DrawBox( 1.f-PLAYER_XSIZE, (GLfloat)player2.ypos-PLAYER_YSIZE, 0.f,
1.f, (GLfloat)player2.ypos+PLAYER_YSIZE, 0.1f );
// Draw Ball
glMaterialfv( GL_FRONT, GL_DIFFUSE, ball_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, ball_ambient );
DrawBox( (GLfloat)ball.xpos-BALL_SIZE, (GLfloat)ball.ypos-BALL_SIZE, 0.f,
(GLfloat)ball.xpos+BALL_SIZE, (GLfloat)ball.ypos+BALL_SIZE, BALL_SIZE*2 );
// Top game field border
glMaterialfv( GL_FRONT, GL_DIFFUSE, border_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, border_ambient );
DrawBox( -1.1f, 1.0f, 0.0f, 1.1f, 1.1f, 0.1f );
// Bottom game field border
glColor3f( 0.0f, 0.0f, 0.7f );
DrawBox( -1.1f, -1.1f, 0.0f, 1.1f, -1.0f, 0.1f );
// Left game field border
DrawBox( -1.1f, -1.0f, 0.0f, -1.0f, 1.0f, 0.1f );
// Left game field border
DrawBox( 1.0f, -1.0f, 0.0f, 1.1f, 1.0f, 0.1f );
// Enable texturing
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, tex_id[ TEX_FIELD ] );
// Game field floor
glMaterialfv( GL_FRONT, GL_DIFFUSE, floor_diffuse );
glMaterialfv( GL_FRONT, GL_AMBIENT, floor_ambient );
DrawBox( -1.01f, -1.01f, -0.01f, 1.01f, 1.01f, 0.0f );
// Disable texturing
glDisable( GL_TEXTURE_2D );
// Disable face culling
glDisable( GL_CULL_FACE );
// Disable lighting
glDisable( GL_LIGHTING );
// Disable depth testing
glDisable( GL_DEPTH_TEST );
}
void Scene::init(){
glClearColor(graph->background[0], graph->background[1], graph->background[2], graph->background[3]);
//inicializar o vector de cameras da Scene
map<string, Camera*>::iterator it;
for(it=graph->cameras.begin(); it != graph->cameras.end(); it++){
cameras.push_back((*it).second);
}
camIt = cameras.begin();
for(int i = 0; camIt != cameras.end(); i++,it++)
{
if((*camIt)->id == graph->rootCamera)
{
actualCam = i;
break;
}
}
glEnable(GL_NORMALIZE);
if(graph->cullingFace == "none")
glCullFace(GL_NONE);
else if(graph->cullingFace == "back")
glCullFace(GL_BACK);
else if(graph->cullingFace == "front")
glCullFace(GL_FRONT);
else if(graph->cullingFace == "both")
glCullFace(GL_FRONT_AND_BACK);
if(graph->cullingOrder == "ccw")
glFrontFace(GL_CCW);
else if(graph->cullingOrder == "cw")
glFrontFace(GL_CW);
//lighting
if(graph->lEnabled)
glEnable(GL_LIGHTING);
if(graph->lDoubleSided){
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
}else{
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
}
if(graph->lLocal)
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_TRUE);
else{
glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER,GL_FALSE);
}
//ambient light
float ambientLight[4] = {0,0,0,0};
for(int i = 0; i < 4;i++)
ambientLight[i] = graph->lAmbient[i];
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientLight);
if(graph->shading == "gouraud")
glShadeModel(GL_SMOOTH);
else if(graph->shading == "flat")
glShadeModel(GL_FLAT);
if(graph->drawingMode == "fill")
wire = 0;
else if(graph->drawingMode == "line")
wire = 1;
else if(graph->drawingMode == "point")
wire = 2;
vector<Light> lghts = graph->lights;
int i = 0;
vector<Light>::iterator lIt;
for(lIt = lghts.begin(); lIt != lghts.end(); lIt++,i++){
float pos[4] = {lIt->pos[0], lIt->pos[1], lIt->pos[2], 1.0};
float ambient[4] = {lIt->ambient[0], lIt->ambient[1], lIt->ambient[2], lIt->ambient[3]};
float diffuse[4] = {lIt->diffuse[0], lIt->diffuse[1], lIt->diffuse[2], lIt->diffuse [3]};
float specular[4] = {lIt->specular[0], lIt->specular[1], lIt->specular[2], lIt->specular[3]};
CGFlight* newLight;
if( lIt->type == "spot")
{
float angle = lIt->angle, exp = lIt->exponent;
float target[3]={lIt->target[0]-pos[0], lIt->target[1]-pos[1], lIt->target[2]-pos[2]};
float unit = sqrt(target[0] * target[0] + target[1] * target[1] + target[2] * target[2]);
for (int i = 0; i < 3; i++)
target[i] = target[i] / unit;
glLightf(lightsArray[i],GL_SPOT_EXPONENT,exp);
glLightf(lightsArray[i],GL_SPOT_CUTOFF,angle);
glLightfv(lightsArray[i],GL_SPOT_DIRECTION,target);
newLight = new CGFlight(lightsArray[i],pos,target);
}
else
newLight =new CGFlight(lightsArray[i],pos);
newLight->setAmbient(ambient);
newLight->setDiffuse(diffuse);
newLight->setSpecular(specular);
if(lIt->enabled)
newLight->enable();
else
newLight->disable();
newLight->update();
lights.push_back(newLight);
}
}
// apply light
// Set them from light nodes if possible.
// If not, use the light objects directly.
void x3ds_instance::set_light()
{
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, m_def->m_file->ambient);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glShadeModel(GL_SMOOTH);
Lib3dsLight* l = m_def->m_file->lights;
for (int gl_light = GL_LIGHT0; gl_light <= GL_LIGHT7; gl_light++)
{
if (l)
{
glEnable(gl_light);
// default we use light objects directly
GLfloat color[4];
color[0] = l->color[0];
color[1] = l->color[1];
color[2] = l->color[2];
color[3] = 1;
// default position
GLfloat position[4];
position[0] = l->position[0];
position[1] = l->position[1];
position[2] = l->position[2];
position[3] = 1;
// try light nodes if possible
Lib3dsNode* ln = lib3ds_file_node_by_name(m_def->m_file, l->name, LIB3DS_LIGHT_NODE);
if (ln)
{
color[0] = ln->data.light.col[0];
color[1] = ln->data.light.col[1];
color[2] = ln->data.light.col[2];
position[0] = ln->data.light.pos[0];
position[1] = ln->data.light.pos[1];
position[2] = ln->data.light.pos[2];
}
// try spot nodes if possible
Lib3dsNode* sn = lib3ds_file_node_by_name(m_def->m_file, l->name, LIB3DS_SPOT_NODE);
if (sn)
{
l->spot[0] = sn->data.spot.pos[0];
l->spot[1] = sn->data.spot.pos[1];
l->spot[2] = sn->data.spot.pos[2];
}
static const GLfloat a[] = {0.0f, 0.0f, 0.0f, 1.0f};
glLightfv(gl_light, GL_AMBIENT, a);
glLightfv(gl_light, GL_DIFFUSE, color);
glLightfv(gl_light, GL_SPECULAR, color);
glLightfv(gl_light, GL_POSITION, position);
glLightf(gl_light, GL_LINEAR_ATTENUATION, l->attenuation);
// glLightf(gl_light, GL_CONSTANT_ATTENUATION, 0);
// glLightf(gl_light, GL_QUADRATIC_ATTENUATION, 0);
if (l->spot_light)
{
position[0] = l->spot[0];
position[1] = l->spot[1];
position[2] = l->spot[2];
glLightfv(gl_light, GL_SPOT_DIRECTION, position);
glLightf(gl_light, GL_SPOT_CUTOFF, l->fall_off);
glLightf(gl_light, GL_SPOT_EXPONENT, 0); // hack
}
l = l->next;
}
else
{
glDisable(gl_light);
}
}
glEnable(GL_LIGHTING);
}
/* static */
void
px_vp20Utils::unsetLightingGL(const MHWRender::MDrawContext& context)
{
MStatus status;
// Take into account only the 8 lights supported by the basic
// OpenGL profile.
const unsigned int nbLights =
std::min(context.numberOfActiveLights(&status), 8u);
if (status != MStatus::kSuccess) return;
// Restore OpenGL default values for anything that we have
// modified.
if (nbLights > 0) {
for (unsigned int i=0; i<nbLights; ++i) {
glDisable(GL_LIGHT0+i);
const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient);
if (i==0) {
const GLfloat diffuse[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
const GLfloat spec[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_SPECULAR, spec);
}
else {
const GLfloat diffuse[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
const GLfloat spec[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_SPECULAR, spec);
}
const GLfloat pos[4] = { 0.0f, 0.0f, 1.0f, 0.0f };
glLightfv(GL_LIGHT0+i, GL_POSITION, pos);
const GLfloat dir[3] = { 0.0f, 0.0f, -1.0f };
glLightfv(GL_LIGHT0+i, GL_SPOT_DIRECTION, dir);
glLightf(GL_LIGHT0+i, GL_SPOT_EXPONENT, 0.0);
glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0);
}
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL) ;
glDisable(GL_NORMALIZE) ;
const GLfloat ambient[4] = { 0.2f, 0.2f, 0.2f, 1.0f };
const GLfloat specular[4] = { 0.8f, 0.8f, 0.8f, 1.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
}
}
void myinit(void)
{
/*Initialize and compute the vectors for the spiral*/
spir[0][0]=0.0;
spir[0][1]=-1.0;
spir[1][0]=-sin(30.0*M_PI/180);
spir[1][1]=-cos(30.0*M_PI/180);
spir[2][0]=-cos(30.0*M_PI/180);
spir[2][1]=-sin(30.0*M_PI/180);
spir[3][0]=-1.0;
spir[3][1]=0.0;
spir[4][0]=-cos(30.0*M_PI/180);
spir[4][1]=sin(30.0*M_PI/180);
spir[5][0]=-sin(30.0*M_PI/180);
spir[5][1]=cos(30.0*M_PI/180);
spir[6][0]=0.0;
spir[6][1]=1.0;
spir[7][0]=sin(30.0*M_PI/180);
spir[7][1]=cos(30.0*M_PI/180);
spir[8][0]=cos(30.0*M_PI/180);
spir[8][1]=sin(30.0*M_PI/180);
spir[9][0]=1.0;
spir[9][1]=0;
spir[10][0]=cos(30.0*M_PI/180);
spir[10][1]=-sin(30.0*M_PI/180);
spir[11][0]=sin(30.0*M_PI/180);
spir[11][1]=-cos(30.0*M_PI/180);
for (int i = 0; i <= 103; i++)
{
cosTable[i] = cos((double)(M_PI*2*i/100.0));
sinTable[i] = sin((double)(M_PI*2*i/100.0));
}
/*create all needed spheres and initialize them with default values*/
initializeSpheres();
/*Initialize the random number creator*/
time_t t;
time(&t);
srand((unsigned int)t); //initialize with date and time
/* attributes */
glClearColor(0.0, 0.0, 0.0, 1.0); /* black background */
/* Lighting */
glLoadIdentity();
GLfloat light_ambient[] = {0.0,0.0,0.0,1.0};
GLfloat light_diffuse[] = {1.0,1.0,1.0,1.0};
GLfloat light_specular[] = {1.0,1.0,1.0,1.0};
GLfloat lmodel_ambient[] = {0.5,0.5,0.5,1.0};
GLfloat mat_amb_diff[] = { 0.5, 0.5, 0.5, 1.0 };
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 40.0 };
GLfloat light_position0[] = {1.0, 1.0, 0.0, 0.0 };
glShadeModel (GL_SMOOTH);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_amb_diff);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
//Enable Lighting
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}
PXR_NAMESPACE_OPEN_SCOPE
/* static */
bool
px_vp20Utils::setupLightingGL(const MHWRender::MDrawContext& context)
{
MStatus status;
// Take into account only the 8 lights supported by the basic
// OpenGL profile.
const unsigned int nbLights =
std::min(context.numberOfActiveLights(&status), 8u);
if (status != MStatus::kSuccess) return false;
if (nbLights > 0) {
// Lights are specified in world space and needs to be
// converted to view space.
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
const MMatrix worldToView =
context.getMatrix(MHWRender::MDrawContext::kViewMtx, &status);
if (status != MStatus::kSuccess) return false;
glLoadMatrixd(worldToView.matrix[0]);
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL) ;
glEnable(GL_NORMALIZE) ;
{
const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat specular[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
}
for (unsigned int i=0; i<nbLights; ++i) {
MFloatVector direction;
float intensity;
MColor color;
bool hasDirection;
bool hasPosition;
#if MAYA_API_VERSION >= 201300
// Starting with Maya 2013, getLightInformation() uses MFloatPointArray for positions
MFloatPointArray positions;
status = context.getLightInformation(
i, positions, direction, intensity, color,
hasDirection, hasPosition);
const MFloatPoint &position = positions[0];
#else
// Maya 2012, getLightInformation() uses MFloatPoint for position
MFloatPoint position;
status = context.getLightInformation(
i, position, direction, intensity, color,
hasDirection, hasPosition);
#endif
if (status != MStatus::kSuccess) return false;
if (hasDirection) {
if (hasPosition) {
// Assumes a Maya Spot Light!
const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat diffuse[4] = { intensity * color[0],
intensity * color[1],
intensity * color[2],
1.0f };
const GLfloat pos[4] = { position[0],
position[1],
position[2],
1.0f };
const GLfloat dir[3] = { direction[0],
direction[1],
direction[2]};
glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0+i, GL_POSITION, pos);
glLightfv(GL_LIGHT0+i, GL_SPOT_DIRECTION, dir);
// Maya's default value's for spot lights.
glLightf(GL_LIGHT0+i, GL_SPOT_EXPONENT, 0.0);
glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 20.0);
}
else {
// Assumes a Maya Directional Light!
const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat diffuse[4] = { intensity * color[0],
intensity * color[1],
intensity * color[2],
1.0f };
const GLfloat pos[4] = { -direction[0],
-direction[1],
-direction[2],
0.0f };
glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0+i, GL_POSITION, pos);
glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0);
}
}
else if (hasPosition) {
// Assumes a Maya Point Light!
const GLfloat ambient[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat diffuse[4] = { intensity * color[0],
intensity * color[1],
intensity * color[2],
1.0f };
const GLfloat pos[4] = { position[0],
position[1],
position[2],
1.0f };
glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0+i, GL_POSITION, pos);
glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0);
}
else {
// Assumes a Maya Ambient Light!
const GLfloat ambient[4] = { intensity * color[0],
intensity * color[1],
intensity * color[2],
1.0f };
const GLfloat diffuse[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat pos[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
glLightfv(GL_LIGHT0+i, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0+i, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0+i, GL_POSITION, pos);
glLightf(GL_LIGHT0+i, GL_SPOT_CUTOFF, 180.0);
}
glEnable(GL_LIGHT0+i);
}
glPopMatrix();
}
glDisable(GL_LIGHTING);
return nbLights > 0;
}
void inicializacao()
{
// inicialização de apontador para quádricas
glQ = gluNewQuadric();
glFrontFace(GL_CCW); // Front faces defined using a counterclockwise rotation
glDepthFunc(GL_LEQUAL); // Por defeito e GL_LESS
glEnable(GL_DEPTH_TEST); // Use a depth (z) buffer to draw only visible objects
// Face Culling para aumentar a velocidade
glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK); // GL_FRONT, GL_BACK, GL_FRONT_AND_BACK
// Define que modelo de iluminacao utilizar; consultar o manual de referencia
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light_ambient); // define luz ambiente
glLightModelf (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightModeli (GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
// por defeito a cor de fundo e o preto
// glClearColor(1.0,1.0,1.0,1.0); // cor de fundo a branco
// declaracoes para a fonte luz GL_LIGHT0
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, light0_kc);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, light0_kl);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, light0_kq);
// declaracoes para a fonte luz GL_LIGHT1
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, light1_kc);
glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, light1_kl);
glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, light1_kq);
// Permitir calculos de iluminacao
glEnable(GL_LIGHTING);
// "Acender" a fonte de luz GL_LIGHT0
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
// Declaracoe para shading
glShadeModel(GL_SMOOTH); // GL_FLAT / GL_SMOOTH
glPolygonMode(GL_FRONT, GL_FILL); // preence a face da frente dos poligonos
//glPolygonMode(GL_FRONT, GL_LINE); // desenha arestas dos poligonos
pixmap.readBMPFile("newspaper.bmp");
pixmap.setTexture(TX_NEWSPAPER);
pixmap.readBMPFile("paisagem.bmp");
pixmap.setTexture(TX_LANDSCAPE);
pixmap.readBMPFile("metal.bmp");
pixmap.setTexture(TX_METAL);
pixmap.readBMPFile("wood_machine.bmp");
pixmap.setTexture(TX_WOOD_MACHINE);
pixmap.readBMPFile("wood.bmp");
pixmap.setTexture(TX_WOOD_BELT);
pixmap.readBMPFile("belt.bmp");
pixmap.setTexture(TX_BELT);
pixmap.readBMPFile("floor.bmp");
pixmap.setTexture(TX_FLOOR);
pixmap.readBMPFile("guillotine.bmp");
pixmap.setTexture(TX_GUILLOTINE);
pixmap.readBMPFile("wall.bmp");
pixmap.setTexture(TX_WALL);
glNewList(DP_GEOMETRY,GL_COMPILE);
impostors();
myRoom(roomX,roomY,roomZ,windowYi,windowYf,windowZi,windowZf,doorXi,doorXf,doorY,curvedXHeight,curvedNSlices,curvedYSlices);
glEndList();
glNewList(DP_MACHINE,GL_COMPILE);
printingMachine(printingMachineX,printingMachineZ);
glEndList();
glNewList(DP_ROBOT,GL_COMPILE);
robot(robotY);
glEndList();
}
//Called to draw scene
void Display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
//use gluLookAt to look at torus
gluLookAt( 0.0f,10.0f,10.0f,
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f);
//rotate torus
static float angle=0.0f;
angle+=0.1f;
glRotatef(angle, 0.0f, 1.0f, 0.0f);
//Get the inverse model matrix
MATRIX4X4 inverseModelMatrix;
glPushMatrix();
glLoadIdentity();
glRotatef(-angle, 0.0f, 1.0f, 0.0f);
glGetFloatv(GL_MODELVIEW_MATRIX, inverseModelMatrix);
glPopMatrix();
//Get the object space light vector
VECTOR3D objectLightPosition=inverseModelMatrix*worldLightPosition;
//Loop through vertices
for(int i=0; i<torus.numVertices; ++i)
{
VECTOR3D lightVector=objectLightPosition-torus.vertices[i].position;
//Calculate tangent space light vector
torus.vertices[i].tangentSpaceLight.x=
torus.vertices[i].sTangent.DotProduct(lightVector);
torus.vertices[i].tangentSpaceLight.y=
torus.vertices[i].tTangent.DotProduct(lightVector);
torus.vertices[i].tangentSpaceLight.z=
torus.vertices[i].normal.DotProduct(lightVector);
}
//Draw bump pass
if(drawBumps)
{
//Bind normal map to texture unit 0
glBindTexture(GL_TEXTURE_2D, normalMap);
glEnable(GL_TEXTURE_2D);
//Bind normalisation cube map to texture unit 1
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, normalisationCubeMap);
glEnable(GL_TEXTURE_CUBE_MAP_ARB);
glActiveTextureARB(GL_TEXTURE0_ARB);
//Set vertex arrays for torus
glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position);
glEnableClientState(GL_VERTEX_ARRAY);
//Send texture coords for normal map to unit 0
glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//Send tangent space light vectors for normalisation to unit 1
glClientActiveTexture(GL_TEXTURE1_ARB);
glTexCoordPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].tangentSpaceLight);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0_ARB);
//Set up texture environment to do (tex0 dot tex1)*color
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_REPLACE);
glActiveTextureARB(GL_TEXTURE1_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_DOT3_RGB_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PREVIOUS_ARB);
glActiveTextureARB(GL_TEXTURE0_ARB);
//Draw torus
glDrawElements(GL_TRIANGLES, torus.numIndices, GL_UNSIGNED_INT, torus.indices);
//Disable textures
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
glActiveTextureARB(GL_TEXTURE0_ARB);
//disable vertex arrays
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE1_ARB);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0_ARB);
//Return to standard modulate texenv
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
//If we are drawing both passes, enable blending to multiply them together
if(drawBumps && drawColor)
{
//Enable multiplicative blending
glBlendFunc(GL_DST_COLOR, GL_ZERO);
glEnable(GL_BLEND);
}
//Perform a second pass to color the torus
if(drawColor)
{
if(!drawBumps)
{
glLightfv(GL_LIGHT1, GL_POSITION, VECTOR4D(objectLightPosition));
glLightfv(GL_LIGHT1, GL_DIFFUSE, white);
glLightfv(GL_LIGHT1, GL_AMBIENT, black);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, black);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT, GL_DIFFUSE, white);
}
//Bind decal texture
glBindTexture(GL_TEXTURE_2D, decalTexture);
glEnable(GL_TEXTURE_2D);
//Set vertex arrays for torus
glVertexPointer(3, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].position);
glEnableClientState(GL_VERTEX_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].normal);
glEnableClientState(GL_NORMAL_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(TORUS_VERTEX), &torus.vertices[0].s);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
//Draw torus
glDrawElements(GL_TRIANGLES, torus.numIndices, GL_UNSIGNED_INT, torus.indices);
if(!drawBumps)
glDisable(GL_LIGHTING);
//Disable texture
glDisable(GL_TEXTURE_2D);
//disable vertex arrays
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
//Disable blending if it is enabled
if(drawBumps && drawColor)
glDisable(GL_BLEND);
glFinish();
glutSwapBuffers();
glutPostRedisplay();
}
DRReturn render(float fTime)
{
glViewport(0, 0, g_pSDLWindow->w, g_pSDLWindow->h);
glClearColor(0.1, 0.2, 0.0, 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(0.0f, 0.0f, 0.0f);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
//if(g_terrain)
// g_terrain->bind();
//if(g_Player.getSektor()->renderAll(fTime, g_Player.getCamera()))
if(wireframe)
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
else
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
if(g_Player.getSektor()->renderAll(fTime, g_Player.getCamera()))
LOG_ERROR("Fehler bei render sektor", DR_ERROR);
ShaderProgram::unbind();
glDisable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
glClear (GL_DEPTH_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
//Reseten der Matrixen
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//gluPerspective(g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 2000.0f);
glMultMatrixf(DRMatrix::perspective_projection(g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 2000.0f));
DRFrustumCulling cull(g_cam, g_Player.getCameraFOV(), (GLfloat)XWIDTH/(GLfloat)YHEIGHT, 0.1f, 1000.0f);
glMatrixMode(GL_MODELVIEW); // Select the modelview matrix
glLoadIdentity(); // Reset (init) the modelview matrix
DRVector3 translate(0.0f);
g_cam->setKameraMatrix();
glEnable(GL_DEPTH_TEST); // Enables depth test
//light
//Add ambient light
GLfloat ambientColor[] = {0.4f, 0.4f, 0.4f, 1.0f}; //Color(0.2, 0.2, 0.2)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);
//Add positioned light
GLfloat lightColor0[] = {1.0f, 1.0f, 1.0f, 1.0f}; //Color (0.5, 0.5, 0.5)
GLfloat lightPos0[] = {4.0f, 0.0f, 8.0f, 1.0f}; //Positioned at (4, 0, 8)
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);
glDisable(GL_LIGHT0);
//Add directed light
GLfloat lightColor1[] = {0.5f, 0.5f, 0.5f, 1.0f}; //Color (0.5, 0.2, 0.2)
//Coming from the direction (-1, 0.5, 0.5)
GLfloat lightPos1[] = {-1.0f, 0.5f, 0.5f, 0.0f};
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor1);
glLightfv(GL_LIGHT1, GL_POSITION, lightPos1);
glEnable(GL_LIGHT1);
if(g_tex.getResourcePtrHolder())
g_tex->bind();
//glColor3f(0.2f, 0.5f, 0.1f);
/* glColor3f(1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
glTexCoord2f(1.0, 0.0f);
glVertex3f( 50.0f, 0.0f, -50.0f);
glTexCoord2f(0.0, 0.0f);
glVertex3f(-50.0f, 0.0f, -50.0f);
glTexCoord2f(0.0, 1.0f);
glVertex3f(-50.0f, 0.0f, 50.0f);
glTexCoord2f(1.0, 1.0f);
glVertex3f( 50.0f, 0.0f, 50.0f);
glEnd();
//glDisable(GL_TEXTURE_2D);
glTranslatef(0.0f, 2.0f, 0.0f);
glBegin(GL_QUADS);
glColor3f(0.0f, 0.0f, 1.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(-1.0f, 0.0f, 0.0f);
glVertex3f(-1.0f, 0.0f, -1.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glEnd();
glTranslatef(0.0f, -2.0f, 0.0f);
// printf("bevore renderBlock\n");
glTranslatef(0.0f, 10.0f, 0.0f);
translate.y += 10.0f;
//*/
RenderBlock* rb = g_RenderBlockLoader.getRenderBlock("dirt");
/*
rb->render();
glTranslatef(0.0f, -5.0f, 0.0f);
translate.y -= 5.0f;
rb = g_RenderBlockLoader.getRenderBlock("dirG");
rb->render();
glTranslatef(1.0f, 0.0f, 0.0f);
translate.x += 1.0f;
rb->render();
glTranslatef(0.0f, 2.0f, 0.0f);
translate.y += 2.0f;
DRFrustumPosition res = cull.isBoxInFrustum(DRVector3(-0.5f), DRVector3(0.5f), DRMatrix::translation(translate));
if(res != OUTSIDE)
g_RenderBlockLoader.getRenderBlock("benc")->render();
glDisable(GL_TEXTURE_2D);
//glDisable(GL_LIGHTING);
//*/
static u32 start = 0;
float dir[] = {1.0f, 1.0f};
int y = 0;
const int length = 250;
int clipCount = 0;
int renderCount = 0;
for(int i = 0; i < blockCount; i++)
{
if(!(i % 10))
{
glTranslatef(0.0f, 1.0f, 0.0f);
translate.y += 1.0f;
if(cull.isSphereInFrustum(translate, 0.6f) != OUTSIDE)
{
rb->render();
renderCount++;
}
else clipCount++;
glTranslatef(0.0f, -1.0f, 0.0f);
translate.y -= 1.0f;
}
if(!(i % length))
{
if(!(y % length))
{
glTranslatef(0.0f, 1.0f, 0.0f);
translate.y += 1.0f;
dir[1] *= -1.0f;
dir[0] *= -1.0f;
}
else
{
glTranslatef(0.0f, 0.0f, 1.0f*dir[1]);
translate.z += 1.0f*dir[1];
dir[0] *= -1.0f;
}
y++;
}
else
{
glTranslatef(1.0f*dir[0], 0.0f, 0.0f);
translate.x += 1.0f*dir[0];
}
if(cull.isSphereInFrustum(translate, 0.6f) != OUTSIDE)
{
rb->render();
renderCount++;
}
else clipCount++;
}
u32 end = SDL_GetTicks();
//FPS
g_Font->begin();
DRText text(g_Font);
text.setFlags(DR_FF_RELATIVE | DR_FF_RELATIVSCALING);
text.setText("FPS: %.0f", 1.0f/fTime);
text.setPosition(DRVector2(0.0f, 0.0f));
text.setColor12(DRColor(0.8f, 0.5f, 0.1f));
text.setScaling(DRVector2(1.0f));
text.drawText();
text.setText("Count: %d", blockCount);
text.setPosition(DRVector2(0.0f, 0.04f));
text.drawText();
text.setText("milliseconds: %u", end-start);
text.setPosition(DRVector2(0.1f, 0.0f));
text.drawText();
text.setText("Steuerung: %d - %s/s", gCurrentControlMode+1, gControlModes[gCurrentControlMode].mValue.print().data());
text.setPosition(DRVector2(0.0f, 0.08f));
text.drawText();
GlobalRenderer& gb = GlobalRenderer::Instance();
DRTextureManager& tx = DRTextureManager::Instance();
text.setColor12(DRColor(1.0f, 1.0f, 1.0f));
text.setScaling(DRVector2(0.8f));
text.setText("Grafik Memory: %.0f MByte", static_cast<double>(tx.getGrafikMemoryTexture()+gb.getGrafikMemoryGeometrie())/(1024.0f*1024.0));
text.setPosition(DRVector2(0.8f, 0.0f));
text.drawText();
text.setText("Texture: %.0f MByte", static_cast<double>(tx.getGrafikMemoryTexture())/(1024.0f*1024.0));
text.setPosition(DRVector2(0.8f, 0.04f));
text.drawText();
text.setText("Geometrie: %.0f MByte",static_cast<double>(gb.getGrafikMemoryGeometrie())/(1024.0f*1024.0));
text.setPosition(DRVector2(0.8f, 0.08f));
text.drawText();
g_Font->end();
start = SDL_GetTicks();
if(GlobalRenderer::Instance().renderTasks())
LOG_ERROR("Fehler bei calling GlobalRenderer::renderTasks", DR_ERROR);
return DR_OK;
}
int main ( int argc, char** argv )
{
// Initialize world.
DYN_initialize(&world, 0.02);
{
DYN_Body body;
DYN_BodyStaticAttributes attributes;
double nullVector[3] = {0, 0, 0};
double identity[9] =
{
1, 0, 0,
0, 1, 0,
0, 0, 1
};
// double impulse[3] = {100, 0, 0};
// double pointOfImpulse[3] = {0, 1, 1};
attributes.shape = DYN_BS_CUBOID;
attributes.cuboidAttributes.width = 3;
attributes.cuboidAttributes.height = 3;
attributes.cuboidAttributes.depth = 3;
DYN_calculateMass(&attributes, 1);
memcpy(body.position, nullVector, sizeof(nullVector));
memcpy(body.velocity, nullVector, sizeof(nullVector));
memcpy(body.angularVelocity, nullVector, sizeof(nullVector));
memcpy(body.orientation, identity, sizeof(identity));
DYN_addBody(&world, &body, &attributes);
//applyImpulse(&world, &world.bodies[0], pointOfImpulse, impulse);
/* attributes.cuboidAttributes.width = 1;
attributes.cuboidAttributes.height = 1;
attributes.cuboidAttributes.depth = 1;
DYN_calculateMass(&attributes, 1);
body.position[0] = 0;
body.position[1] = 0;
body.position[2] = -100;
body.velocity[2] = 1;
DYN_addBody(&world, &body, &attributes);*/
{
int i,j,k;
attributes.cuboidAttributes.width = 3;
attributes.cuboidAttributes.height = 3;
attributes.cuboidAttributes.depth = 3;
DYN_calculateMass(&attributes, 1);
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
for (k = 0; k < 4; k++)
{
body.position[0] = 10 + 5*i;
body.position[1] = 10 + 5*j;
body.position[2] = 10 + 5*k;
memcpy(body.velocity, nullVector, sizeof(nullVector));
DYN_addBody(&world, &body, &attributes);
}
}
}
}
}
// initialize SDL video
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
{
printf( "Unable to init SDL: %s\n", SDL_GetError() );
return 1;
}
// make sure SDL cleans up before exit
atexit(SDL_Quit);
// Setting OpenGL attributes
SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
// create a new window
SDL_Surface* screen = SDL_SetVideoMode(RESOLUTION_X, RESOLUTION_Y, 16,
SDL_HWSURFACE | SDL_OPENGL);
// Lock mouse in
SDL_ShowCursor(0);
//SDL_WM_GrabInput(SDL_GRAB_ON); //< Toggle this
// Create display lists
createDisplayLists();
// Initialize modes
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
// Initialize gl matrixes
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60, 4.0/3.0, 1, 100000.0);
// Initlalize GL lights
{
GLfloat ambient[4] = {0.1, 0.1, 0.1, 1};
GLfloat diffuseColor[4] = {1, 1, 1, 1};
GLfloat specularColor[4] = {0,0,0,0};
glEnable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
glEnable(GL_LIGHT0);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glMatrixMode(GL_MODELVIEW);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseColor);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_SPECULAR, specularColor);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0);
}
if ( !screen )
{
printf("Unable to set 640x480 video: %s\n", SDL_GetError());
return 1;
}
// program main loop
while (!handleEvents())
{
// message processing loop
DYN_stepWorld(&world);
controlView();
draw();
usleep(20000);
// finally, update the screen
SDL_GL_SwapBuffers();
} // end main loop
// all is well ;)
printf("Exited cleanly\n");
return 0;
}
void LightingScene::init()
{
// Enables lighting computations
glEnable(GL_LIGHTING);
// Sets up some lighting parameters
// Computes lighting only using the front face normals and materials
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
// Define ambient light (do not confuse with ambient component of individual lights)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbientLight);
//glShadeModel(GL_FLAT);
// Declares and enables two lights, with null ambient component
light0 = new CGFlight(GL_LIGHT0, light0_pos);
light0->setAmbient(ambientNull);
light0->disable();
light0->setSpecular(yellow);
light0->enable();
light1 = new CGFlight(GL_LIGHT1, light1_pos);
light1->setAmbient(ambientNull);
light1->disable();
light1->enable();
light2 = new CGFlight(GL_LIGHT2, light2_pos);
light2->setAmbient(ambientNull);
light2->disable();
light2->setKc(0);
light2->setKl(1);
light2->setKq(0);
light2->enable();
light3 = new CGFlight(GL_LIGHT3, light3_pos);
light3->setAmbient(ambientNull);
light3->disable();
light3->setKc(0);
light3->setKl(0);
light3->setKq(0.2);
light3->enable();
// Uncomment below to enable normalization of lighting normal vectors
glEnable (GL_NORMALIZE);
//Declares scene elements
robot = new MyRobot(180,4,4,7);
sceneVar=0;
t = CGFapplication::getTime();
aviao=new MyPaperPlane(90,4,4,8);
clock1= new MyClock();
table = new myTable();
floor = new Plane(10, 0, 0, 0 , 0, 2);
wallWindow = new Plane(10, 0, 16,0-3.5, 8.53-3.5,1);
wall = new Plane(10, 0, 16,0-3.5, 8.53-3.5,1);
boardA = new Plane(BOARD_A_DIVISIONS,0, 512, 0, 512);
boardB = new Plane(BOARD_B_DIVISIONS,0, 512, 0-70, 372-70);
//Declares materials
materialA = new CGFappearance(ambA,difA,specA,shininessA);
materialB = new CGFappearance(ambB,difB,specB,shininessB);
slidesAppearance = new CGFappearance(ambSA,difSA,specSA,shininessSA);
slidesAppearance->setTexture("slides.png");
boardAppearance = new CGFappearance(ambBA,difBA,specBA,shininessBA);
boardAppearance->setTexture("board.png");
boardAppearance->setTextureWrap(GL_CLAMP,GL_CLAMP);
windowAppearance = new CGFappearance(ambW,difW,specW,shininessW);
windowAppearance->setTexture("window.png");
windowAppearance->setTextureWrap(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
floorAppearance = new CGFappearance(ambF,difF,specF,shininessF);
floorAppearance->setTexture("floor.png");
floorAppearance->setTextureWrap(GL_REPEAT, GL_REPEAT);
setUpdatePeriod(100);
}
void GLWidget::initializeGL()
{
initializeOpenGLFunctions();
glClearColor(0.8, 0.8, 0.8, 0);
glEnable(GL_DEPTH_TEST);
glFrontFace(GL_CW);
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
//WE ADD THE LIGHTS
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
//glEnable(GL_LIGHT3);
//Light 1 is a point light, an omni light
float lightColor[4] = { 0.5, 0.5, 0.5, 1 };
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor);
//Light 2 a blue keylight
float lightColor2[4] = { 0.5, 0.5, 0.5, 1 };
glLightfv(GL_LIGHT1, GL_DIFFUSE, lightColor2);
//Light 3 is just above the face
float lightColor3[4] = { 1.3, 1.3, 1.3, 1 };
glLightfv(GL_LIGHT2, GL_DIFFUSE, lightColor3);
/*float lightColor4[4] = { 0.3, 0.3, 0.3, 1 };
float specReflection[] = { 0.3f, 0.3f, 0.3f, 1.0f };
glMaterialfv(GL_BACK, GL_SPECULAR, specReflection);
glMateriali(GL_BACK, GL_SHININESS, 56);
glLightfv(GL_LIGHT3, GL_SPECULAR, lightColor4);*/
//ambient light
GLfloat ambientColor[] = { 0.2f, 0.2f, 0.2f, 1.0f }; //Color(0.2, 0.2, 0.2)
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);
/*glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);*/
readBackgroundImage();
glShadeModel(GL_SMOOTH);
generatingMesh = false;
//Activar el calculo de transparencias
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glClearColor(0.0, 0.0, 0.0, 0);
}
static void
pinit(ModeInfo * mi)
{
morph3dstruct *mp = &morph3d[MI_SCREEN(mi)];
glClearDepth(1.0);
glColor3f(1.0, 1.0, 1.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position0);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular);
switch (mp->object) {
case 2:
mp->draw_object = draw_cube;
mp->MaterialColor[0] = MaterialRed;
mp->MaterialColor[1] = MaterialGreen;
mp->MaterialColor[2] = MaterialCyan;
mp->MaterialColor[3] = MaterialMagenta;
mp->MaterialColor[4] = MaterialYellow;
mp->MaterialColor[5] = MaterialBlue;
mp->edgedivisions = cubedivisions;
mp->Magnitude = 2.0;
break;
case 3:
mp->draw_object = draw_octa;
mp->MaterialColor[0] = MaterialRed;
mp->MaterialColor[1] = MaterialGreen;
mp->MaterialColor[2] = MaterialBlue;
mp->MaterialColor[3] = MaterialWhite;
mp->MaterialColor[4] = MaterialCyan;
mp->MaterialColor[5] = MaterialMagenta;
mp->MaterialColor[6] = MaterialGray;
mp->MaterialColor[7] = MaterialYellow;
mp->edgedivisions = octadivisions;
mp->Magnitude = 2.5;
break;
case 4:
mp->draw_object = draw_dodeca;
mp->MaterialColor[0] = MaterialRed;
mp->MaterialColor[1] = MaterialGreen;
mp->MaterialColor[2] = MaterialCyan;
mp->MaterialColor[3] = MaterialBlue;
mp->MaterialColor[4] = MaterialMagenta;
mp->MaterialColor[5] = MaterialYellow;
mp->MaterialColor[6] = MaterialGreen;
mp->MaterialColor[7] = MaterialCyan;
mp->MaterialColor[8] = MaterialRed;
mp->MaterialColor[9] = MaterialMagenta;
mp->MaterialColor[10] = MaterialBlue;
mp->MaterialColor[11] = MaterialYellow;
mp->edgedivisions = dodecadivisions;
mp->Magnitude = 2.0;
break;
case 5:
mp->draw_object = draw_icosa;
mp->MaterialColor[0] = MaterialRed;
mp->MaterialColor[1] = MaterialGreen;
mp->MaterialColor[2] = MaterialBlue;
mp->MaterialColor[3] = MaterialCyan;
mp->MaterialColor[4] = MaterialYellow;
mp->MaterialColor[5] = MaterialMagenta;
mp->MaterialColor[6] = MaterialRed;
mp->MaterialColor[7] = MaterialGreen;
mp->MaterialColor[8] = MaterialBlue;
mp->MaterialColor[9] = MaterialWhite;
mp->MaterialColor[10] = MaterialCyan;
mp->MaterialColor[11] = MaterialYellow;
mp->MaterialColor[12] = MaterialMagenta;
mp->MaterialColor[13] = MaterialRed;
mp->MaterialColor[14] = MaterialGreen;
mp->MaterialColor[15] = MaterialBlue;
mp->MaterialColor[16] = MaterialCyan;
mp->MaterialColor[17] = MaterialYellow;
mp->MaterialColor[18] = MaterialMagenta;
mp->MaterialColor[19] = MaterialGray;
mp->edgedivisions = icodivisions;
mp->Magnitude = 2.5;
break;
default:
mp->draw_object = draw_tetra;
mp->MaterialColor[0] = MaterialRed;
mp->MaterialColor[1] = MaterialGreen;
mp->MaterialColor[2] = MaterialBlue;
mp->MaterialColor[3] = MaterialWhite;
mp->edgedivisions = tetradivisions;
mp->Magnitude = 2.5;
break;
}
if (MI_IS_MONO(mi)) {
int loop;
for (loop = 0; loop < 20; loop++)
mp->MaterialColor[loop] = MaterialGray;
}
}
/*
some basic initialization of our GL code
*/
void InitRenderer()
{
/*
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
*/
// starting rotation.
g_yRotation = 20.0f;
g_xRotation = 30.0f;
//initialize the mouse state
MouseState.leftButton = MouseState.rightButton = MouseState.middleButton = false;
MouseState.x = MouseState.y = 0;
// init our eye location
eyex = 0;
eyey = 0;
eyez = 5;
focusx = focusy = focusz = 0.0f;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// set up our viewing frustum
int m_width = glutGet(GLUT_WINDOW_WIDTH);
int m_height = glutGet(GLUT_WINDOW_HEIGHT);
float aspect = (float)m_width/(float)m_height;
gluPerspective(40.0f, aspect, 0.0f, 10000.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); //Aggiunto
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_ambient);
glLightf( GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0f );
glLightf( GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.0f );
glLightf( GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.0f );
glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, material1 );
glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, material2 );
glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, material3 );
glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, material4 );
glMaterialf( GL_FRONT_AND_BACK, GL_SHININESS, 10.0f );
// Solid render
glPolygonMode( GL_FRONT_AND_BACK , GL_FILL );
//glPolygonMode( GL_FRONT_AND_BACK , GL_LINE );
// Shade mode
//glShadeModel(GL_FLAT);
glShadeModel(GL_SMOOTH);
// Turn on the zbuffer
glEnable( GL_DEPTH_TEST );
//glDisable( GL_DEPTH_TEST );
// Turn on zbuffer writing
glDepthMask(1);
// Turn on zbuffer function
glDepthFunc(GL_LESS);
// Turn on culling (CCW --> ogl default mode - like d3d)
glEnable( GL_CULL_FACE );
glFrontFace( GL_CCW );
}
/**
* @param {short} xi_type 0 : RC pilot view
* 1 : fly behind view
* 2 : upper view
* @return helicopter model, ground, sky and shadow on screen drawing
**/
void DrawScene(short xi_type) {
// statics (scene lighting definitions)
static const GLfloat groundAmbient[4] = {0.02f, 0.3f, 0.1f, 1.0f},
local_ambient[4] = {0.7f, 0.7f, 0.7f, 1.0f},
ambient0[4] = {0.0f, 0.0f, 0.0f, 1.0f},
diffuse0[4] = {1.0f, 1.0f, 1.0f, 1.0f},
specular0[4] = {1.0f, 0.0f, 0.0f, 1.0f},
position0[4] = {2.0f, 100.5f, 1.5f, 1.0f},
ambient1[4] = {0.0f, 0.0f, 0.0f, 1.0f},
diffuse1[4] = {1.0f, 1.0f, 1.0f, 1.0f},
specular1[4] = {1.0f, 0.0f, 0.0f, 1.0f},
position1[4] = {-2.0f, 100.5f, 1.0f, 0.0f};
// statics (squashing matrix; 3D -> 2D)
static const float mat[16] = {1.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0};
// locals
int e;
float X, Y, Z;
double camera[3], destination[3], up[3]; // view port
// scene light definitions
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, local_ambient);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0);
glLightfv(GL_LIGHT0, GL_POSITION, position0);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0);
glLightfv(GL_LIGHT0, GL_SPECULAR, specular0);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient1);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse1);
glLightfv(GL_LIGHT1, GL_SPECULAR, specular1);
// A/V position
X = heli.cg.NED[_NORTH]; // North = X computer frame
Y = -heli.cg.NED[_DOWN]; // Down = -Y computer frame
Z = heli.cg.NED[_EAST]; // East = Z computer frame
// clear view port
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
// view port
if (xi_type == 0) {
camera[_X] = 1.0;
camera[_Y] = 6.0;
camera[_Z] = 30.0;
destination[_X] = X;
destination[_Y] = Y;
destination[_Z] = Z;
up[_X] = 0.0;
up[_Y] = 1.0;
up[_Z] = 0.0;
} else if (xi_type == 1) {
camera[_X] = X - 10 * cos(heli.cg.THETA[_PSI]);
camera[_Y] = Y + 1;
camera[_Z] = Z - 10 * sin(heli.cg.THETA[_PSI]);
destination[_X] = X;
destination[_Y] = Y;
destination[_Z] = Z;
up[_X] = 0.0;
up[_Y] = 1.0;
up[_Z] = 0.0;
} else if (xi_type == 2){
camera[_X] = X;
camera[_Y] = 50;
camera[_Z] = Z;
destination[_X] = X;
destination[_Y] = Y;
destination[_Z] = Z;
up[_X] = 1.0;
up[_Y] = 1.0;
up[_Z] = 0.0;
}
gluLookAt(camera[_X], camera[_Y], camera[_Z],
destination[_X], destination[_Y], destination[_Z],
up[_X], up[_Y], up[_Z]);
glEnable(GL_NORMALIZE);
glDisable(GL_LIGHTING);
// origin heli pad lines
glLineWidth(3.0f);
glColor3f(0.0f, 0.0f, 1.0f);
glBegin(GL_LINES);
glVertex3f( 0.0f, 1.0f, 0.0f);
glVertex3f( 0.0f, 0.0f, 0.0f);
glVertex3f( 1.0f, 1.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f(-1.0f, 1.0f, 1.0f);
glVertex3f( 1.0f, 1.0f, -1.0f);
glEnd();
// origin heli pad circle
DrawCircle(0.0, 0.0, 1.0, 8);
glLineWidth(1.0f);
//ground
glEnable(GL_LIGHTING);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, groundAmbient);
glBegin(GL_POLYGON);
glNormal3f(0.0f, 1.0f, 0.0f);
glVertex3f(31200.0f, -0.0f, -31200.0f);
glVertex3f(-31200.0f, -0.0f, -31200.0f);
glVertex3f(-31200.0f, -0.0f, 31200.0f);
glVertex3f(31200.0f, -0.0f, 31200.0f);
glEnd();
glDisable(GL_LIGHTING);
for(e = -1000; e <= 1000; e += 50) {
glColor3f(0.0f, 0.0f, 0.0f);
glBegin(GL_LINES);
glVertex3f(e, 0.8, -1000.0f);
glVertex3f(e, 0.8, 1000.0f);
glVertex3f(-1000.0f, 0.8, e);
glVertex3f(1000.0f, 0.8, e);
glEnd();
}
glEnable(GL_LIGHTING);
glPushMatrix();
glTranslatef(X, Y, Z);
glRotatef(heli.cg.THETA[_PSI]*C_RAD2DEG, 0.0f, -1.0f, 0.0);
glRotatef(heli.cg.THETA[_THETA]*C_RAD2DEG, 0.0f, 0.0f, 1.0f);
glRotatef(heli.cg.THETA[_PHI]*C_RAD2DEG, 1.0f, 0.0f, 0.0f);
DrawXcellModel();
glPopMatrix();
/*
for (i = 0; i < 6; i++) {
glPushMatrix();
glTranslatef(X + pow(-1, i)*i*6, Y + 2*i, Z - i*7);
glRotatef(xcell.cg.THETA[_PSI]*C_RAD2DEG + i*50, 0.0f, -1.0f, 0.0); // heading
glRotatef(xcell.cg.THETA[_THETA]*C_RAD2DEG - i*3, 0.0f, 0.0f, 1.0f); // pitch
glRotatef(xcell.cg.THETA[_PHI]*C_RAD2DEG + i*4, 1.0f, 0.0f, 0.0f); // roll
DrawXcellModel();
glPopMatrix();
}
*/
glPushMatrix();
// Draw the shadows
glMultMatrixf(mat);
// Everything now is flattened onto the ground
glTranslatef(X, 0.01, Z);
glRotatef(heli.cg.THETA[_PSI] * C_RAD2DEG, 0.0f, -1.0f, 0.0);
glRotatef(heli.cg.THETA[_THETA] * C_RAD2DEG, 0.0f, 0.0f, 1.0f);
glRotatef(heli.cg.THETA[_PHI] * C_RAD2DEG, 1.0f, 0.0f, 0.0f);
DrawXcellShadowModel();
glPopMatrix();
}
int main(int argc, char *argv[])
{
//All must bow for the migthy vector of DOOOOM!
vec3 p;
eoInitAll(argc, argv, DATADIR);
//Enable mouse-selection
eoGameEnableMouseSelection(0.2);
eoExec("testbox 1");
//Load the cursor
sprite_base* dcur_sprb = eoSpriteBaseLoad(Data("/data/gfx/","cursor.spr"));
dcur_spr = eoSpriteNew( dcur_sprb, 1, 1 );
sprite_base* hcur_sprb = eoSpriteBaseLoad(Data("/data/gfx/","cursorH.spr"));
hcur_spr = eoSpriteNew( hcur_sprb, 1, 1 );
//Setup the 2D gui context
ingameContext = eoGuiContextCreate();
winHalp = eoGuiAddWindow(ingameContext, 10, 10, 200, 50, "Halp", NULL);
int lblOffset=0, lblInc=13;
eoGuiAddLabel(winHalp, 0, 0, "F1 = Console");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "h = Toggle Halp");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "click = Select Obj");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "u,o = obj move y");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "i,j,k,l = obj move x/z");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "8,9= obj rot around y");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "space =free/lock camera");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "del = delete selected object");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "shift = move slower");
lblOffset+=lblInc;
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "Cmds:");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "-------------");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "quit 1");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "addat /dir/file.obj className");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "add /dir/file.obj className");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "rot x y z");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "pos x y z");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "class [newClassName]");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "save FILENAME.lvl");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "merge FILENAME.lvl");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "pinc [num]");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "rinc [num]");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "testbox [0 or 1]");
eoGuiAddLabel(winHalp, 0, lblOffset+=lblInc, "hitbox [0 or 1]");
winHalp->_size.y +=lblOffset;
winObjInfo = eoGuiAddWindow(ingameContext, eoSetting()->res.x- 160, eoSetting()->res.y - 110, 150,100, "Object Info", NULL );
lblInfoClassName = eoGuiAddLabel( winObjInfo, 0,0, "Class: No Object ");
lblInfoId = eoGuiAddLabel( winObjInfo, 0,10, "Id: No Object ");
lblInfoPos = eoGuiAddLabel( winObjInfo, 0,20, "Pos: No Object ");
lblInfoRot = eoGuiAddLabel( winObjInfo, 0,30, "Rot: No Object ");
hackyPos.x = 0;
hackyPos.y = 2.5;
hackyPos.z = 0;
eoCamPosSet( hackyPos );
hackyPos.x = 0;
hackyPos.y = 0;
hackyPos.z = -10;
eoCamTargetSet( hackyPos );
eoExec( "camfree 1" );
eoFuncAdd( conLoadObj, NULL, "add");
eoFuncAdd( conLoadObjP, NULL, "addat");
eoFuncAdd( conRotObj, NULL, "rot");
eoFuncAdd( conPosObj, NULL, "pos");
eoFuncAdd( conClassObj, NULL, "class");
eoFuncAdd( conMergeLevel, NULL, "merge");
eoFuncAdd( conSaveLevel, NULL, "save");
eoVarAdd(CON_TYPE_VEC3,0, &hackyPos, "_selectedPos");
eoVarAdd(CON_TYPE_VEC3,0, &hackyRot, "_selectedRot");
eoVarAdd(CON_TYPE_FLOAT,0, &rinc, "rinc");
eoVarAdd(CON_TYPE_FLOAT,0, &pinc, "pinc");
//Set active context
eoGuiContextSet(ingameContext);
eoGuiWarpMouse( eoSetting()->res.x/2, eoSetting()->res.y/2 );
//Set camera to somewhere
p.x=14;
p.y=2;
p.z=-2.5;
eoCamPosSet(p);
p.x=-8.52066;
p.y=2.107272;
p.z=7.96192;
//and at something
eoCamTargetSet( p );
//Enable 2Dinterface
eoGuiShow();
eoGuiShowCursor(1);
//Pause simulation
eoPauseSet(FALSE);
//Register callback function
eoRegisterStartFrameFunc( frameStart );
//Set some GL light stuffs
GLfloat global_ambient[] = { 0.2f, 0.2f, 0.2f, 2.0f };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient);
GLfloat pos[] = { 10,10,10,0 }; //Last pos: 0 = dir, 1=omni
glLightfv( GL_LIGHT0, GL_POSITION, pos );
GLfloat specular[] = {0.0, 0.0, 0.0, 1.0};
glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
eoInpAddFunc( "exit", "Exit the game.", inpQuitFunc, INPUT_FLAG_DOWN);
eoInpAddFunc( "halp", "Toggle the halp window.", inpToggleHalp, INPUT_FLAG_DOWN);
eoExec("bind h halp");
eoInpAddFunc( "camtoggle", "Toggle the camfree.", inpToggleCam, INPUT_FLAG_DOWN);
eoExec("bind space camtoggle");
eoInpAddFunc( "objMoveUp", "Move currently selected object up along Y.", inpMoveObjUp, INPUT_FLAG_HOLD);
eoInpAddFunc( "objMoveDn", "Move currently selected object down along Y.", inpMoveObjDn, INPUT_FLAG_HOLD);
eoInpAddFunc( "objMoveLeft", "Move currently selected object down along X.", inpMoveObjLeft, INPUT_FLAG_HOLD);
eoInpAddFunc( "objMoveRight", "Move currently selected object up along X.", inpMoveObjRight, INPUT_FLAG_HOLD);
eoInpAddFunc( "objMoveForward", "Move currently selected object down along Z.", inpMoveObjForward, INPUT_FLAG_HOLD);
eoInpAddFunc( "objMoveBackward", "Move currently selected object up along Z.", inpMoveObjBackward, INPUT_FLAG_HOLD);
eoInpAddFunc( "objRotYCW", "Rotate around Y clockwise.", inpRotYPlus, INPUT_FLAG_HOLD);
eoInpAddFunc( "objRotYCCW", "Rotate around Y counter-clockwise.", inpRotYMinus, INPUT_FLAG_HOLD);
eoInpAddFunc( "objSlow", "Make movement and rotation slow.", inpSlowObj, INPUT_FLAG_UP|INPUT_FLAG_DOWN);
eoInpAddFunc( "objRm", "Remove object", inpObjRm, INPUT_FLAG_DOWN);
eoExec("bind u objMoveUp");
eoExec("bind o objMoveDn");
eoExec("bind i objMoveForward");
eoExec("bind k objMoveBackward");
eoExec("bind j objMoveLeft");
eoExec("bind l objMoveRight");
eoExec("bind 8 objRotYCW");
eoExec("bind 9 objRotYCCW");
eoExec("bind shiftl objSlow");
eoExec("bind delete objRm");
eoMainLoop();
return 0;
}
ENTRYPOINT void
init_glblur (ModeInfo *mi)
{
glblur_configuration *bp;
int wire = MI_IS_WIREFRAME(mi);
MI_INIT (mi, bps);
bp = &bps[MI_SCREEN(mi)];
bp->glx_context = init_GL(mi);
reshape_glblur (mi, MI_WIDTH(mi), MI_HEIGHT(mi));
clear_gl_error(); /* WTF? sometimes "invalid op" from glViewport! */
if (!wire)
{
GLfloat gamb[4]= {0.2, 0.2, 0.2, 1.0};
GLfloat pos[4] = {0.0, 5.0, 10.0, 1.0};
GLfloat amb[4] = {0.2, 0.2, 0.2, 1.0};
GLfloat dif[4] = {0.3, 0.3, 0.3, 1.0};
GLfloat spc[4] = {0.8, 0.8, 0.8, 1.0};
GLfloat shiny = 128;
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_NORMALIZE);
glShadeModel(GL_SMOOTH);
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, gamb);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, spc);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMaterialf(GL_FRONT, GL_SHININESS, shiny);
}
{
Bool spinx=False, spiny=False, spinz=False;
double spin_speed = 0.9;
double wander_speed = 0.06;
char *s = do_spin;
while (*s)
{
if (*s == 'x' || *s == 'X') spinx = True;
else if (*s == 'y' || *s == 'Y') spiny = True;
else if (*s == 'z' || *s == 'Z') spinz = True;
else if (*s == '0') ;
else
{
fprintf (stderr,
"%s: spin must contain only the characters X, Y, or Z (not \"%s\")\n",
progname, do_spin);
exit (1);
}
s++;
}
bp->rot = make_rotator (spinx ? spin_speed : 0,
spiny ? spin_speed : 0,
spinz ? spin_speed : 0,
1.0,
do_wander ? wander_speed : 0,
False);
bp->trackball = gltrackball_init (True);
}
if (blursize < 0) blursize = 0;
if (blursize > 200) blursize = 200;
bp->ncolors = 128;
bp->colors0 = (XColor *) calloc(bp->ncolors, sizeof(XColor));
bp->colors1 = (XColor *) calloc(bp->ncolors, sizeof(XColor));
bp->colors2 = (XColor *) calloc(bp->ncolors, sizeof(XColor));
bp->colors3 = (XColor *) calloc(bp->ncolors, sizeof(XColor));
make_smooth_colormap (0, 0, 0, bp->colors0, &bp->ncolors, False, 0, False);
make_smooth_colormap (0, 0, 0, bp->colors1, &bp->ncolors, False, 0, False);
make_smooth_colormap (0, 0, 0, bp->colors2, &bp->ncolors, False, 0, False);
make_smooth_colormap (0, 0, 0, bp->colors3, &bp->ncolors, False, 0, False);
bp->ccolor = 0;
bp->obj_dlist0 = glGenLists (1);
bp->obj_dlist1 = glGenLists (1);
bp->obj_dlist2 = glGenLists (1);
bp->obj_dlist3 = glGenLists (1);
bp->scene_dlist1 = glGenLists (1);
bp->scene_dlist2 = glGenLists (1);
init_texture (mi);
generate_object (mi);
}
static void
pinit(ModeInfo *mi)
{
/* int status; */
glClearDepth(1.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position0);
glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, position1);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_NORMALIZE);
glCullFace(GL_BACK);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialWhite);
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
glEnable(GL_CULL_FACE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#if 0
clear_gl_error();
status = gluBuild2DMipmaps(GL_TEXTURE_2D, 3,
WoodTextureWidth, WoodTextureHeight,
GL_RGB, GL_UNSIGNED_BYTE, WoodTextureData);
if (status)
{
const char *s = (char *) gluErrorString (status);
fprintf (stderr, "%s: error mipmapping %dx%d texture: %s\n",
progname, WoodTextureWidth, WoodTextureHeight,
(s ? s : "(unknown)"));
exit (1);
}
check_gl_error("mipmapping");
#else
{
XImage *img = image_data_to_ximage (mi->dpy, mi->xgwa.visual,
wood_png, sizeof(wood_png));
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
img->width, img->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, img->data);
check_gl_error("texture");
XDestroyImage (img);
}
#endif
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_shininess);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_specular);
}
void GlslApplication::render_scene() const
{
// backup state so it doesn't mess up students stuff
glPushAttrib( GL_ALL_ATTRIB_BITS );
glPushClientAttrib( GL_CLIENT_ALL_ATTRIB_BITS );
// we set most gl state each time since it all gets popped each frame
glClearColor(
scene.background_color.r,
scene.background_color.g,
scene.background_color.b,
1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable( GL_NORMALIZE );
glEnable( GL_DEPTH_TEST );
glEnable( GL_LIGHTING );
glEnable( GL_TEXTURE_2D );
// set camera transform
const Camera& camera = camera_control.camera;
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( camera.get_fov_degrees(),
camera.get_aspect_ratio(),
camera.get_near_clip(),
camera.get_far_clip() );
const Vector3& campos = camera.get_position();
const Vector3 camref = camera.get_direction() + campos;
const Vector3& camup = camera.get_up();
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
gluLookAt( campos.x, campos.y, campos.z,
camref.x, camref.y, camref.z,
camup.x, camup.y, camup.z );
// set light data
float arr[4];
arr[3] = 1.0; // w is always 1
scene.ambient_light.to_array( arr );
glLightModelfv( GL_LIGHT_MODEL_AMBIENT, arr );
glLightModeli( GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE );
const Scene::PointLightList& lights = scene.get_lights();
for ( size_t i = 0; i < NUM_GL_LIGHTS && i < lights.size(); i++ ) {
const PointLight& light = lights[i];
glEnable( LightConstants[i] );
light.color.to_array( arr );
glLightfv( LightConstants[i], GL_DIFFUSE, arr );
glLightfv( LightConstants[i], GL_SPECULAR, arr );
glLightf( LightConstants[i], GL_CONSTANT_ATTENUATION, light.attenuation.constant );
glLightf( LightConstants[i], GL_LINEAR_ATTENUATION, light.attenuation.linear );
glLightf( LightConstants[i], GL_QUADRATIC_ATTENUATION, light.attenuation.quadratic );
light.position.to_array( arr );
glLightfv( LightConstants[i], GL_POSITION, arr );
}
// render each object
const Scene::GeometryList& geometries = scene.get_geometries();
for ( size_t i = 0; i < geometries.size(); ++i ) {
const Geometry& geom = *geometries[i];
Vector3 axis;
real_t angle;
glPushMatrix();
glTranslated( geom.position.x, geom.position.y, geom.position.z );
geom.orientation.to_axis_angle( &axis, &angle );
glRotated( angle * ( 180.0 / PI ), axis.x, axis.y, axis.z );
glScaled( geom.scale.x, geom.scale.y, geom.scale.z );
geom.render();
glPopMatrix();
}
glPopClientAttrib();
glPopAttrib();
}
