/*
 *   GRacer
 *
 *   Copyright (C) 1999 Takashi Matsuda <matsu@users.sourceforge.net>
 *
 * This program is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License as 
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#ifndef __GRACER_COURSE_H__
#define __GRACER_COURSE_H__

#include <stdio.h>
#include "gr_global.h"
#include "gr_vertex.h"
#include "gr_plane.h"
#include "gr_boundary.h"
#include "gr_memory.h"

#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif

typedef enum {
  GR_CLINE_REGION_C	= 0,
  GR_CLINE_REGION_A	= 1,
  GR_CLINE_REGION_B	= 2,

  GR_CLINE_PREV_A	= GR_CLINE_REGION_A << 0,
  GR_CLINE_PREV_B	= GR_CLINE_REGION_B << 0,
  GR_CLINE_PREV_C	= GR_CLINE_REGION_C << 0,

  GR_CLINE_CURRENT_A	= GR_CLINE_REGION_A << 2,
  GR_CLINE_CURRENT_B	= GR_CLINE_REGION_B << 2,
  GR_CLINE_CURRENT_C	= GR_CLINE_REGION_C << 2,

  GR_CLINE_A_TO_A	= (GR_CLINE_PREV_A | GR_CLINE_CURRENT_A),
  GR_CLINE_A_TO_B	= (GR_CLINE_PREV_A | GR_CLINE_CURRENT_B),
  GR_CLINE_A_TO_C	= (GR_CLINE_PREV_A | GR_CLINE_CURRENT_C),

  GR_CLINE_B_TO_A	= (GR_CLINE_PREV_B | GR_CLINE_CURRENT_A),
  GR_CLINE_B_TO_B	= (GR_CLINE_PREV_B | GR_CLINE_CURRENT_B),
  GR_CLINE_B_TO_C	= (GR_CLINE_PREV_B | GR_CLINE_CURRENT_C),

  GR_CLINE_C_TO_A	= (GR_CLINE_PREV_C | GR_CLINE_CURRENT_A),
  GR_CLINE_C_TO_B	= (GR_CLINE_PREV_C | GR_CLINE_CURRENT_B),
  GR_CLINE_C_TO_C	= (GR_CLINE_PREV_C | GR_CLINE_CURRENT_C),

  GR_CLINE_CURRENT_MASK	= (GR_CLINE_CURRENT_A |
  			   GR_CLINE_CURRENT_B |
			   GR_CLINE_CURRENT_C),

  GR_CLINE_PREV_MASK	= (GR_CLINE_PREV_A |
			   GR_CLINE_PREV_B |
			   GR_CLINE_PREV_C),

  GR_CLINE_MASK		= (GR_CLINE_CURRENT_MASK | GR_CLINE_PREV_MASK),
} GrCLineType;

#define gr_cline_current_region(r) \
	(((r) & GR_CLINE_CURRENT_MASK) >> 2)

#define gr_cline_prev_region(r) \
	((r) & GR_CLINE_PREV_MASK)

typedef struct GrCLineInfo {
  GrCLineType res;
  struct {
    GrVertexd pos;
    int cline;
  } current, prev;

  float cross_ratio;
} GrCLineInfo;

typedef struct GrCMaterial {
  float friction;
  float exp;
  float mu;
  int flag;
} GrCMaterial;

typedef struct GrCSurface {
  GrPlane plane;
  int p[3];
  GrVertex v[3];
  GrVertex rv[3];
  int flag;
  int mat;
} GrCSurface;

typedef struct GrCSegment {
  GrBoundary *boundary;
  int num_verts;
  GrVertex *verts;
  int num_surfs;
  GrCSurface *surfs;
  int flag;
  GrVertex max, min;
} GrCSegment;

typedef struct GrControlLine {
  GrVertex region_a[4];
  GrVertex rot_a[4];
  GrVertex region_b[4];
  GrVertex rot_b[4];
  int flag;
  int segment;
  float xmax, xmin;
  float ymax, ymin;
} GrControlLine;

typedef struct GrGrid {
  float x, y, dir;
  int segment;
  int flag;
} GrGrid;

typedef struct GrCourse {
  GrRef ref;

  char *title;
  char *desc;
  char *model;
  char *timestamp;

  int num_grids;
  GrGrid *grids;

  int num_clines;
  GrControlLine *clines;

  int num_mats;
  GrCMaterial *mats;

  int num_segs;
  GrCSegment **segs;
} GrCourse;

typedef int (*GrCSurfaceCallback)		(GrCourse *course,
    						 int seg_no,
    						 int surf_no,
						 void *data);
typedef int (*GrCSurfaceXYCallback)		(GrCourse *course,
    						 int seg_no,
    						 int surf_no,
						 float z,
						 void *data);

GrCourse*	gr_course_new_from_file		(FILE *file);
GrCourse*	gr_course_new_from_data		(char *data);
GrCSurface*	gr_course_find_surface		(GrCourse *course,
    						 float x, float y,
						 int segment_cur,
						 int *segment_ret);

void		gr_course_write_file		(GrCourse *course, FILE *file);

int		gr_course_check_control_line	(GrCourse *course,
						 GrCLineInfo *cinfo);

void		gr_course_foreach_surface	(GrCourse *course,
						 GrVertex *center,
						 float r,
						 GrCSurfaceCallback callback,
						 void *data);

void		gr_course_foreach_surface_xy	(GrCourse *course,
						 GrVertex *pos,
						 GrCSurfaceXYCallback callback,
						 void *data);

int		gr_course_surface_check_inner	(GrCSurface *surf,
						 GrVertex *p);

#ifdef __cplusplus
}
#endif

#endif /* __GRACER_COURSE_H__ */