SceneObject::Ptr obj, Material::Ptr mat ) {

SceneDagNode::Ptr node = std::make_shared<SceneDagNode>( obj, mat );

node->parent = parent;

node->next = nullptr;

node->child = nullptr;

// Add the object to the parent's child list, this means

// whatever transformation applied to the parent will also

// be applied to the child.

if (parent->child == nullptr) {

parent->child = node;

}

else {

parent = parent->child;

while (parent->next != nullptr) {

parent = parent->next;

}

parent->next = node;

}

return node;

LightListNode::Ptr tmp = _lightSource;

_lightSource = std::make_shared<LightListNode>( light, tmp );

return _lightSource;

Matrix4x4 rotation;

double toRadian = 2*M_PI/360.0;

int i;

for (i = 0; i < 2; i++) {

switch(axis) {

case 'x':

rotation[0][0] = 1;

rotation[1][1] = cos(angle*toRadian);

rotation[1][2] = -sin(angle*toRadian);

rotation[2][1] = sin(angle*toRadian);

rotation[2][2] = cos(angle*toRadian);

rotation[3][3] = 1;

break;

case 'y':

rotation[0][0] = cos(angle*toRadian);

rotation[0][2] = sin(angle*toRadian);

rotation[1][1] = 1;

rotation[2][0] = -sin(angle*toRadian);

rotation[2][2] = cos(angle*toRadian);

rotation[3][3] = 1;

break;

case 'z':

rotation[0][0] = cos(angle*toRadian);

rotation[0][1] = -sin(angle*toRadian);

rotation[1][0] = sin(angle*toRadian);

rotation[1][1] = cos(angle*toRadian);

rotation[2][2] = 1;

rotation[3][3] = 1;

break;

}

if (i == 0) {

node->trans = node->trans*rotation;

angle = -angle;

}

else {

node->invtrans = rotation*node->invtrans;

}

}

Matrix4x4 translation;

translation[0][3] = trans[0];

translation[1][3] = trans[1];

translation[2][3] = trans[2];

node->trans = node->trans*translation;

translation[0][3] = -trans[0];

translation[1][3] = -trans[1];

translation[2][3] = -trans[2];

node->invtrans = translation*node->invtrans;

Matrix4x4 scale;

scale[0][0] = factor[0];

scale[0][3] = origin[0] - factor[0] * origin[0];

scale[1][1] = factor[1];

scale[1][3] = origin[1] - factor[1] * origin[1];

scale[2][2] = factor[2];

scale[2][3] = origin[2] - factor[2] * origin[2];

node->trans = node->trans*scale;

scale[0][0] = 1/factor[0];

scale[0][3] = origin[0] - 1/factor[0] * origin[0];

scale[1][1] = 1/factor[1];

scale[1][3] = origin[1] - 1/factor[1] * origin[1];

scale[2][2] = 1/factor[2];

scale[2][3] = origin[2] - 1/factor[2] * origin[2];

node->invtrans = scale*node->invtrans;

Vector3D up ) {

Matrix4x4 mat;

Vector3D w;

view.normalize();

up = up - up.dot(view)*view;

up.normalize();

w = view.cross(up);

mat[0][0] = w[0];

mat[1][0] = w[1];

mat[2][0] = w[2];

mat[0][1] = up[0];

mat[1][1] = up[1];

mat[2][1] = up[2];

mat[0][2] = -view[0];

mat[1][2] = -view[1];

mat[2][2] = -view[2];

mat[0][3] = eye[0];

mat[1][3] = eye[1];

mat[2][3] = eye[2];

return mat;

{

SceneDagNode::Ptr childPtr;

if (node->parent != nullptr)

{

node->modelToWorld = node->parent->modelToWorld*node->trans;

node->worldToModel = node->invtrans*node->parent->worldToModel;

}

else

{

node->modelToWorld = node->trans;

node->worldToModel = node->invtrans;

}

// Traverse the children.

childPtr = node->child;

while (childPtr != NULL) {

computeTransforms(childPtr);

childPtr = childPtr->next;

}

SceneDagNode::Ptr childPtr;

// Applies transformation of the current node to the global

// transformation matrices.

if (node->obj) {

// Perform intersection.

if (node->obj->intersect(ray, node->worldToModel, node->modelToWorld)) {

ray.intersection.mat = node->mat;

}

}

// Traverse the children.

childPtr = node->child;

while (childPtr != nullptr) {

traverseScene(childPtr, ray);

childPtr = childPtr->next;

}

LightListNode::Ptr curLight = _lightSource;

for (;;) {

if (curLight == nullptr) break;

// Each lightSource provides its own shading function.

// Implement shadows here if needed.

curLight->light->shade(ray);

curLight = curLight->next;

}

int numbytes = _scrWidth * _scrHeight * sizeof(unsigned char);

_rbuffer = new unsigned char[numbytes];

std::fill_n(_rbuffer, numbytes,0);

_gbuffer = new unsigned char[numbytes];

std::fill_n(_gbuffer, numbytes,0);

_bbuffer = new unsigned char[numbytes];

std::fill_n(_bbuffer, numbytes,0);

bmp_write( file_name.c_str(), _scrWidth, _scrHeight, _rbuffer, _gbuffer, _bbuffer );

delete _rbuffer;

delete _gbuffer;

delete _bbuffer;

Colour col(0.0, 0.0, 0.0);

traverseScene(_root, ray);

// Don't bother shading if the ray didn't hit

// anything.

if (!ray.intersection.none) {

computeShading(ray);

col = ray.col;

}

// You'll want to call shadeRay recursively (with a different ray,

// of course) here to implement reflection/refraction effects.

return col;

Vector3D up, double fov, std::string fileName ) {

computeTransforms(_root);

Matrix4x4 viewToWorld;

_scrWidth = width;

_scrHeight = height;

double factor = (double(height)/2)/tan(fov*M_PI/360.0);

initPixelBuffer();

viewToWorld = initInvViewMatrix(eye, view, up);

// Construct a ray for each pixel.

for (int i = 0; i < _scrHeight; i++) {

for (int j = 0; j < _scrWidth; j++) {

// Sets up ray origin and direction in view space,

// image plane is at z = -1.

Point3D origin(0., 0., 0.);

Point3D imagePlane;

imagePlane[0] = (-double(width)/2 + 0.5 + j)/factor;

imagePlane[1] = (-double(height)/2 + 0.5 + i)/factor;

imagePlane[2] = -1;

// TODO: Convert ray to world space and call

// shadeRay(ray) to generate pixel colour.

// ray -> world space

Point3D rayOriginWorld = viewToWorld * imagePlane;

Vector3D rayDir = imagePlane - origin;

Vector3D rayDirWorld = viewToWorld * rayDir;

Ray3D ray;

ray.origin = rayOriginWorld;

ray.dir = rayDirWorld;

ray.dir.normalize();

// pixel colour

Colour col = shadeRay(ray);

_rbuffer[i*width+j] = int(col[0]*255);

_gbuffer[i*width+j] = int(col[1]*255);

_bbuffer[i*width+j] = int(col[2]*255);

}

}

flushPixelBuffer(fileName);