Functions.hh

Go to the documentation of this file.

 
#include "Effect.hh"
#include "Graph.hh"
#include <typeinfo>
 
struct FCube
{
  Point p;
  Vector u_x;
  Vector u_y;
  Vector u_z;
};
 
struct FLine
{
public:
  Point p1,p2;
  Vector u_x,u_y;
};
 
struct FPlane
{
public:
  Point p1,p2,p3,p4;
  Vector u;
};
 
struct FFlexCube
{
public:
  float dist_left;
  float dist_right;
  //float height;
  float left_angle; 
  float right_angle; 
  //float top_angle; 
  //float bottom_angle; 
};
 
struct FCube2
{
  Point tlb;
  Point trb;
  Point blb;
  Point brb;
  Point tlf;
  Point trf;
  Point blf;
  Point brf;
};
 
 
void cube(Matrix m, FaceStore &s);
void sphere(Matrix m, int numfaces, int numfaces2, FaceStore &s);
void cone(Matrix m, int numfaces, Point p1, Point p2, float rad1, float rad2, FaceStore &s);
void rectangle(Matrix m, float x, float y, FaceStore &s);
void texture_rectangle(Matrix m, TexturePlugin *plugin, FaceStore &s);
 
void cylinder(Matrix m, int numfaces, FaceStore &s);
void disk(Matrix m, int numfaces, float disk_pos, FaceStore &s);
void color(BoxableFaceCollection &coll, unsigned int color, FaceStore &s);
void matrix(BoxableFaceCollection &coll, Matrix m, FaceStore &s);
void andnot(BoxableFaceCollection &coll, BoxableFaceCollection &coll2, FaceStore &s);
void ring(Matrix m, const PointVectorCollection &points, float x, int steps, FaceStore &s);
 
void color_poly(Point2d p1, Point2d p2, Point2d p3, Color c1, Color c2, int x, int y, BitmapStore<Color> &s);
 
 
void floor(const FCube &pos, FLine &l1, FLine &l2, FLine &l3, FLine &l4, FPlane &pl, FaceStore &s);
 
void linetocube(const FLine &line, FCube &cube);
 
void flexcube(const FPlane &pl, 
          const FFlexCube &args,
          FCube2 &res);
 
void flexcube(const FPlane &pl, float dist_left, float dist_right, float left_angle, float right_angle, FCube2 &res);
 
void plane_cube_blit(const FPlane &pl, FaceStore &s);
 
void cubeplane_t(const FCube2 &res, FPlane &pl);
void cubeplane_l(const FCube2 &res, FPlane &pl);
void cubeplane_r(const FCube2 &res, FPlane &pl);
void cubeplane_f(const FCube2 &res, FPlane &pl);
 
FPlane plane_init();
void plane_dup(const FPlane &pl, FPlane &pl1);
 
void tunnel_end(const FPlane &pl, FaceStore &s);
 
int chessboard_bitmap(FrameAnimPlugins *fa);
void chessboard(const FPlane &pl, FaceStore &s);
 
class FuncEffect : public FrameAnimPlugins
{
public:
  FuncEffect(Render *render);
  void Init();
  bool Frame(float time);
private:
  //int tex_index;
};
 
class FunctionPointerFrameAnim : public FrameAnimPlugins
{
public:
  FunctionPointerFrameAnim(Render *render, void (*fptr)(FaceStore &s)) : FrameAnimPlugins(render), fptr(fptr) { }
  void Init();
  void Cleanup();
  bool Frame(float time);
private:
  void (*fptr)(FaceStore &s);
};
 
void chessboard_test(FaceStore &s);
 
class PolyContainer
{
public:
  void Alloc(int bytescount, int objcount2) { buffer = new char[bytescount]; ptrs=new char*[objcount2]; widths = new int[objcount2]; bufferbytes = bytescount; objcount = objcount2; }
  void ResizeObjs(int newobjcount)
  {
    char **p = new char*[newobjcount];
    int *w = new int[newobjcount];
    std::type_info **i = new std::type_info*[newobjcount];
    std::copy(ptrs,ptrs+objcount,p);
    std::copy(widths, widths+objcount, w);
    std::copy(infos, infos+objcount, i);
    delete [] ptrs;
    delete [] widths;
    delete [] infos;
    ptrs = p;
    widths = w;
    infos = i;
    objcount = newobjcount;
  }
  void ResizeBytes(int newcount)
  {
    char *buf = new char[newcount];
    std::copy(buffer, buffer+bufferbytes, buf);
    delete [] buffer;
    buffer = buf;
    bufferbytes = newcount;
  }
 
 
  #if 0
  template<class T>
  T *GetObj(int obj)
  {
    if (*(infos[obj])!=typeid(T)) return 0;
    return (T*)ptrs[obj];
  }
  #endif
  
  template<class T>
  void AllocObj(int obj)
  {
    if (obj > objcount) ResizeObjs(obj+20);
    if (ptrs[obj] != 0)
      {
    T *ptr = (T*)&ptrs[obj];
    ptr->~T();
      }
    if (allocated_bytes + sizeof(T) >= bufferbytes) ResizeBytes(allocated_bytes + sizeof(T)*20);
    T* ptr = new(buffer+allocated_bytes)T;
    ptrs[obj] = ptr;
    widths[obj] = sizeof(T);
    // infos[obj] = new std::type_info;
    //TODO *(infos[obj]) = typeid(T);
    allocated_bytes+=sizeof(T);
  }
private:
  char *buffer;
  int bufferbytes;
  char **ptrs;
  int *widths;
  std::type_info **infos;
  int objcount;
 
  int allocated_bytes;
};