void skeletonID_callback(Fl_Value_Input *obj, void*)
{
int subnum;
subnum = (int)sub_input->value();
if (subnum < 0)
{
sub_input->value(0);
subnum = 0;
}
else
if (subnum >= displayer.GetNumSkeletons())
{
sub_input->value(displayer.GetNumSkeletons() - 1);
subnum = displayer.GetNumSkeletons() - 1;
}
// Change values of other inputs to match sub-number
double translation[3];
displayer.GetSkeleton(subnum)->GetTranslation(translation);
double rotationAngle[3];
displayer.GetSkeleton(subnum)->GetRotationAngle(rotationAngle);
tx_input->value(translation[0]);
ty_input->value(translation[1]);
tz_input->value(translation[2]);
rx_input->value(rotationAngle[0]);
ry_input->value(rotationAngle[1]);
rz_input->value(rotationAngle[2]);
glwindow->redraw();
}
void rz_callback(Fl_Value_Input *obj, void*)
{
int subnum = 0;
subnum = (int)sub_input->value();
if (subnum < displayer.GetNumSkeletons() && subnum >= 0)
displayer.GetSkeleton(subnum)->SetRotationAngleZ(rz_input->value());
glwindow->redraw();
}
void tx_callback(Fl_Value_Input *obj, void*)
{
int subnum = 0;
subnum = (int)sub_input->value();
if (subnum < displayer.GetNumSkeletons() && subnum >= 0)
displayer.GetSkeleton(subnum)->SetTranslationX(tx_input->value());
glwindow->redraw();
}
/*
* Redisplay() is called by Player_Gl_Window::draw().
*
* The display is double buffered, and FLTK swap buffers when
* Player_Gl_Window::draw() returns. The GL context associated with this
* instance of Player_Gl_Window is set to be the current context by FLTK
* when it calls draw().
*/
void Redisplay()
{
/* clear image buffer to black */
glClearColor(1.0, 1.0, 1.0, 0);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); /* clear image, zbuf */
glPushMatrix(); /* save current transform matrix */
cameraView();
glLineWidth(2.0); /* we'll draw background with thick lines */
if (renderWorldAxes == ON)
{
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_FOG);
RenderWorldAxes(); /* draw a triad in the origin of the world coordinate */
}
if (groundPlane == ON)
{
if (useFog == ON)
{
glEnable(GL_FOG);
GLfloat fogColor[4] = {1.0, 1.0, 1.0, 1.0};
glFogfv(GL_FOG_COLOR, fogColor);
glFogf(GL_FOG_START, (float)fogStart);
glFogf(GL_FOG_END, (float)fogEnd);
glFogf(GL_FOG_DENSITY, (float)fogDensity);
glFogi(GL_FOG_MODE, GL_LINEAR);
}
// draw_ground();
glEnable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glCallList(displayListGround);
glDisable(GL_LIGHTING);
glDisable(GL_FOG);
glLineWidth(1.0);
glColor3f(0.1f, 0.1f, 0.1f);
double ground[4] = {0,1,0,0};
double light[4] = {0,groundPlaneLightHeight,0,1};
displayer.RenderShadow(ground, light);
}
// render the skeletons
if (displayer.GetNumSkeletons())
{
glEnable(GL_LIGHTING);
glDisable(GL_FOG);
displayer.Render(DisplaySkeleton::BONES_AND_LOCAL_FRAMES);
}
glPopMatrix(); // restore current transformation matrix
}
void UpdateMaxFrameNumber(void)
{
maxFrames = 0;
for(int skeletonIndex = 0; skeletonIndex < displayer.GetNumSkeletons(); skeletonIndex++)
{
int currentFrames = displayer.GetSkeletonMotion(skeletonIndex)->GetNumFrames();
if (currentFrames > maxFrames)
maxFrames = currentFrames;
}
}
void load_callback(Fl_Button *button, void *)
{
if(button == loadSkeleton_button)
if (lastSkeleton <= lastMotion) // cannot load new skeleton until motion is assigned to the current skeleton
{
char * filename = fl_file_chooser("Select filename","*.ASF","");
if(filename != NULL)
{
// Read skeleton from asf file
pSkeleton = new Skeleton(filename, MOCAP_SCALE);
lastSkeleton++;
// Set the rotations for all bones in their local coordinate system to 0
// Set root position to (0, 0, 0)
pSkeleton->setBasePosture();
displayer.LoadSkeleton(pSkeleton);
glwindow->redraw();
}
}
if(button == loadMotion_button)
{
if ((lastSkeleton >= 0) && (lastSkeleton >= lastMotion))
{
char * filename = fl_file_chooser("Select filename","*.AMC","");
if(filename != NULL)
{
// Read motion (.amc) file and create a motion
pMotion = new Motion(filename, MOCAP_SCALE, pSkeleton);
// backup the filename
strcpy(lastMotionFilename, filename);
// set sampled motion for display
displayer.LoadMotion(pMotion);
if (lastSkeleton > lastMotion)
lastMotion++;
UpdateMaxFrameNumber();
resetPostureAccordingFrameSlider();
frame_slider->value(currentFrameIndex);
frame_slider->maximum((double)maxFrames);
frame_slider->redraw();
glwindow->redraw();
Fl::flush();
}
} // if (lastSkeleton > lastMotion)
}
glwindow->redraw();
}
//////////////////////////////////////////////////////////////////////////////////
// Load up a new motion captured frame
//////////////////////////////////////////////////////////////////////////////////
void SetSkeletonsToSpecifiedFrame(int frameIndex)
{
if (frameIndex < 0)
{
printf("Error in SetSkeletonsToSpecifiedFrame: frameIndex %d is illegal.\n", frameIndex);
exit(0);
}
if (displayer.GetSkeletonMotion(0) != NULL)
{
int postureID;
if (frameIndex >= displayer.GetSkeletonMotion(0)->GetNumFrames())
postureID = displayer.GetSkeletonMotion(0)->GetNumFrames() - 1;
else
postureID = frameIndex;
displayer.GetSkeleton(0)->setPosture(* (displayer.GetSkeletonMotion(0)->GetPosture(postureID)));
}
}
void resetPostureAccordingFrameSlider(void)
{
currentFrameIndex = (int)frame_slider->value() - 1;
currentFrameIndexDoublePrecision = currentFrameIndex;
// display
for (int skeletonIndex = 0; skeletonIndex < displayer.GetNumSkeletons(); skeletonIndex++)
{
int postureID;
if (currentFrameIndex >= displayer.GetSkeletonMotion(skeletonIndex)->GetNumFrames())
postureID = displayer.GetSkeletonMotion(skeletonIndex)->GetNumFrames() - 1;
else
postureID = currentFrameIndex;
// Set skeleton to the first posture
Posture * currentPosture = displayer.GetSkeletonMotion(skeletonIndex)->GetPosture(postureID);
displayer.GetSkeleton(skeletonIndex)->setPosture(*currentPosture);
}
}
void reload_callback(Fl_Button *button, void *)
{
if (!displayer.GetNumSkeletons())
return;
// Read motion (.amc) file and create a motion
pMotion = new Motion(lastMotionFilename, MOCAP_SCALE, pSkeleton);
// Set sampled motion for display
displayer.LoadMotion(pMotion);
resetPostureAccordingFrameSlider();
UpdateMaxFrameNumber();
frame_slider->maximum((double)maxFrames);
frame_slider->value(currentFrameIndex);
frame_slider->redraw();
Fl::flush();
glwindow->redraw();
}
void resetScene_callback(Fl_Button *button, void *)
{
rewindButton = ON;
playButton = OFF;
repeatButton = OFF;
lastSkeleton = -1;
lastMotion = -1;
displayer.Reset();
maxFrames = 0;
glwindow->redraw();
framesIncrementDoublePrecision = 1.0;
currentFrameIndex = 0;
currentFrameIndexDoublePrecision = 0.0;
}
//////////////////////////////////////////////////////////////////////////////////
// Called occasionally to see if anything's happening
//////////////////////////////////////////////////////////////////////////////////
void idle()
{
// load up the next motion capture frame
SetSkeletonsToSpecifiedFrame(currentFrameIndex);
if (animate)
currentFrameIndex+=2;
// if we've reached the end of the motion capture sequence,
// start over from frome 0
int totalFrames = displayer.GetSkeletonMotion(0)->GetNumFrames();
if (currentFrameIndex >= maxFrameIndex)
{
currentFrameIndex = 0;
cout << " Hit end frame, exiting" << endl;
exit(0);
}
glutPostRedisplay();
}
int main(int argc, char **argv)
{
// Initialize form, sliders and buttons
form = make_window();
performanceCounter.StartCounter(); // init
saveFileTimeCounter.StartCounter(); // init
groundPlane_button->value(groundPlane);
fog_button->value(useFog);
worldAxes_button->value(renderWorldAxes);
frame_slider->value(1);
if (saveScreenToFile == SAVE_CONTINUOUS)
record_button->value(1); // ON
else
record_button->value(0); // OFF
// just do some timing, no special purpose
// because the first data is always not trustable according to experience
performanceCounter.StopCounter();
performanceCounter.GetElapsedTime();
saveFileTimeCounter.StopCounter();
saveFileTimeCounter.GetElapsedTime();
performanceCounter.StartCounter();
// show form, and do initial draw of model
form->show();
glwindow->show(); // glwindow is initialized when the form is built
performanceCounter.StopCounter();
if (argc > 2)
{
char *filename;
filename = argv[1];
if(filename != NULL)
{
//Read skeleton from asf file
pSkeleton = new Skeleton(filename, MOCAP_SCALE);
//Set the rotations for all bones in their local coordinate system to 0
//Set root position to (0, 0, 0)
pSkeleton->setBasePosture();
displayer.LoadSkeleton(pSkeleton);
lastSkeleton++;
}
if (displayer.GetNumSkeletons())
{
filename = argv[2];
if(filename != NULL)
{
//Read motion (.amc) file and create a motion
pMotion = new Motion(filename, MOCAP_SCALE,pSkeleton);
//set sampled motion for display
displayer.LoadMotion(pMotion);
lastMotion++;
//Tell skeleton to perform the first pose ( first posture )
pSkeleton->setPosture(*(displayer.GetSkeletonMotion(0)->GetPosture(0)));
// Set skeleton to perform the first pose ( first posture )
int currentFrames = displayer.GetSkeletonMotion(0)->GetNumFrames();
if (currentFrames > maxFrames)
{
maxFrames = currentFrames;
frame_slider->maximum((double)maxFrames);
}
frame_slider->maximum((double)maxFrames);
currentFrameIndex=0;
} // if(filename != NULL)
}
else
printf("Load a skeleton first.\n");
framesIncrementDoublePrecision = 1.0; // Current frame and frame increment
playButton = ON;
repeatButton = OFF;
groundPlane = ON;
glwindow->redraw();
} // if (argc > 2)
Fl::add_idle(idle);
return Fl::run();
}
void spotJoint_callback(Fl_Value_Input *obj, void *)
{
displayer.SetDisplayedSpotJoint((int) joint_idx->value());
glwindow->redraw();
}
void idle(void*)
{
if (previousPlayButtonStatus == ON)
{
// it means we should measure the interval between two frames
// if it is too tiny, we should slow down the motion
performanceCounter.StopCounter();
double actualTimeCostOneFrame = performanceCounter.GetElapsedTime(); // in seconds
// time spent on saving the screen in previous time-step should be excluded
if (saveFileTimeCost > 0.0)
actualTimeCostOneFrame -= saveFileTimeCost;
framesIncrementDoublePrecision = actualTimeCostOneFrame * expectedFPS;
}
// start counter at the beginning of the new round
if (playButton == ON)
performanceCounter.StartCounter();
if(rewindButton == ON)
{
currentFrameIndex = 0;
currentFrameIndexDoublePrecision = 0.0;
for (int i = 0; i < displayer.GetNumSkeletons(); i++)
{
if (displayer.GetSkeletonMotion(i) != NULL)
{
Posture * initSkeleton = displayer.GetSkeletonMotion(i)->GetPosture(0);
displayer.GetSkeleton(i)->setPosture(*initSkeleton);
}
}
rewindButton = OFF;
}
// Initialization
saveFileTimeCost = -1.0;
if(playButton == ON)
{
if (saveScreenToFile == SAVE_CONTINUOUS)
{
saveFileTimeCounter.StartCounter();
CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename);
saveScreenshot(640, 480, saveScreenToFileContinuousFilename);
printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename);
saveScreenToFileContinuousCount++;
saveFileTimeCounter.StopCounter();
saveFileTimeCost = saveFileTimeCounter.GetElapsedTime();
}
if (saveScreenToFile == SAVE_CONTINUOUS)
{
currentFrameIndexDoublePrecision += 1.0;
}
else
{
currentFrameIndexDoublePrecision += framesIncrementDoublePrecision;
}
currentFrameIndex = (int)currentFrameIndexDoublePrecision;
if(currentFrameIndex >= maxFrames)
{
if (repeatButton == ON)
{
currentFrameIndex = 0;
currentFrameIndexDoublePrecision = 0.0;
}
else // repeat button is OFF
{
currentFrameIndex = maxFrames - 1;
currentFrameIndexDoublePrecision = currentFrameIndex;
playButton = OFF; // important, especially in "recording" mode
}
}
if (currentFrameIndex < 0)
{
currentFrameIndex = 0;
currentFrameIndexDoublePrecision = 0.0;
}
SetSkeletonsToSpecifiedFrame(currentFrameIndex);
frame_slider->value((double) currentFrameIndex + 1);
} // if(playButton == ON)
if (minusOneButton == ON)
if (displayer.GetNumSkeletons() != 0)
{
currentFrameIndex--;
if (currentFrameIndex < 0)
currentFrameIndex = 0;
frame_slider->value((double) currentFrameIndex + 1);
SetSkeletonsToSpecifiedFrame(currentFrameIndex);
if (saveScreenToFile == SAVE_CONTINUOUS)
{
CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename);
saveScreenshot(640, 480, saveScreenToFileContinuousFilename);
printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename);
saveScreenToFileContinuousCount++;
}
minusOneButton = OFF;
}
if (plusOneButton == ON)
{
if (displayer.GetNumSkeletons() != 0)
{
currentFrameIndex++;
if (currentFrameIndex >= maxFrames)
currentFrameIndex = maxFrames - 1;
frame_slider->value((double) currentFrameIndex + 1);
SetSkeletonsToSpecifiedFrame(currentFrameIndex);
if (saveScreenToFile == SAVE_CONTINUOUS)
{
CreateScreenFilename(SAVE_CONTINUOUS, saveScreenToFileContinuousCount, saveScreenToFileContinuousFilename);
saveScreenshot(640, 480, saveScreenToFileContinuousFilename);
printf("%s is saved to disk.\n", saveScreenToFileContinuousFilename);
saveScreenToFileContinuousCount++;
}
plusOneButton = OFF;
}
}
frame_slider->value((double)(currentFrameIndex + 1));
previousPlayButtonStatus = playButton; // Super important updating
glwindow->redraw();
}
int main(int argc, char** argv)
{
// init frame dimensions and buffer
width = windowWidth;//800;
height = windowHeight;//600;
pixels = new unsigned char[3*width*height];
if(argc==3)
{
currentFrameIndex = atoi(argv[1]);
maxFrameIndex = atoi(argv[2]);
}
// init camera
fovy = 65;
nearz = 1;
neary = nearz * tan(fovy/2 * (PI/180));
nearx = neary * ((float)width/(float)height);
eye = Vector3(-5, 1, -5);
focus= Vector3(0, 1, 0);
up = Vector3(0, 1, 0);
// init scene objects
numObjects = 0;
boneIndex=-1;
objsPerBone=0;
// spheres
numSpheres=0;
spheres[numSpheres] = new Sphere(Vector3(0, -1000, 0), 1000, Vector3(0.5, 0.5, 0.5), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
spheres[numSpheres] = new Sphere(Vector3(-1.5, 2, 3), 0.2, Vector3(0, 0, 1), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
//cylinders
numCylinders=0;
Matrix3 rot = getRotationMatrix(90, 1, 0, 0);
cylinders[numCylinders]= new Cylinder(Vector3(-1.5, 0.5, 3), 0.2, 1.5, rot, Vector3(0, 0, 1), MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
cylinders[numCylinders]= new Cylinder(Vector3(-1.5, 2, 3), 0.005, 2, rot, Vector3(0.8, 0.8, 0.8), MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
// dumbells
float l = 0.35;
Vector3 pos = Vector3(-3, 0.07, 3);
rot = getRotationMatrix(120, 0, 1, 0);
spheres[numSpheres] = new Sphere(pos, 0.07, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
spheres[numSpheres] = new Sphere(pos+(rot*Vector3(0, 0, l)), 0.07, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
cylinders[numCylinders]= new Cylinder(pos, 0.02, l, rot, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
pos = Vector3(-3.5, 0.07, 3.4);
rot = getRotationMatrix(170, 0, 1, 0);
spheres[numSpheres] = new Sphere(pos, 0.07, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
spheres[numSpheres] = new Sphere(pos+(rot*Vector3(0, 0, l)), 0.07, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
cylinders[numCylinders]= new Cylinder(pos, 0.02, l, rot, Vector3(0.2, 0.2, 0.2), MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
//triangles
numTriangles=0;
Vector3 ah = Vector3( 2, 3, 5); Vector3 al = Vector3( 2, 0, 5);
Vector3 bh = Vector3(-5, 3, 5); Vector3 bl = Vector3(-5, 0, 5);
Vector3 ch = Vector3( 2, 3, -2); Vector3 cl = Vector3( 2, 0, -2);
Vector3 dh = Vector3(-5, 3, -2); Vector3 dl = Vector3(-5, 0, -2);
triangles[numTriangles] = new Triangle(ah, bh, al, Vector3(0, 0, 1), 0, 0, 1, 0, 0, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(bh, al, bl, Vector3(0, 0, 1), 1, 0, 0, 1, 1, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(bh, dh, bl, Vector3(0.5, 0.5, 0.5),MAT_REFLECT);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(dh, bl, dl, Vector3(0.5, 0.5, 0.5),MAT_REFLECT);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(ch, ah, cl, Vector3(1, 0, 1), 0, 0, 1, 0, 0, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(ah, cl, al, Vector3(1, 0, 1), 1, 0, 0, 1, 1, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(dh, ch, dl, Vector3(1, 1, 0), 0, 0, 1, 0, 0, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(ch, dl, cl, Vector3(1, 1, 0), 1, 0, 0, 1, 1, 1);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(ah, bh, ch, Vector3(0.75, 0.75, 0.75),MAT_DIFFUSE);
objects[numObjects++] = triangles[numTriangles++];
triangles[numTriangles] = new Triangle(bh, ch, dh, Vector3(0.75, 0.75, 0.75),MAT_DIFFUSE);
objects[numObjects++] = triangles[numTriangles++];
// lights
numLights=0;
lights[numLights++] = new Light(Vector3(1, 2, -1), Vector3(0.5, 0.5, 0.5),
Vector3(1.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 1.0f), 1, 1, 0.05f);
lights[numLights++] = new Light(Vector3(-1, 2.9, -1), Vector3(0.5, 0.5, 0.5),
Vector3(1.0f, 0.0f, 0.0f), Vector3(0.0f, 0.0f, 1.0f), 1, 1, 0.05f);
// GLUT functions
glutInit(&argc, argv);
glutInitWindowSize(windowWidth,windowHeight);
glutInitWindowPosition(100, 100);
glutCreateWindow("CS 180, Final Project");
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutIdleFunc(idle);
// load up Kim's skeleton stuff
string skeletonFilename("01.asf");
string motionFilename("01_02.amc");
skeleton = new Skeleton(skeletonFilename.c_str(), MOCAP_SCALE);
skeleton->setBasePosture();
displayer.LoadSkeleton(skeleton);
motion = new Motion(motionFilename.c_str(), MOCAP_SCALE, skeleton);
displayer.LoadMotion(motion);
skeleton->setPosture(*(displayer.GetSkeletonMotion(0)->GetPosture(0)));
// load up the next motion capture frame
SetSkeletonsToSpecifiedFrame(currentFrameIndex);
glutMainLoop();
return 0;
}
//////////////////////////////////////////////////////////////////////////////////
// Draws to the OpenGL window
//////////////////////////////////////////////////////////////////////////////////
void display()
{
// precompute all the bone positions of the skeleton
displayer.ComputeBonePositionsManual(DisplaySkeleton::BONES_AND_LOCAL_FRAMES);
// retrieve all the bones of the skeleton
vector<MATRIX4>& rotations = displayer.rotations();
Matrix3 rotation;
vector<MATRIX4>& scalings = displayer.scalings();
Matrix3 scaling;
vector<VEC4F>& translations = displayer.translations();
Vector3 translation;
vector<float>& lengths = displayer.lengths();
int totalBones = rotations.size();
objsPerBone = 2;
// if bones are uninitialized, run inits
int i, obj;
if(boneIndex<0)
{
boneIndex=numObjects;
for(i=1;i<totalBones;i++)
{
rotation = rotations[i];
scaling = scalings[i];
translation = translations[i];
if(i == 23 || i == 30){//draw boxing gloves
spheres[numSpheres] = new Sphere(translation, 0.075, Vector3(1, 0, 0), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
cylinders[numCylinders] = new Cylinder(translation, 0.0001, 0.0001, rotation,Vector3( 1,0,0),MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
}
else{
spheres[numSpheres] = new Sphere(translation, 0.025, Vector3(1, 0, 0), MAT_DIFFUSE);
objects[numObjects++] = spheres[numSpheres++];
cylinders[numCylinders] = new Cylinder(translation,0.025,lengths[i],rotation,Vector3( 1,0,0),MAT_DIFFUSE);
objects[numObjects++] = cylinders[numCylinders++];
}
}
// update bone positions
} else {
for(i=1;i<totalBones;i++)
{
rotation = rotations[i];
scaling = scalings[i];
translation = translations[i];
for(obj=0;obj<objsPerBone;obj++)
{
objects[boneIndex + (i-1)*objsPerBone + obj]->updateLocation(translation, rotation);
}
}
}
// move camera
eye = Vector3(0,5,-1);
focus = Vector3(0, 3, -1);
up = Vector3(0, 1, 0);
rotation = rotations[16]; scaling = scalings[16]; translation = translations[16];
eye = (rotation*scaling) * eye + (translation);
focus = (rotation*scaling) * focus + (translation);
focus[1]=eye[1];
//up = (rotation*scaling) * up + (translation);
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
int index;
int object;
Vector3 rayDir, color, p, n, tmp;
Matrix3 modelview = getModelviewMatrix();
float dist;
float r = nearx, l = -nearx;
float t = neary, b = -neary;
float u, v;
int x, y;
for(x=0; x<width; x++)
{
for(y=0; y<height; y++)
{
index = 3*width*y + 3*x;
// calculate ray direction
u = l + (r-l)*(x+0.5)/width;
v = b + (t-b)*(y+0.5)/height;
rayDir[0] = u; rayDir[1] = v; rayDir[2] = -nearz;
rayDir = modelview.transpose()*rayDir;
// find closest object intersect point
dist = findClosestIntersect(rayDir, eye, object);
// if intersect exists, determine pixel color from lighting
if(dist>=1)
{
// calculate coords of collision, normal vector
p = eye + rayDir * dist;
n = objects[object]->getNormal(p);
// coloring computations
color[0] = 0; color[1] = 0; color[2] = 0; // zero out pixel color
// if there is ambient light, it goes in this line
//FOR RENDERING WITHOUT EFFECTS:
//color = objects[object]->getColor(p);
// if the object is diffuse, calc shading for all lights
if(objects[object]->getMaterial()<=MAT_DIFFUSE)
{for(int i=0; i<numLights; i++) color += calcShading(p, eye, objects[object], lights[i]);}
// otherwise, reflect/refract!
else color += reflectRefract(p, rayDir, eye, objects[object], 0);
// prevent color components from going out of bounds
color[0] = (color[0]>1) ? 1 : color[0];
color[1] = (color[1]>1) ? 1 : color[1];
color[2] = (color[2]>1) ? 1 : color[2];
// place pixel colors in pixel buffer
pixels[index+0]=(int)(color[0]*255);
pixels[index+1]=(int)(color[1]*255);
pixels[index+2]=(int)(color[2]*255);
} else {pixels[index+0]=0; pixels[index+1]=0; pixels[index+2]=0;} // if no intersect, color black
}
}
// Render picture
glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels);
glutSwapBuffers();
writePPM();
}
