Esempio n. 1
0
Material* SceneParser::parsePhongMaterial() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	Vec3f diffuseColor(1, 1, 1);
	Vec3f specularColor(0, 0, 0);
	float exponent = 1;
	getToken(token); assert(!strcmp(token, "{"));
	while (1) {
		getToken(token);
		if (!strcmp(token, "diffuseColor")) {
			diffuseColor = readVec3f();
		}
		else if (!strcmp(token, "specularColor")) {
			specularColor = readVec3f();
		}
		else if (!strcmp(token, "exponent")) {
			exponent = readFloat();
		}
		else {
			assert(!strcmp(token, "}"));
			break;
		}
	}
	Material *answer = new PhongMaterial(diffuseColor, specularColor, exponent);
	return answer;
}
Esempio n. 2
0
void SceneParser::parseLights() {
  char token[MAX_PARSER_TOKEN_LENGTH];
  getToken(token); assert (!strcmp(token, "{"));

  // read in the number of objects
  getToken(token); assert (!strcmp(token, "numLights"));
  num_lights = readInt();
  //lights = new (Light*)[num_lights];
  lights = new Light*[num_lights];

  // read in the objects
  int count = 0;
  while (num_lights > count) {
    getToken(token); 
    if (!strcmp(token, "DirectionalLight")) {
      getToken(token); assert (!strcmp(token, "{"));
      getToken(token); assert (!strcmp(token, "direction"));
      Vec3f direction = readVec3f();
      getToken(token); assert (!strcmp(token, "color"));
      Vec3f color = readVec3f();
      getToken(token); assert (!strcmp(token, "}"));

      // ++++++++++++++++++++++++++++++++++++++++++++++++++++
      // CALLING ASSIGNMENT 2 CODE
      lights[count] = new DirectionalLight(direction,color);
      // ++++++++++++++++++++++++++++++++++++++++++++++++++++

      count++;
    } else {
      printf ("Unknown token in parseGroup: '%s'\n", token);
      exit(0);
    }   
  }
  getToken(token); assert (!strcmp(token, "}"));
}
Esempio n. 3
0
/* Parses the "Background" token */
void scene::parseBackground()
{
    char token[MAX_PARSER_TOKEN_LENGTH];

    getToken(token);
    assert (!strcmp(token, "{"));
    while (1)
    {
        getToken(token);
        if (!strcmp(token, "}"))
        {
            break;
        }
        else if (!strcmp(token, "color"))
        {
            bgColor = readVec3f();
        }
        else if (!strcmp(token, "ambientLight"))
        {
            ambLight = readVec3f();
        }
        else
        {
            cout<< "Unknown token in parseBackground: "<<token<<"\n";
            assert(0);
        }
    }
}
Esempio n. 4
0
Transform* SceneParser::parseTransform() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	Matrix matrix; matrix.SetToIdentity();
	Object3D *object = NULL;
	getToken(token); assert(!strcmp(token, "{"));
	// read in transformations: 
	// apply to the LEFT side of the current matrix (so the first
	// transform in the list is the last applied to the object)
	getToken(token);
	while (1) {
		if (!strcmp(token, "Scale")) {
			matrix *= Matrix::MakeScale(readVec3f());
		}
		else if (!strcmp(token, "UniformScale")) {
			float s = readFloat();
			matrix *= Matrix::MakeScale(Vec3f(s, s, s));
		}
		else if (!strcmp(token, "Translate")) {
			matrix *= Matrix::MakeTranslation(readVec3f());
		}
		else if (!strcmp(token, "XRotate")) {
			matrix *= Matrix::MakeXRotation(DegreesToRadians(readFloat()));
		}
		else if (!strcmp(token, "YRotate")) {
			matrix *= Matrix::MakeYRotation(DegreesToRadians(readFloat()));
		}
		else if (!strcmp(token, "ZRotate")) {
			matrix *= Matrix::MakeZRotation(DegreesToRadians(readFloat()));
		}
		else if (!strcmp(token, "Rotate")) {
			getToken(token); assert(!strcmp(token, "{"));
			Vec3f axis = readVec3f();
			float degrees = readFloat();
			matrix *= Matrix::MakeAxisRotation(axis, DegreesToRadians(degrees));
			getToken(token); assert(!strcmp(token, "}"));
		}
		else if (!strcmp(token, "Matrix")) {
			Matrix matrix2; matrix2.SetToIdentity();
			getToken(token); assert(!strcmp(token, "{"));
			for (int j = 0; j < 4; j++) {
				for (int i = 0; i < 4; i++) {
					float v = readFloat();
					matrix2.Set(i, j, v);
				}
			}
			getToken(token); assert(!strcmp(token, "}"));
			matrix = matrix2 * matrix;
		}
		else {
			// otherwise this must be an object,
			// and there are no more transformations
			object = parseObject(token);
			break;
		}
		getToken(token);
	}
	assert(object != NULL);
	getToken(token); assert(!strcmp(token, "}"));
	return new Transform(matrix, object);
}
Esempio n. 5
0
Light* SceneParser::parseDirectionalLight() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token); assert(!strcmp(token, "direction"));
	Vec3f direction = readVec3f();
	getToken(token); assert(!strcmp(token, "color"));
	Vec3f color = readVec3f();
	getToken(token); assert(!strcmp(token, "}"));
	return new DirectionalLight(direction, color);
}
Esempio n. 6
0
        Md2Parser::Md2FrameList Md2Parser::parseFrames(const char* begin, const size_t frameCount, const size_t frameVertexCount) {
            Md2FrameList frames(frameCount, Md2Frame(frameVertexCount));

            const char* cursor = begin;
            for (size_t i = 0; i < frameCount; ++i) {
                frames[i].scale = readVec3f(cursor);
                frames[i].offset = readVec3f(cursor);
                readBytes(cursor, frames[i].name, Md2Layout::FrameNameLength);
                readVector(cursor, frames[i].vertices);
            }
            
            return frames;
        }
Esempio n. 7
0
void scene::parseLights()
{
    char token[MAX_PARSER_TOKEN_LENGTH];
    char texname[MAX_PARSER_TOKEN_LENGTH];
    getToken(token);
    assert (!strcmp(token, "{"));

    /* Loop over each Material */
    bool working=true;
    while (working)
    {
        getToken(token);
        if (!strcmp(token, "}"))
        {
            working = false;
        }
        else if (!strcmp(token, "Light"))
        {
            getToken(token);
            assert (!strcmp(token, "{"));
            texname[0] = '\0';
            Vec3f position(0,0,0);
            Vec3f color(1,1,1);

            while (1)
            {
                getToken(token);
                if (!strcmp(token, "position"))
                    position = readVec3f();
                else if (!strcmp(token, "color"))
                    color = readVec3f();
                else
                {
                    assert (!strcmp(token, "}"));
                    break;
                }
            }

            /**********************************************/
            /* The call to your own constructor goes here */
            /**********************************************/
            light temp;
            temp.position=position;
            temp.color=color;

            myLights.push_back(temp);

        }
    }
}
Esempio n. 8
0
void SceneParser::parseOrthographicCamera() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	// read in the camera parameters
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token); assert(!strcmp(token, "center"));
	Vec3f center = readVec3f();
	getToken(token); assert(!strcmp(token, "direction"));
	Vec3f direction = readVec3f();
	getToken(token); assert(!strcmp(token, "up"));
	Vec3f up = readVec3f();
	getToken(token); assert(!strcmp(token, "size"));
	float size = readFloat();
	getToken(token); assert(!strcmp(token, "}"));
	camera = (Camera*) new OrthographicCamera(center, direction, up, size);
}
Esempio n. 9
0
Triangle* SceneParser::parseTriangle() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token);
	assert(!strcmp(token, "vertex0"));
	Vec3f v0 = readVec3f();
	getToken(token);
	assert(!strcmp(token, "vertex1"));
	Vec3f v1 = readVec3f();
	getToken(token);
	assert(!strcmp(token, "vertex2"));
	Vec3f v2 = readVec3f();
	getToken(token); assert(!strcmp(token, "}"));
	assert(current_material != NULL);
	return new Triangle(v0, v1, v2, current_material);
}
Esempio n. 10
0
void SceneParser::parsePerspectiveCamera() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	// read in the camera parameters
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token); assert(!strcmp(token, "center"));
	Vec3f center = readVec3f();
	getToken(token); assert(!strcmp(token, "direction"));
	Vec3f direction = readVec3f();
	getToken(token); assert(!strcmp(token, "up"));
	Vec3f up = readVec3f();
	getToken(token); assert(!strcmp(token, "angle"));
	float angle_degrees = readFloat();
	float angle_radians = DegreesToRadians(angle_degrees);
	getToken(token); assert(!strcmp(token, "}"));
	camera = (Camera *) new PerspectiveCamera(center, direction, up, angle_radians);
}
Esempio n. 11
0
/* Parse out the "Triangle" token */
triangle* scene::parseTriangle()
{
    char token[MAX_PARSER_TOKEN_LENGTH];
    getToken(token);
    assert (!strcmp(token, "{"));

    /* Parse out vertex information */
    getToken(token);
    assert (!strcmp(token, "vertex0"));
    Vec3f v0 = readVec3f();
    getToken(token);
    assert (!strcmp(token, "vertex1"));
    Vec3f v1 = readVec3f();
    getToken(token);
    assert (!strcmp(token, "vertex2"));
    Vec3f v2 = readVec3f();
    getToken(token);
    assert (!strcmp(token, "tex_xy_0"));
    float x0 = 0;
    float y0 = 0;
    x0 = readFloat();
    y0 = readFloat();
    getToken(token);
    assert (!strcmp(token, "tex_xy_1"));
    float x1 = 0;
    float y1 = 0;
    x1 = readFloat();
    y1 = readFloat();
    getToken(token);
    assert (!strcmp(token, "tex_xy_2"));
    float x2 = 0;
    float y2 = 0;
    x2 = readFloat();
    y2 = readFloat();
    getToken(token);
    assert (!strcmp(token, "materialIndex"));
    int mat = readInt();

    getToken(token);
    assert (!strcmp(token, "}"));

    /**********************************************/
    /* The call to your own constructor goes here */
    /**********************************************/
    return new triangle(v0,v1,v2,x0,x1,x2,y0,y1,y2,mat,this);
}
Esempio n. 12
0
void SceneParser::parseBackground() {
  char token[MAX_PARSER_TOKEN_LENGTH];
  // read in the background color
  getToken(token); assert (!strcmp(token, "{"));  
  while (1) {
    getToken(token); 
    if (!strcmp(token, "}")) { 
      break;  
    } else if (!strcmp(token, "color")) {
      background_color = readVec3f();
    } else if (!strcmp(token, "ambientLight")) {
      ambient_light = readVec3f();
    } else {
      printf ("Unknown token in parseBackground: '%s'\n", token);
      assert(0);
    }
  }
}
Esempio n. 13
0
Triangle* SceneParser::parseTriangle() {
  char token[MAX_PARSER_TOKEN_LENGTH];

  // read in the sphere parameters
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "vertex0"));
  Vec3f v0 = readVec3f();
  getToken(token); assert (!strcmp(token, "vertex1"));
  Vec3f v1 = readVec3f();
  getToken(token); assert (!strcmp(token, "vertex2"));
  Vec3f v2 = readVec3f();
  getToken(token); assert (!strcmp(token, "}"));

  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
  // CALLING ASSIGNMENT 2 CODE
  // create a new triangle object and return it
  return new Triangle(v0,v1,v2,current_object_color);
  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
}
Esempio n. 14
0
void SceneParser::parseMaterial() {
  char token[MAX_PARSER_TOKEN_LENGTH];
  // change the current object color
  // scoping for the materials is very simplistic,
  // and essentially ignores any tree hierarchy
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "diffuseColor"));
  current_object_color = readVec3f();
  getToken(token); assert (!strcmp(token, "}"));
}
Esempio n. 15
0
Sphere* SceneParser::parseSphere() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token); assert(!strcmp(token, "center"));
	Vec3f center = readVec3f();
	getToken(token); assert(!strcmp(token, "radius"));
	float radius = readFloat();
	getToken(token); assert(!strcmp(token, "}"));
	assert(current_material != NULL);
	return new Sphere(center, radius, current_material);
}
Esempio n. 16
0
Plane* SceneParser::parsePlane() {
	char token[MAX_PARSER_TOKEN_LENGTH];
	getToken(token); assert(!strcmp(token, "{"));
	getToken(token); assert(!strcmp(token, "normal"));
	Vec3f normal = readVec3f();
	getToken(token); assert(!strcmp(token, "offset"));
	float offset = readFloat();
	getToken(token); assert(!strcmp(token, "}"));
	assert(current_material != NULL);
	return new Plane(normal, offset, current_material);
}
void SceneParser::parsePhongMaterials() {
  char token[MAX_PARSER_TOKEN_LENGTH];
  // change the current object color
  // scoping for the materials is very simplistic,
  // and essentially ignores any tree hierarchy
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "numMaterials"));
  num_materials = readInt();
  materials = new PhongMaterial[num_materials];
  current_object_color = readVec3f();
  getToken(token); assert (!strcmp(token, "}"));
}
Esempio n. 18
0
void SceneParser::parsePerspectiveCamera() {
  char token[MAX_PARSER_TOKEN_LENGTH];

  // read in the camera parameters
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "center"));
  Vec3f center = readVec3f();
  getToken(token); assert (!strcmp(token, "direction"));
  Vec3f direction = readVec3f();
  getToken(token); assert (!strcmp(token, "up"));
  Vec3f up = readVec3f();
  getToken(token); assert (!strcmp(token, "angle"));
  float angle_degrees = readFloat();
  float angle_radians = DegreesToRadians(angle_degrees);
  getToken(token); assert (!strcmp(token, "}"));

  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
  // CALLING ASSIGNMENT 2 CODE
  // create a new perspective camera and return it
  camera = new PerspectiveCamera(center,direction,up,angle_radians);
  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
}
Esempio n. 19
0
Sphere* SceneParser::parseSphere() {
  char token[MAX_PARSER_TOKEN_LENGTH];

  // read in the sphere parameters
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "center"));
  Vec3f center = readVec3f();
  getToken(token); assert (!strcmp(token, "radius"));
  float radius = readFloat();
  getToken(token); assert (!strcmp(token, "}"));

  return new Sphere(center,radius,current_object_color);
}
Esempio n. 20
0
Material* SceneParser::parseMaterial() {
  char token[MAX_PARSER_TOKEN_LENGTH];
  Vec3f diffuseColor(1,1,1);
  getToken(token); assert (!strcmp(token, "{"));
  while (1) {
    getToken(token); 
    if (!strcmp(token, "diffuseColor")) {
      diffuseColor = readVec3f();
    } else {
      assert (!strcmp(token, "}"));
      break;
    }
  }
  Material *answer = new Material(diffuseColor);
  return answer;
}
Esempio n. 21
0
Plane* SceneParser::parsePlane() {
  char token[MAX_PARSER_TOKEN_LENGTH];

  // read in the sphere parameters
  getToken(token); assert (!strcmp(token, "{"));
  getToken(token); assert (!strcmp(token, "normal"));
  Vec3f normal = readVec3f();
  getToken(token); assert (!strcmp(token, "offset"));
  float offset = readFloat();
  getToken(token); assert (!strcmp(token, "}"));

  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
  // CALLING ASSIGNMENT 2 CODE
  // create a new plane object and return it
  return new Plane(normal,offset,current_object_color);
  // ++++++++++++++++++++++++++++++++++++++++++++++++++++
}
Esempio n. 22
0
/* Parse the "Sphere" token */
sphere* scene::parseSphere()
{
    char token[MAX_PARSER_TOKEN_LENGTH];

    getToken(token);
    assert (!strcmp(token, "{"));
    getToken(token);
    assert (!strcmp(token, "materialIndex"));
    int sphere_material_index = readInt();
    getToken(token);
    assert (!strcmp(token, "center"));
    Vec3f center = readVec3f();
    getToken(token);
    assert (!strcmp(token, "radius"));
    float radius = readFloat();
    getToken(token);
    assert (!strcmp(token, "}"));

    /**********************************************/
    /* The call to your own constructor goes here */
    /**********************************************/
    return new sphere(center,radius,sphere_material_index,this);
}
Esempio n. 23
0
/* Parse the "Materials" token */
void scene::parseMaterials()
{
    char token[MAX_PARSER_TOKEN_LENGTH];
    char texname[MAX_PARSER_TOKEN_LENGTH];
    getToken(token);
    assert (!strcmp(token, "{"));

    /* Loop over each Material */
    bool working=true;
    while (working)
    {
        getToken(token);
        if (!strcmp(token, "}"))
        {
            working = false;
        }
        else if (!strcmp(token, "Material"))
        {
            getToken(token);
            assert (!strcmp(token, "{"));
            texname[0] = '\0';
            Vec3f diffuseColor(1,1,1);
            Vec3f specularColor(0,0,0);
            float shininess = 1;
            Vec3f transparentColor(0,0,0);
            Vec3f reflectiveColor(0,0,0);
            float indexOfRefraction = 1;

            while (1)
            {
                getToken(token);
                if (!strcmp(token, "textureFilename"))
                {
                    getToken(token);
                    strcpy(texname, token);
                }
                else if (!strcmp(token, "diffuseColor"))
                    diffuseColor = readVec3f();
                else if (!strcmp(token, "specularColor"))
                    specularColor = readVec3f();
                else if  (!strcmp(token, "shininess"))
                    shininess = readFloat();
                else if (!strcmp(token, "transparentColor"))
                    transparentColor = readVec3f();
                else if (!strcmp(token, "reflectiveColor"))
                    reflectiveColor = readVec3f();
                else if (!strcmp(token, "indexOfRefraction"))
                    indexOfRefraction = readFloat();
                else
                {
                    assert (!strcmp(token, "}"));
                    break;
                }
            }

            material temp;
            temp.diffuseCol=diffuseColor;
            temp.specularCol=specularColor;
            temp.shininess=shininess;
            temp.transparentCol=transparentColor;
            temp.reflectiveCol=reflectiveColor;
            temp.refractionIndex=indexOfRefraction;
            if(strcmp(texname, "NULL"))
                temp.texture=jpeg_read(texname, NULL);
            else
                temp.texture=NULL;

            myMaterials.push_back(temp);

        }
    }
}