readfile.cpp

/*****************************************************************************/
/* This is the program skeleton for homework 2 in CSE167 by Ravi Ramamoorthi */
/* Extends HW 1 to deal with shading, more transforms and multiple objects   */
/*****************************************************************************/

/*****************************************************************************/
// This file is readfile.cpp.  It includes helper functions for matrix 
// transformations for a stack (matransform) and to rightmultiply the 
// top of a stack.  These functions are given to aid in setting up the 
// transformations properly, and to use glm functions in the right way.  
// Their use is optional in your program.  


// The functions readvals and readfile do basic parsing.  You can of course 
// rewrite the parser as you wish, but we think this basic form might be 
// useful to you.  It is a very simple parser.

// Please fill in parts that say YOUR CODE FOR HW 2 HERE. 
// Read the other parts to get a context of what is going on. 

/*****************************************************************************/
// Basic includes to get this file to work.  
#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <deque>
#include <stack>

#include "Transform.h" 

using namespace std;
#include "variables.h" 
#include "readfile.h"



// You may not need to use the following two functions, but it is provided
// here for convenience

// The function below applies the appropriate transform to a 4-vector
void matransform(stack<mat4> &transfstack, float* values) 
{
  mat4 transform = transfstack.top(); 
  vec4 valvec = vec4(values[0],values[1],values[2],values[3]); 
  vec4 newval = transform * valvec; 
  for (int i = 0; i < 4; i++) values[i] = newval[i]; 
}

void rightmultiply(const mat4 & M, stack<mat4> &transfstack) 
{
  mat4 &T = transfstack.top(); 
  T = T * M; 
}

// Function to read the input data values
// Use is optional, but should be very helpful in parsing.  
bool readvals(stringstream &s, const int numvals, float* values) 
{
  for (int i = 0; i < numvals; i++) {
    s >> values[i]; 
    if (s.fail()) {
      cout << "Failed reading value " << i << " will skip\n"; 
      return false;
    }
  }
  return true; 
}

void readfile(const char* filename) 
{
  string str, cmd; 
  ifstream in;
  in.open(filename); 
  if (in.is_open()) {
    fileName = (char *)malloc(sizeof(char)*100);

    // I need to implement a matrix stack to store transforms.  
    // This is done using standard STL Templates 
    stack <mat4> transfstack; 
    transfstack.push(mat4(1.0));  // identity

        nameSpecified = false;

        //default Values of attenuation
        attenuation[0] = 1;
        attenuation[1] = 0;
        attenuation[2] = 0;

        //default values of maxDepth
        maxDepth = 5;

    getline (in, str); 
    while (in) {
      if ((str.find_first_not_of(" \t\r\n") != string::npos) && (str[0] != '#')) {
        // Ruled out comment and blank lines 

        stringstream s(str);
        s >> cmd; 
        int i; 
        float values[10]; // Position and color for light, colors for others
        // Up to 10 params for cameras.  
        bool validinput; // Validity of input 

        // Process the light, add it to database.
        // Lighting Command


        // Material Commands 
        // Ambient, diffuse, specular, shininess properties for each object.
        // Filling this in is pretty straightforward, so I've left it in 
        // the skeleton, also as a hint of how to do the more complex ones.
        // Note that no transforms/stacks are applied to the colors. 

        if (cmd == "ambient") {
          validinput = readvals(s, 3, values); // colors 
          if (validinput) {
            for (i = 0; i < 3; i++) {
              ambient[i] = values[i]; 
            }
          }
        } else if (cmd == "diffuse") {
          validinput = readvals(s, 3, values); 
          if (validinput) {
            for (i = 0; i < 3; i++) {
              diffuse[i] = values[i]; 
            }
          }
        } else if (cmd == "specular") {
          validinput = readvals(s, 3, values); 
          if (validinput) {
            for (i = 0; i < 3; i++) {
              specular[i] = values[i]; 
            }
          }
        } else if (cmd == "emission") {
          validinput = readvals(s, 3, values); 
          if (validinput) {
            for (i = 0; i < 3; i++) {
              emission[i] = values[i]; 
            }
          }
        } else if (cmd == "shininess") {
          validinput = readvals(s, 1, values); 
          if (validinput) {
            shininess = values[0]; 
          }
        } else if (cmd == "attenuation") {
          validinput = readvals(s, 3, values); 
          if (validinput) {
            for (i = 0; i < 3; i++) {
              attenuation[i] = values[i]; 
            }
          }
        } else if (cmd == "size") {
          validinput = readvals(s,2,values); 
          if (validinput) { 
            w = (int) values[0]; h = (int) values[1]; 
          } 
        }
        else if (cmd == "directional")
        {
          validinput = readvals(s, 6, values);
          if (validinput)
          {
            vec3 light, color;
            for (int i = 0; i < 6; ++i)
            {
              if (i < 3)
              {
                light[i] = values[i];
              } else {
                color[i%3] = values[i];
              }
            }
            directionalLights[numDirectionalLights] = light;
            directionalColors[numDirectionalLights++] = color;
          }
        }
        else if (cmd == "point")
        {
          validinput = readvals(s, 6, values);
          if (validinput)
          {
            vec3 light, color;
            for (int i = 0; i < 6; ++i)
            {
              if (i < 3)
              {
                light[i] = values[i];
              } else {
                color[i%3] = values[i];
              }
            }
            pointLights[numPointLights] = light;
            pointColors[numPointLights++] = color;
          }
        }
        else if (cmd == "output")
        {
          nameSpecified = true;
          s >> fileName;
        }
        else if (cmd == "maxdepth"){
          validinput = readvals(s, 1, values);
          if(validinput){
            maxDepth = values[0];
          }
        }
        else if (cmd == "camera") {
          validinput = readvals(s,10,values); // 10 values eye cen up fov
          if (validinput) {

            // YOUR CODE FOR HW 2 HERE
            // Use all of values[0...9]
            // You may need to use the upvector fn in Transform.cpp
            // to set up correctly. 
            // Set eyeinit upinit center fovy in variables.h 
            eyeinit = vec3(values[0], values[1], values[2]);
            center = vec3(values[3], values[4], values[5]);
            vec3 axis = vec3(values[6], values[7], values[8]);
            upinit = Transform::upvector(axis, eyeinit-center);
            fovy = values[9] / 57.2958; // convert to radians
          }
        }

        // I've left the code for loading objects in the skeleton, so 
        // you can get a sense of how this works.  
        // Also look at demo.txt to get a sense of why things are done this way.
        else if (cmd == "sphere") {
          if (numobjects == maxobjects) { // No more objects 
            cerr << "Reached Maximum Number of Objects " << numobjects << " Will ignore further objects\n";
          } else {
            validinput = readvals(s, 4, values); 
            if (validinput) {
              object * obj = &(objects[numobjects]); 

              // Set the object's light properties
              for (i = 0; i < 4; i++) {
                (obj->ambient)[i] = ambient[i]; 
                (obj->diffuse)[i] = diffuse[i]; 
                (obj->specular)[i] = specular[i]; 
                (obj->emission)[i] = emission[i];
                if(i<3){
                  (obj->attenuation)[i] = attenuation[i];
                }
              }
              obj->shininess = shininess; 

              // Set the object's transform
              obj->transform = transfstack.top(); 

              obj->type = sphere; 

              vec4 sphere = vec4( values[0], values[1], values[2], 1);
              obj->radius = values[3];
                
              obj->shapeVertices.push_back( sphere );
              
            }
            ++numobjects; 
          }
        }        else if (cmd == "tri") {
          if (numobjects == maxobjects) { // No more objects 
            cerr << "Reached Maximum Number of Objects " << numobjects << " Will ignore further objects\n";
          } else {
            validinput = readvals(s, 3, values); 
            if (validinput) {
              object * obj = &(objects[numobjects]); 

              // Set the object's light properties
              for (i = 0; i < 4; i++) {
                (obj->ambient)[i] = ambient[i]; 
                (obj->diffuse)[i] = diffuse[i]; 
                (obj->specular)[i] = specular[i]; 
                (obj->emission)[i] = emission[i];
                if(i<3){
                  (obj->attenuation)[i] = attenuation[i];
                }
              }
              obj->shininess = shininess; 

              // Set the object's transform
              obj->transform = transfstack.top(); 

              obj->type = tri; 

              //save the corresponding vertices to this opject
              for (int i = 0; i < 3; ++i)
              {
                obj->shapeVertices.push_back( vertices[ values[i] ] );
              }
            }
            ++numobjects; 
          }
        }

        else if (cmd == "maxverts")
        { 
          validinput = readvals(s, 1, values); 
          if(validinput) maxverts = values[0];
        }

        else if (cmd == "vertex")
        {
          if (numVertices >= maxverts)
          {
            cerr << "Reached max num vertices " << numVertices << 
                    " will ignore further vertices\n";
          } 
          else {
            validinput = readvals(s, 3, values); 
            if (validinput)
            {
              vec4 * v = new vec4( values[0], values[1], values[2], 1);
              vertices.push_back(*v);
            }
            numVertices++;
          }
        }

        else if (cmd == "translate") {
          validinput = readvals(s,3,values); 
          if (validinput) {

            // YOUR CODE FOR HW 2 HERE.  
            // Think about how the transformation stack is affected
            // You might want to use helper functions on top of file. 
            // Also keep in mind what order your matrix is!
            mat4 tr = Transform::translate(values[0], values[1], values[2]);
            rightmultiply(tr, transfstack);
          }
        }
        else if (cmd == "scale") {
          validinput = readvals(s,3,values); 
          if (validinput) {

            // YOUR CODE FOR HW 2 HERE.  
            // Think about how the transformation stack is affected
            // You might want to use helper functions on top of file.  
            // Also keep in mind what order your matrix is!
          mat4 sc = Transform::scale(values[0], values[1], values[2]);
            rightmultiply(sc, transfstack);
          }
        }
        else if (cmd == "rotate") {
          validinput = readvals(s,4,values); 
          if (validinput) {

            // YOUR CODE FOR HW 2 HERE. 
            // values[0..2] are the axis, values[3] is the angle.  
            // You may want to normalize the axis (or in Transform::rotate)
            // See how the stack is affected, as above.  
            // Note that rotate returns a mat3. 
            // Also keep in mind what order your matrix is!
            vec3 axis = vec3(values[0], values[1], values[2]);
            axis = glm::normalize(axis);
            mat3 rot = Transform::rotate(-1 * values[3], axis);
            mat4 rot4 = mat4(rot);
            rightmultiply(rot4, transfstack);

            
          }
        }

        // I include the basic push/pop code for matrix stacks
        else if (cmd == "pushTransform") {
          transfstack.push(transfstack.top()); 
        } else if (cmd == "popTransform") {
          if (transfstack.size() <= 1) {
            cerr << "Stack has no elements.  Cannot Pop\n"; 
          } else {
            transfstack.pop(); 
          }
        }

        else {
          cerr << "Unknown Command: " << cmd << " Skipping \n"; 
        }
      }
      getline (in, str); 
    }

    // Set up initial position for eye, up and amount
    // As well as booleans 

    eye = eyeinit; 
    up = upinit; 
    amount = amountinit;
    sx = sy = 1.0;  // keyboard controlled scales in x and y 
    tx = ty = 0.0;  // keyboard controllled translation in x and y  

  } else {
    cerr << "Unable to Open Input Data File " << filename << "\n"; 
    throw 2; 
  }
}