///Displays
void display(){
///--- Clears the color buffer so that we don't display garbage
glViewport(0,0,windowDimension,windowDimension);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///--- Upload viewing matrices externally
GLuint pid = quad.getProgramID();
glUseProgram(pid);
mat4 MODEL = mat4::Identity();
glUniformMatrix4fv(glGetUniformLocation(pid, "MODEL"), 1, GL_FALSE, MODEL.data());
float theta_rad = M_PI/180.0*theta;
//vec3 camera_pos( camX, camY, 2*sin(theta_rad));
camX = camX + rateX;
camY = camY + rateY;
camZ = camZ + rateZ;
vec3 camera_pos(camX,camY,camZ);
mat4 VIEW = Eigen::lookAt( camera_pos, vec3(lookX,lookY,lookZ), vec3(0,0,1) ); //< "z" up on screen
glUniformMatrix4fv(glGetUniformLocation(pid, "VIEW"), 1, GL_FALSE, VIEW.data());
mat4 PROJ = Eigen::perspective(75.0f, windowDimension/(float)windowDimension, 0.1f, 10.0f);
glUniformMatrix4fv(glGetUniformLocation(pid, "PROJ"), 1, GL_FALSE, PROJ.data());
glUseProgram(pid);
///--- calls the quad.draw() method which displays the terrain quad (?takes in the ModelViewProjection matrices?)
quad.draw();
}
Scene *readHeights(char* fn) {
int width, height;
unsigned char *height_map;
height_map = readBMP(fn, width, height);
if (!height_map)
{
fl_alert("Error loading height map\n");
return false;
}
Scene * ret = new Scene();
//TODO: customize mat
Material * mat = new Material();
mat->kd = vec3f(1.0, 1.0, 1.0);
//extract the points
Trimesh * trimesh = new Trimesh(ret, mat, &ret->transformRoot);
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
int pos = y * width + x;
unsigned char pixel[3];
memcpy(pixel, height_map + pos * 3, 3);
double height = double(pixel[0] + pixel[1] + pixel[2]) / 3 / 128;
vec3f point(x, y, height);
trimesh->addVertex(point);
if (x > 0 && y > 0) { //link the points
trimesh->addFace(pos, pos - 1, pos - 1 - width);
trimesh->addFace(pos, pos - 1 - width, pos - width);
}
}
}
char *error;
if (error = trimesh->doubleCheck())
throw ParseError(error);
//add a trimesh
ret->add(trimesh);
//add a pointlight
PointLight* point_light = new PointLight(ret, vec3f(width, height, 10), vec3f(1.0, 1.0, 1.0));
ret->add(point_light);
//set the camerea
//TODO: calculate the correct viewing distance;
vec3f map_center((double)width / 2 - 0.5, (double)height / 2 - 0.5, 0.5);
double camera_distance = (double)width + 3.0;
vec3f camera_pos(0, -camera_distance, 2 * camera_distance);
camera_pos += map_center;
ret->getCamera()->setEye(camera_pos);
ret->getCamera()->setLook((map_center - camera_pos).normalize(), vec3f(0, 0, 1).normalize());
return ret;
}
void RenderSystem::PreRender(void)
{
// prepare renderer,
m_spRenderer->PreRender();
m_spRenderer->m_spShaderProgram->Enable();
// view: camera position.
glm::vec3 camera_pos(m_Scene.GetCamera().GetPositionVec3());
m_spRenderer->m_spShaderProgram->SetParameter<glm::vec3>("CameraPosition", camera_pos);
// TODO TEMP HERE UNTIL SUMMER BREAK REFACTOR.
m_LightManager.SetupLights(m_spRenderer->m_spShaderProgram);
}
void display(){
opengp::update_title_fps("Intro. to Computer Graphics");
glViewport(0,0,window_width,window_height);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
///--- Upload viewing matrices externally
GLuint pid = mesh.getProgramID();
glUseProgram(pid);
mat4 MODEL = mat4::Identity();
glUniformMatrix4fv(glGetUniformLocation(pid, "MODEL"), 1, GL_FALSE, MODEL.data());
float theta_rad = M_PI/180.0*theta;
vec3 camera_pos( 0, -2*cos(theta_rad), 2*sin(theta_rad));
mat4 VIEW = Eigen::lookAt( camera_pos, vec3(0,0,0), vec3(0,0,1) ); //< "z" up on screen
glUniformMatrix4fv(glGetUniformLocation(pid, "VIEW"), 1, GL_FALSE, VIEW.data());
mat4 PROJ = Eigen::perspective(75.0f, window_width/(float)window_height, 0.1f, 10.0f);
glUniformMatrix4fv(glGetUniformLocation(pid, "PROJ"), 1, GL_FALSE, PROJ.data());
glUseProgram(pid);
mesh.draw();
}
void seal_start_game() {
gettimeofday(&_lastUpdate, NULL);
lua_State *L = GAME->lstate;
assert(lua_gettop(L) == 0);
lua_pushcfunction(L, traceback);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_INIT);
seal_call(L, 0, 1);
struct sprite* root = lua_touserdata(L, -1);
GAME->root = root;
lua_pop(L, 1);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_UPDATE);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_DRAW);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_PAUSE);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_RESUME);
lua_getfield(L, LUA_REGISTRYINDEX, GAME_EVENT);
camera_pos(GAME->global_camera,
GAME->config.window_width/2,
GAME->config.window_height/2);
}
/// render
void view::render() {
// Clear Screen And Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
if (!m_world) {
return;
}
if(ortho_sh)
{
glClearColor(0,0,0,1);
modifiedmesh_drawable->set_render_faces(true);
modifiedmesh_drawable->set_render_edges(false);
modifiedmesh_drawable->set_render_normals(false);
modifiedmesh_drawable->set_render_vertices(false);
modifiedmesh_drawable->render();
glFlush();
int size = w()*h()*3;
unsigned char *data = new unsigned char[size];
glReadPixels(0,0, w(), h(),GL_RGB,GL_UNSIGNED_BYTE,data);
ilInit();
iluInit();
ilutInit();
ILuint ImageName;
ilGenImages(1, &ImageName);
ilBindImage(ImageName);
ilTexImage(w(),h(),1,3,IL_RGB,IL_UNSIGNED_BYTE,data);
//iluFlipImage();
ilEnable(IL_FILE_OVERWRITE);
#ifdef _WIN32
// Did not compile in linux:
ilSaveImage(reinterpret_cast<const wchar_t *>(filename_screenshot.c_str()));
#else
ilSaveImage(filename_screenshot.c_str());
#endif
delete[] data;
glClearColor(0.80f, 0.80f, 0.90f, 1.0f);
}
else
{
// Reset Modelview:
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// Set modelviewmatrix
m = translate_44(0.0f, 0.0f, -cam_distance)
* rotate_x_44(cam_polar)
* rotate_y_44(cam_azimut)
* translate_44(-cam_target.x(), -cam_target.y(), -cam_target.z() );
// Transpose (here: invert) matrix:
Mat44f mat_trans = transpose(m);
point3f camera_pos(0.0, 0.0, 0.0);
camera_pos = invert(m) * camera_pos;
glLoadMatrixf( &mat_trans(0,0) );
// Create light components
GLfloat ambientLight[] = { 0.0f, 0.0f, 0.0f, 1.0f };
GLfloat diffuseLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat specularLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat position[] = { 1.0f, 1.0f, 1.0f, 0.0f };
GLfloat globalAmbient[] = { 0.2f, 0.2f, 0.2f, 1.0f};
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalAmbient);
// Assign created components to GL_LIGHT1
glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
glLightfv(GL_LIGHT0, GL_POSITION, position);
Rendering::RenderingInfo info( camera_pos, m_noise_tex );
/* render the world */
m_world->render( info );
renderCoordinateSystem();
//render_noise_texture();
}
}
void RenderFrameDX10(void)
{
Vector4 vClearColor(0.4f, 0.4f, 0.4f, 1.0f);
// frame buffer
ID3D10RenderTargetView *pRenderTargetView = GutGetDX10RenderTargetView();
// depth/stencil buffer
ID3D10DepthStencilView *pDepthStencilView = GutGetDX10DepthStencilView();
// front/back buffer
IDXGISwapChain *pSwapChain = GutGetDX10SwapChain();
// `清除顏色`
g_pDevice->ClearRenderTargetView(pRenderTargetView, (float *)&vClearColor);
// `清除`Depth/Stencil buffer
g_pDevice->ClearDepthStencilView(pDepthStencilView, D3D10_CLEAR_DEPTH | D3D10_CLEAR_STENCIL, 1.0f, 0);
Vector4 camera_lookat(0.0f, 0.0f, 0.0f);
int w, h;
GutGetWindowSize(w, h);
Matrix4x4 view_matrix;
Matrix4x4 ortho_proj = GutMatrixOrthoRH_DirectX(20.0f, 20.0f, 0.1f, 100.0f);
// `前視圖`
{
D3D10_VIEWPORT vp = {0, 0, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(0.0f, -20.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `上視圖`
{
D3D10_VIEWPORT vp = {w/2, 0, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(0.0f, 0.0f, 20.0f);
Vector4 camera_up(0.0f, 1.0f, 0.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `右視圖`
{
D3D10_VIEWPORT vp = {0, h/2, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Vector4 camera_pos(20.0f, 0.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// render objects
RenderSolarSystemDX10(view_matrix, ortho_proj);
}
// `使用者視角`
{
D3D10_VIEWPORT vp = {w/2, h/2, w/2, h/2, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// view matrix
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
view_matrix = object_matrix * view_matrix;
// render objects
RenderSolarSystemDX10(view_matrix, g_proj_matrix);
}
// `畫邊線`
{
UINT stride = sizeof(Vertex_VC);
UINT offset = 0;
D3D10_VIEWPORT vp = {0, 0, w, h, 0.0f, 1.0f};
g_pDevice->RSSetViewports(1, &vp);
// `設定`vertex shader
g_pDevice->VSSetShader(g_pVertexShader);
// `設定`pixel shader
g_pDevice->PSSetShader(g_pPixelShader);
// `設定vertex shader讀取參數的記憶體位置`
g_pDevice->VSSetConstantBuffers(0, 1, &g_pConstantBuffer);
Matrix4x4 *pConstData;
g_pConstantBuffer->Map( D3D10_MAP_WRITE_DISCARD, NULL, (void **) &pConstData );
pConstData->Identity();
g_pConstantBuffer->Unmap();
g_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_LINELIST);
g_pDevice->IASetVertexBuffers(0, 1, &g_pBorderVertexBuffer, &stride, &offset);
g_pDevice->Draw(4, 0);
}
// `等待硬體掃結束, 然後才更新畫面.`
pSwapChain->Present(1, 0);
}
//-----------------------------------------------------------------------------
void MyGlDraw(void)
{
clearScreen();
//*************************************************************************
// Chame aqui as funções do mygl.h
//*************************************************************************
objData = new objLoader(); // cria o objeto que carrega o modelo
objData->load("models/monkey_head2.obj"); // a carga do modelo é indicada atraves do nome do arquivo.
// Neste caso, deve ser sempre do tipo OBJ.
/**************creating the list of all vertexs**********************/
std::vector<glm::vec4> vertex_list;
std::vector<Vertex> my_list;
obj_vector* vector;
obj_face* faces;
//std::cout<<"object vertex list"<<std::endl;
for (int i = 0; i < objData->vertexCount; ++i)
{
vector = objData->vertexList[i];
glm::vec4 aux(vector->e[0], vector->e[1], vector->e[2], 1.0);
//PrintVec4(aux);
vertex_list.push_back(aux);
}
/******OBJECT SPACE TO UNIVERSE SPACE******/
glm::mat4 Scale = glm::mat4(2.0);
Scale[3].w = 1.0;
glm::mat4 Trans = glm::mat4(1.0);
glm::vec4 v(1.0,1.0, 1.0, 1.0);
Trans[3] = v;
glm::mat4 Rotate = glm::mat4(1.0);
Rotate[0].x = cos(angle +=1 * PI/180.0);
Rotate[2].x = sin(angle +=1 * PI/180.0);
Rotate[0].z = - sin(angle +=1 * PI/180.0);
Rotate[2].z = cos(angle +=1 * PI/180.0);
Rotate[3].w = 1.0;
glm::mat4 M_Model = Rotate * Scale;
/******OBJECT SPACE TO UNIVERSE SPACE******/
/******UNIVERSE SPACE TO CAMERA SPACE******/
glm::vec3 camera_pos(0.0,0.0,5.0);
glm::vec3 look_at(0.0,0.0,0.0);
glm::vec3 camera_up(0.0,1.0,0.0);
glm::vec3 camera_dir = look_at - camera_pos;
glm::vec3 z_camera = -normalize(camera_dir);
glm::vec3 x_camera = normalize(cross(camera_up, z_camera));
glm::vec3 y_camera = normalize(cross(z_camera, x_camera));
glm::vec4 homog(0.0,0.0,0.0,1.0);
glm::mat4 B = glm::mat4(1.0);
B[0]= glm::vec4 (x_camera,0.0);
B[1]= glm::vec4 (y_camera,0.0);
B[2]= glm::vec4 (z_camera,0.0);
B[3]=homog;
glm::mat4 trans = glm::mat4(1.0);
trans[3] = glm::vec4 (-camera_pos, 1.0);
glm::mat4 M_View = transpose(B) * trans;
glm::mat4 Model_View = M_View * M_Model;
/******UNIVERSE SPACE TO CAMERA SPACE******/
/******CAMERA SPACE TO PROJECTION SPACE (CLIPPING)******/
double d=1.0;
glm::mat4 M_Projection = glm::mat4(1.0);
M_Projection[2] = glm::vec4(0.0, 0.0, 1.0, -1.0/d);
M_Projection[3] = glm::vec4(0.0, 0.0, d, 0.0);
glm::mat4 M_ModelViewProjection = M_Projection * Model_View;
/******CAMERA SPACE TO PROJECTION SPACE (CLIPPING)******/
/******PROJECTION SPACE (CLIPPING) TO CANONICAL SPACE******/
//std::cout<<"PRINTING"<<std::endl;
for (int i = 0; i < objData->vertexCount; ++i)
{
vertex_list[i]=M_ModelViewProjection*vertex_list[i];
vertex_list[i].x=vertex_list[i].x/vertex_list[i].w;
vertex_list[i].y=vertex_list[i].y/vertex_list[i].w;
vertex_list[i].z=vertex_list[i].z/vertex_list[i].w;
vertex_list[i].w=vertex_list[i].w/vertex_list[i].w;
}
/******PROJECTION SPACE (CLIPPING) TO CANONICAL SPACE******/
/******CANONICAL SPACE TO SCREEN SPACE******/
glm::mat4 Translation_Screen = glm::mat4(1.0);
Translation_Screen[3] = glm::vec4((IMAGE_WIDTH -1)/2, (IMAGE_HEIGHT -1)/2, 0.0, 1.0);
glm::mat4 Scale_Screen = glm::mat4(1.0);
Scale_Screen[0].x = IMAGE_WIDTH/2;
Scale_Screen[1].y = IMAGE_HEIGHT/2;
glm::mat4 InvertY_Screen = glm::mat4(1.0);
InvertY_Screen[1].y = -1.0;
glm::mat4 Final_Matrix = glm::mat4(1.0);
//Final_Matrix = InvertY_Screen * Scale_Screen * Translation_Screen;
Final_Matrix = Translation_Screen * Scale_Screen * InvertY_Screen;
//PrintMatrix(Final_Matrix);
for (int i = 0; i < objData->vertexCount; ++i)
{
vertex_list[i] = Final_Matrix * vertex_list[i];
//PrintVec4(vertex_list[i]);
}
/******CANONICAL SPACE TO SCREEN SPACE******/
//std::cout<<"object vertex list"<<std::endl;
for (int i = 0; i < objData->vertexCount; ++i)
{
Vertex tmp;
tmp.setX(round(vertex_list[i].x));
tmp.setY(round(vertex_list[i].y));
tmp.setZ(round(vertex_list[i].z));
tmp.setW(round(vertex_list[i].w));
my_list.push_back(tmp);
}
for (int i = 0; i < objData->faceCount; ++i)
{
faces = objData->faceList[i];
my_list[faces->vertex_index[0]].DrawTriangle(my_list[faces->vertex_index[1]], my_list[faces->vertex_index[2]]);
}
}
// 使用OpenGL來繪圖
void RenderFrameOpenGL(void)
{
// `取得視窗大小`
int w, h;
GutGetWindowSize(w, h);
// `清除畫面`
glClearColor(0.4f, 0.4f, 0.4f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Vector4 camera_lookat(0.0f, 0.0f, 0.0f);
Matrix4x4 ortho_proj = GutMatrixOrthoRH_OpenGL(20.0f, 20.0f, 0.1f, 100.0f);
{
// `前視圖`
glViewport(0, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, -20.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `上視圖`
glViewport(w/2, h/2, w/2, h/2);
// view matrix
Vector4 camera_pos(0.0f, 0.0f, 20.0f);
Vector4 camera_up(0.0f, 1.0f, 0.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `右視圖`
glViewport(0, 0, w/2, h/2);
// view matrix
Vector4 camera_pos(20.0f, 0.0f, 0.0f);
Vector4 camera_up(0.0f, 0.0f, 1.0f);
g_view_matrix = GutMatrixLookAtRH(camera_pos, camera_lookat, camera_up);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&ortho_proj[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `使用者視角`
glViewport(w/2, 0, w/2, h/2);
// object * view matrix
Matrix4x4 object_matrix = g_Control.GetObjectMatrix();
Matrix4x4 view_matrix = g_Control.GetViewMatrix();
g_view_matrix = object_matrix * view_matrix;
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(&g_projection_matrix[0][0]);
// render objects
RenderSolarSystemOpenGL();
}
{
// `畫出viewport的邊界`
glViewport(0, 0, w, h);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
// projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// worldview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// `畫邊界`
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex_VC), g_Border);
glDrawArrays(GL_LINES, 0, 4);
glPopClientAttrib();
}
// `把背景backbuffer的畫面呈現出來`
GutSwapBuffersOpenGL();
}
void wmonkey_scene_2()
{
printf("WOODEN MONKEY SCENE : 2 (path tracing) ----------------------------------\n\n");
Raytracer rt;
int width = 16 * 20 * 2;
int height = 12 * 20 * 2;
// room dimensions
double wDiameter = 20;
double wRadius = wDiameter / 2;
double wallSize[] = {wDiameter + DBL_EPSILON, wDiameter + DBL_EPSILON, wDiameter + DBL_EPSILON};
// Camera parameters.
Point3D camera_pos(0, 0, 1);
Vector3D camera_target(0, 0, -1);
Vector3D up(0, 1, 0);
double fov = 65;
double l0c = .9;
PointLight * light0 = new PointLight(
// Point3D(-wDiameter - roomRad + (roomRad / 2), 50 * 2, 50 * 2),
Point3D(0, wRadius - 5, 0),
Colour(l0c, l0c, l0c),
0.2);
rt.addLightSource(light0);
// http://en.wikipedia.org/wiki/Cornell_Box
// http://www.kevinbeason.com/smallpt/#moreinfo
Material matLight(
Colour(1, 1, 1) // ambient
, Colour(1, 1, 1) // diffuse
, Colour(1, 1, 1) // spec
, 0, 0, 0, 0
);
Material matMirror(
Colour(0.3, 0.3, 0.3) // ambient
, Colour(0.1, 0.1, 0.1) // diffuse
, Colour(0.628281, 0.555802, 0.366065) // spec
, 51.2, 1.0
);
Material matGlass(
Colour(0, 0, 0) // ambient
, Colour(0.1, 0.1, 0.1) // diffuse
, Colour(1.0, 1.0, 1.0) // spec
, 100, 0.0, 1.01, 0.9
);
Material matBeige(
Colour(0.607843, 0.549019, 0.372549) // ambient
, Colour(0.741176, 0.686274, 0.525490) // diffuse
, Colour(0.933333, 0.901960, 0.807843) // spec
, 12.8
);
Material matReddishWall(
Colour(.25, .25, .25) // ambient
, Colour(.75, .25, .25) // diffuse
, Colour(.3, .3, .3) // spec
, 2, 0, 0, 0
);
Material matBluishWall(
Colour(.25, .25, .25) // ambient
, Colour(.25, .25, .75) // diffuse
, Colour(.3, .3, .3) // spec
, 2, 0, 0, 0
);
Material matGreenishWall(
Colour(.25, .25, .25) // ambient
, Colour(.25, .75, .25) // diffuse
, Colour(.3, .3, .3) // spec
, 2, 0, 0, 0
);
Material matBaseWall(
Colour(.25, .25, .25) // ambient
, Colour(.25, .25, .25) // diffuse
, Colour(.6, .6, .6) // spec
, 2, 0, 0, 0
);
// create and position the box
SceneDagNode* wallLeft = rt.addObject( new UnitSquare(), &matReddishWall );
SceneDagNode* wallRight = rt.addObject( new UnitSquare(), &matBluishWall );
SceneDagNode* wallFront = rt.addObject( new UnitSquare(), &matBaseWall );
SceneDagNode* wallTop = rt.addObject( new UnitSquare(), &matLight );
SceneDagNode* wallBot = rt.addObject( new UnitSquare(), &matGreenishWall );
rt.translate(wallFront, Vector3D(0, 0, -wDiameter - wRadius + DBL_EPSILON));
rt.scale(wallFront, Point3D(0, 0, 0), wallSize);
rt.translate(wallRight, Vector3D(wRadius, 0, -wDiameter + DBL_EPSILON));
rt.rotate(wallRight, 'y', -90);
rt.scale(wallRight, Point3D(0, 0, 0), wallSize);
rt.translate(wallLeft, Vector3D(-wRadius, 0, -wDiameter + DBL_EPSILON));
rt.rotate(wallLeft, 'y', 90);
rt.scale(wallLeft, Point3D(0, 0, 0), wallSize);
rt.translate(wallTop, Vector3D(0, wRadius, -wDiameter + DBL_EPSILON));
rt.rotate(wallTop, 'x', 90);
rt.scale(wallTop, Point3D(0, 0, 0), wallSize);
rt.translate(wallBot, Vector3D(0, -wRadius, -wDiameter + DBL_EPSILON));
rt.rotate(wallBot, 'x', -90);
rt.scale(wallBot, Point3D(0, 0, 0), wallSize);
// create some objects within the box...
SceneDagNode* sphere_chrome = rt.addObject( new UnitSphere(), &matGlass );
double _sChrome_size = 2;
double _sChrome[] = {_sChrome_size, _sChrome_size, _sChrome_size};
rt.translate(sphere_chrome,
Vector3D(wRadius / 3 * 2,
-wRadius + (_sChrome_size),
-wDiameter + (wRadius / 3)));
rt.scale(sphere_chrome, Point3D(0, 0, 0), _sChrome);
SceneDagNode* sphere_glass = rt.addObject( new UnitSphere(), &matMirror );
double _sGlass_size = 2.5;
double _sGlass[] = {_sGlass_size, _sGlass_size, _sGlass_size};
rt.translate(sphere_glass,
Vector3D(-wRadius / 3 * 2,
-wRadius + (_sGlass_size),
-wDiameter - (wRadius / 3)));
rt.scale(sphere_glass, Point3D(0, 0, 0), _sGlass);
SceneDagNode* sphere_beige = rt.addObject( new UnitSphere(), &matBeige );
double _sBeige_size = 3.5;
double _sBeige[] = {_sBeige_size, _sBeige_size, _sBeige_size};
rt.translate(sphere_beige,
Vector3D(wRadius / 3 * 2,
-wRadius + (_sGlass_size * 2),
-wDiameter - (wRadius / 3)));
rt.scale(sphere_beige, Point3D(0, 0, 0), _sBeige);
rt.setAAMode(Raytracer::AA_SUPER_SAMPLING);
rt.setAAMode(Raytracer::NONE);
rt.setShadingMode(Raytracer::SCENE_MODE_DIFFUSE);
rt.setShadows(Raytracer::SHADOW_CAST);
rt.setEnvMapMode(Raytracer::ENV_MAP_CUBE_SKYBOX);
// rt.setColorSpaceMode(Raytracer::COLOR_ENC_SRGB_GAMMA_CORRECT);
rt.setReflDepth(4);
// refraction if it's turned on
if (REFRACTION_FLAG) {
rt.setRefractionMode(REFRACTION_FLAG);
}
if ( rt.getEnvMapMode() != Raytracer::NONE ) {
// load images
EnvMap env;
if ( _DEBUG ) {
env = EnvMap(
"EnvMaps/DebugMaps/posx.bmp",
"EnvMaps/DebugMaps/posy.bmp",
"EnvMaps/DebugMaps/posz.bmp",
"EnvMaps/DebugMaps/negx.bmp",
"EnvMaps/DebugMaps/negy.bmp",
"EnvMaps/DebugMaps/negz.bmp"
);
} else {
env = EnvMap(
"EnvMaps/SaintLazarusChurch/posx.bmp",
"EnvMaps/SaintLazarusChurch/posy.bmp",
"EnvMaps/SaintLazarusChurch/posz.bmp",
"EnvMaps/SaintLazarusChurch/negx.bmp",
"EnvMaps/SaintLazarusChurch/negy.bmp",
"EnvMaps/SaintLazarusChurch/negz.bmp"
);
}
rt.setEnvMap(env);
}
printf("WOODEN MONKEY SCENE : 2 :: Rendering...\n");
rt.render(width, height, camera_pos, camera_target, up, fov, "wmonkey_2.bmp");
printf("WOODEN MONKEY SCENE : 2 :: Done!\n");
}
