#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <memory.h>
#include <assert.h>

class obj_t
{
public:
   double  (*hits)(void);
   void    (*uninorm)(void);

/* Optional plugins for retrieval of reflectivity */
/* useful for the ever-popular tiled floor        */

   void    (*getamb)(void);
   void    (*getdiff)(void);
   void    (*getspec)(void);

private:
   class   obj_t  *next;
   int     objid;
   int     objtype;

   double  ambient[3];    /* Reflectivity for materials  */
   double  diffuse[3];
   double  specular[3];

   double  emissivity[3]; /* For lights                  */

   void    *priv;        /* Private type-dependent data */
   double  hitloc[3];    /* Last hit point              */
   double  normal[3];    /* Normal at hit point         */
};

class link_t
{
public:
   link_t(void);       // constructor
   link_t(obj_t *);    // constructor
   void set_next(link_t *);
   link_t *get_next();
   obj_t  *get_object();
private:
   link_t *next;
   obj_t  *obj;

};

link_t::link_t(obj_t *newobj)
{
   next = NULL;
   obj  = newobj;
}

void link_t::set_next(link_t *new_next)
{
   next = new_next;
}

link_t * link_t::get_next()
{
   return(next);
}

obj_t * link_t::get_object()
{
   return(obj);
}

class list_t
{
public:
   list_t(void);             // constructor
   void   add(obj_t *obj);   // add object to end of list
   void   start();           // set current to start of list
   link_t *next();           // advance to next element in list
   obj_t  *access();          // return current object

private:
   link_t *first;
   link_t *last;
   link_t *current;
};

void list_t::add(obj_t *obj)
{
   link_t *link;
   link = new link_t(obj);
   if (first == NULL)
   {
      first = last = link;
   }
   else
   {
      last->set_next(link);
      last = link;
   }
}

void list_t::start(void)
{
   current = first;
}

link_t * list_t::next(void)
{
   link_t *link;
   link = current->get_next();
   if (link != NULL)
      current = link;
   return(link);
}

obj_t * list::access(void)
{
   rturn(current->get_object());
}
class view_t
{
public:
   view_t(void);
   view_t(FILE *in, FILE *out);
   int    load_view(FILE *);
   void   print_view(FILE *);
private:
   int    win_x_size;
   int    win_y_size;
   double world_x_size;
   double world_y_size;
   double viewpt[3];
};

class model_t
{
public:
   model_t();
   model_t(FILE *in, FILE *out);
private:
   class view_t *view;
   class list_t *list;
};


model_t::model_t(
FILE *in,
FILE *out)
{
   view = new view_t(in, out);
   list = new list_t();
}

view_t::view_t(void)
{

}
view_t::view_t(FILE *in, FILE *out)
{
   load_view(in);
   print_view(out);
}

link_t::link_t(void)
{
   next = NULL;
   obj  = NULL;
}

list_t::list_t(void)
{
   first = last = NULL;
}

int view_t::load_view(FILE *in)
{
   int vc;
   char buf[256];

   vc = fscanf(in, "%lf %lf", &world_x_size, &world_y_size);
   fgets(buf, 256, in);

   vc += fscanf(in, "%lf %lf %lf", viewpt, viewpt + 1, viewpt + 2);
   fgets(buf, 256, in);

   if (vc == 5)
       return(0);
   else
       return(-1);
}

void view_t::print_view(FILE *out)
{
   fprintf(out, "World to window mapping \n");
   fprintf(out, "%6.0lf %6.0lf \n",
                  world_x_size, world_y_size);

   fprintf(out, "\nViewpoint \n");
   fprintf(out, "%6.1lf %6.1lf %6.1lf\n",
                 viewpt[0], viewpt[1], viewpt[2]);

   return;
}

int main()
{
   model_t model(stdin, stderr);
}