/*
 *   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
 */

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include "tcldefs.h"
#include "glutgame.h"
#include <common/gr_memory.h>
#include <common/gr_debug.h>
#include <common/gr_scene.h>
#include <common/gr_angle.h>
#include "lap.h"
#include "glbind.h"
#include <GL/glut.h>
#include "sound.h"

#ifndef MAX
#define MAX(a,b) (((a) > (b))? (a) : (b))
#endif

#define	LFONT_SIZE		0.10
#define SFONT_SIZE		0.08

#define	LFONT_HEIGHT		(LFONT_SIZE + 0.02)
#define SFONT_HEIGHT		(SFONT_SIZE + 0.01)

#define	LFONT_WIDTH		(LFONT_SIZE * 0.8)
#define SFONT_WIDTH		(SFONT_SIZE * 0.8)

#define	RPM_ANGLE		215.0

#define MIN_INTERVAL		0.02

typedef struct GrViewerQueryInfo {
  char *name;
  int (*func) (GrViewer *game, GrViewerEntryInfo *gentry,
	       Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]);
} GrViewerQueryInfo;


static void	glut_game_overhead_reshape	(GlutObject obj,
						 int width, int height);
static void	glut_game_draw_panel		(GlutObject obj);

Tcl_Obj *obj_time;
Tcl_Obj *obj_lap;
Tcl_Obj *obj_speed;
Tcl_Obj *obj_rpm;
Tcl_Obj *obj_entry;

Tcl_HashTable query_hash;

GrViewerOption
gr_viewer_get_options (GrViewer *viewer)
{
  return viewer->options;
}

void
gr_viewer_set_options (GrViewer *viewer, GrViewerOption options)
{
  const GrObjectDrawOption linear_mask = 
    GR_OBJECT_MAG_LINEAR | GR_OBJECT_MIN_LINEAR | GR_OBJECT_MIP_LINEAR;

  viewer->options = options;

  viewer->use_texture = (options & GR_VIEWER_USE_TEXTURE) != 0;
  viewer->use_mipmap = (options & GR_VIEWER_USE_MIPMAP) != 0;
  viewer->use_linear = (options & GR_VIEWER_USE_LINEAR) != 0;
  viewer->use_shading = (options & GR_VIEWER_USE_SHADING) != 0;
  viewer->show_sky = (options & GR_VIEWER_SHOW_SKY) != 0;
  viewer->show_decr = (options & GR_VIEWER_SHOW_DECR) != 0;
  viewer->use_audio = (options & GR_VIEWER_USE_AUDIO) != 0;

  viewer->draw_option = GR_OBJECT_ALL;
  viewer->draw_option &=
    (options & GR_VIEWER_USE_TEXTURE)? ~0 : ~GR_OBJECT_TEXTURE;
  viewer->draw_option &=
    (options & GR_VIEWER_USE_MIPMAP)? ~0 : ~GR_OBJECT_MIPMAP;
  viewer->draw_option &=
    (options & GR_VIEWER_USE_LINEAR)? ~0 : ~linear_mask;
  viewer->draw_option &=
    (options & GR_VIEWER_USE_SHADING)? ~0 : ~GR_OBJECT_SMOOTH;
}


static int
Tcl_GrViewerConfigure (Tcl_Interp *interp, GlutObject obj,
    		       int objc, Tcl_Obj *CONST objv[])
{
  GrViewer *game = obj;
  Tcl_Obj *res_obj;
  char *str;
  int i;
  int res;
  GrViewerOption option;

  for (i=0; i<objc; ) {
    str = Tcl_GetStringFromObj (objv[i], NULL);
    if (!strcmp (str, "-use_texture")) {
      option = GR_VIEWER_USE_TEXTURE;
    } else if (!strcmp (str, "-use_mipmap")) {
      option = GR_VIEWER_USE_MIPMAP;
    } else if (!strcmp (str, "-use_linear")) {
      option = GR_VIEWER_USE_LINEAR;
    } else if (!strcmp (str, "-use_shading")) {
      option = GR_VIEWER_USE_SHADING;
    } else if (!strcmp (str, "-show_sky")) {
      option = GR_VIEWER_SHOW_SKY;
    } else if (!strcmp (str, "-show_decr")) {
      option = GR_VIEWER_SHOW_DECR;
    } else if (!strcmp (str, "-use_audio")) {
      option = GR_VIEWER_USE_AUDIO;
    } else {
      option = 0;
    }
    if (option) {
      if (i+1 == objc) {
	res = gr_viewer_get_options (game);
	res_obj = Tcl_NewIntObj ((res & option) != 0);
	Tcl_SetObjResult (interp, res_obj);
	return TCL_OK;
      } else {
	if (Tcl_GetIntFromObj (interp, objv[i+1], &res) == TCL_ERROR) {
	  Tcl_AppendResult (interp, ": flag must be integer value.", NULL);
	  return TCL_ERROR;
	} else {
	  if (res) {
	    option = gr_viewer_get_options (game) | option;
	  } else {
	    option = gr_viewer_get_options (game) & ~option;
	  }
	  gr_viewer_set_options (game, option);
	  i += 2;
	}
      }
    } else {
      res = Tcl_GlutWidgetConfigure (interp, obj, objc-i, objv+i);
      if (res == 0) {
	return TCL_ERROR;
      }
      i += res;
    }
  }

  return TCL_OK;
}

static void
gr_tcltrigger_callback (GrWorld *world,
			GrVehicle *vehicle,
			GrTclTrigger *trigger)
{
  Tcl_Obj *obj;
  Tcl_Interp *interp;
  Tcl_Obj *script;

  if (!trigger->interp || !trigger->script)
    return;

  interp = trigger->interp;
  script = trigger->script;

  obj = Tcl_NewIntObj (vehicle->entry_no);
  Tcl_ObjSetVar2 (interp, obj_entry, NULL, obj, 0);

  Tcl_IncrRefCount (script);
  if (Tcl_EvalObj (interp, script) == TCL_ERROR) {
    fputs (Tcl_GetVar (interp, "errorInfo", TCL_GLOBAL_ONLY), stderr);
  }
  Tcl_DecrRefCount (script);
}

static void
gr_tcltrigger_destroy (GrTclTrigger *trigger)
{
  if (trigger->script) {
    Tcl_DecrRefCount (trigger->script);
  }
  free (trigger);
}


static int
tcl_GrViewerTrigger (GrViewer *game,
		     Tcl_Interp *interp,
		     int objc,
		     Tcl_Obj *CONST objv[])
{
  int i, length;
  GrTclTrigger trigger, *ptr;
  char *str;
  Tcl_HashEntry *entry;
  int key;
  int _new;

  if (objc < 3) {
    goto ERROR;
  }

  memset (&trigger, 0, sizeof (trigger));
  trigger.key = -1;

  for (i=0; i<objc; i++) {
    str = Tcl_GetStringFromObj (objv[i], NULL);
    if (!str) {
      goto ERROR;
    }
    if (!strcmp (str, "-cline") && i+1 < objc) {
      i ++;
      TCL_CHECK(Tcl_GetIntFromObj (interp, objv[i], &trigger.core.cline),
		ERROR);
      if (trigger.core.cline < 0) {
	Tcl_AppendResult (interp, ": cline must greater than or equal zero.",
				  NULL);
	return TCL_ERROR;
      }
      trigger.core.condition |= GR_TRIGGER_CLINE;
    } else if (!strcmp (str, "-a_to_b")) {
      trigger.core.condition |= GR_CLINE_A_TO_B;
    } else if (!strcmp (str, "-a_to_a")) {
      trigger.core.condition |= GR_CLINE_A_TO_A;
    } else if (!strcmp (str, "-a_to_c")) {
      trigger.core.condition |= GR_CLINE_A_TO_C;
    } else if (!strcmp (str, "-b_to_a")) {
      trigger.core.condition |= GR_CLINE_B_TO_A;
    } else if (!strcmp (str, "-b_to_b")) {
      trigger.core.condition |= GR_CLINE_B_TO_B;
    } else if (!strcmp (str, "-b_to_c")) {
      trigger.core.condition |= GR_CLINE_B_TO_C;
    } else if (!strcmp (str, "-c_to_a")) {
      trigger.core.condition |= GR_CLINE_C_TO_A;
    } else if (!strcmp (str, "-c_to_b")) {
      trigger.core.condition |= GR_CLINE_C_TO_B;
    } else if (!strcmp (str, "-lap++")) {
      trigger.core.condition |= GR_TRIGGER_LAP_PLUS;
    } else if (!strcmp (str, "-lap") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_GetIntFromObj (interp, objv[i], &trigger.core.lap), ERROR);
      if (trigger.core.lap < 0) {
	Tcl_AppendResult (interp, ": lap must greater than or equal zero.",
				  NULL);
	return TCL_ERROR;
      }
      trigger.core.condition |= GR_TRIGGER_LAP;
    } else if (!strcmp (str, "-key") && i+1<objc) {
      if (trigger.key <= 0) {
	Tcl_AppendResult (interp, ": trigger key must greater than zero.",
				  NULL);
	return TCL_ERROR;
      }
      i ++;
      TCL_CHECK(Tcl_GetIntFromObj (interp, objv[i], &trigger.key), ERROR);
    } else if (!strcmp (str, "-speed_lt") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_GetDoubleFromObj (interp, objv[i], &trigger.core.speed_lt),
	  ERROR);
      trigger.core.condition |= GR_TRIGGER_SPEED_LT;
    } else if (!strcmp (str, "-speed_gt") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_GetDoubleFromObj (interp, objv[i], &trigger.core.speed_gt),
	  ERROR);
      trigger.core.condition |= GR_TRIGGER_SPEED_GT;
    } else if (!strcmp (str, "-rpm_lt") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_GetDoubleFromObj (interp, objv[i], &trigger.core.rpm_lt),
	  ERROR);
      trigger.core.condition |= GR_TRIGGER_RPM_LT;
    } else if (!strcmp (str, "-rpm_gt") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_GetDoubleFromObj (interp, objv[i], &trigger.core.rpm_gt),
	  ERROR);
      trigger.core.condition |= GR_TRIGGER_RPM_GT;
    } else if (!strcmp (str, "-command") && i+1<objc) {
      i ++;
      TCL_CHECK(Tcl_ListObjLength (interp, objv[i], &length), ERROR);
      if (length > 0) {
	Tcl_IncrRefCount (objv[i]);
	trigger.interp = interp;
	trigger.script = objv[i];
      } else {
	goto ERROR;
      }
    } else if (!strcmp (str, "-remove") && i+1 == objc -1) {
      i ++;
      TCL_CHECK(Tcl_GetIntFromObj (interp, objv[i], &key), ERROR);
      if (trigger.key <= 0) {
	Tcl_AppendResult (interp, ": trigger key must greater than zero.",
				  NULL);
	return TCL_ERROR;
      }
      entry = Tcl_FindHashEntry (&game->trigger_hash, (ClientData) key);
      if (!entry)
	goto NOT_DEFINED_ERROR;

      ptr = Tcl_GetHashValue (entry);
      Tcl_DeleteHashEntry (entry);
      gr_DECREF (ptr);
      gr_world_remove_trigger (game->world, (GrTrigger *) ptr);

      return TCL_OK;
    } else {
      goto ERROR;
    }
  }

  ptr = gr_new0 (GrTclTrigger, 1);
  if (!ptr) {
    Tcl_AppendResult (interp, ": memory allocation error.", NULL);
    return TCL_ERROR;
  }
  gr_FREE_FUNC (ptr, gr_tcltrigger_destroy);
  *ptr = trigger;
  ptr->core.callback = (GrTriggerFunc) gr_tcltrigger_callback;

  gr_world_add_trigger (game->world, (GrTrigger *) ptr);
  game->trigger_key ++;
  entry = Tcl_CreateHashEntry (&game->trigger_hash,
			       (char *) game->trigger_key, &_new);
  Tcl_SetHashValue (entry, ptr);
  gr_INCREF (ptr);

  Tcl_SetObjResult (interp, Tcl_NewIntObj (game->trigger_key));
  return TCL_OK;

ERROR:
  Tcl_AppendResult (interp,
      ": wrong args. should be -cline <no>, -a_to_a, -a_to_b, -a_to_c, "
      "-b_to_a, -b_to_b, -b_to_c, -c_to_a, -c_to_b, -lap <no>, -key <no>, "
      "-speed_lt <val>, -speed_gt <val>, -rpm_lt <val>, -rpm_gt <val>, "
      "-command <script>, -replace <key>, or -remove <key>.",
      NULL);
  return TCL_ERROR;

NOT_DEFINED_ERROR:
  Tcl_AppendResult (interp, ": illegal trigger key. not defined.", NULL);
  return TCL_ERROR;
}

static int
tcl_query_subcmd_current_time (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (game->world->current_time);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_event_time (GrViewer *game,
			     GrViewerEntryInfo *gentry,
			     Tcl_Interp *interp,
			     int objc,
			     Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->time);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_pos (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;
  Tcl_Obj *res;

  res = Tcl_GetObjResult (interp);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.x);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.y);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.z);
  Tcl_ListObjAppendList (interp, res, obj);

  return 1;
}

static int
tcl_query_subcmd_spd (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;
  Tcl_Obj *res;

  res = Tcl_GetObjResult (interp);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].spd.c.x);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].spd.c.y);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].spd.c.z);
  Tcl_ListObjAppendList (interp, res, obj);

  return 1;
}

static int
tcl_query_subcmd_rot (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;
  Tcl_Obj *res;

  res = Tcl_GetObjResult (interp);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].rot.c.x);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].rot.c.y);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].rot.c.z);
  Tcl_ListObjAppendList (interp, res, obj);

  return 1;
}

static int
tcl_query_subcmd_omg (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;
  Tcl_Obj *res;

  res = Tcl_GetObjResult (interp);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].omg.c.x);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].omg.c.y);
  Tcl_ListObjAppendList (interp, res, obj);
  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].omg.c.z);
  Tcl_ListObjAppendList (interp, res, obj);

  return 1;
}

static int
tcl_query_subcmd_x (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.x);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_y (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.y);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_z (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->body.state[0].pos.c.z);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_rpm (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->state[0].rpm);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_speed (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->state[0].spd);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_gear (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  Tcl_Obj *obj;

  obj = Tcl_NewDoubleObj (gentry->vehicle->control.gear);
  Tcl_ListObjAppendList (interp, Tcl_GetObjResult (interp), obj);

  return 1;
}

static int
tcl_query_subcmd_lap (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  int lap = MAX (gentry->vehicle->lap, gentry->vehicle->lap_count);

  if (Tcl_ListObjAppendList (interp,
			     Tcl_GetObjResult (interp),
			     Tcl_NewIntObj (lap)) == TCL_ERROR)
  {
    return 0;
  }

  return 1;
}

static int
tcl_query_subcmd_entry (GrViewer *game,
			GrViewerEntryInfo *gentry,
			Tcl_Interp *interp,
			int objc,
			Tcl_Obj *CONST objv[])
{
  int i;
  int entry_no;
  char *str;
  Tcl_HashEntry *entry;
  GrViewerQueryInfo *query;
  int res;

  TCL_CHECK (Tcl_GetIntFromObj(interp, objv[1], &entry_no), ERROR);
  entry = Tcl_FindHashEntry (&game->entry_hash, (ClientData) entry_no);
  if (!entry) {
    Tcl_AppendResult (interp, ": illegal entry no. does not defined.",
		      NULL);
    return 0;
  }
  gentry = Tcl_GetHashValue (entry);

  for (i=2; i<objc; i++) {
    str = Tcl_GetStringFromObj (objv[i], NULL);
    if (!str) {
      goto ERROR;
    }

    entry = Tcl_FindHashEntry (&query_hash, str);
    if (!entry) {
      goto ERROR;
    }
    query = Tcl_GetHashValue (entry);
    res = (*query->func) (game, gentry, interp, objc-i, objv+i);
    if (res <= 0) {
      goto ERROR;
    }
    i += res;
  }

  return i;

ERROR:
  Tcl_AppendResult (interp, ": wrong args. "
      "should be entry <entry no> {pos, spd, rot, omg, x, y, z, lap, "
      "or event_time} ...",
      NULL);

  return 0;
}

GrViewerQueryInfo query_subcmds[] = {
  {"current_time",	tcl_query_subcmd_current_time},
  {"event_time",	tcl_query_subcmd_event_time},
  {"pos",		tcl_query_subcmd_pos},
  {"spd",		tcl_query_subcmd_spd},
  {"rot",		tcl_query_subcmd_rot},
  {"omg",		tcl_query_subcmd_omg},
  {"x",			tcl_query_subcmd_x},
  {"y",			tcl_query_subcmd_y},
  {"z",			tcl_query_subcmd_z},
  {"lap",		tcl_query_subcmd_lap},
  {"speed",		tcl_query_subcmd_speed},
  {"rpm",		tcl_query_subcmd_rpm},
  {"gear",		tcl_query_subcmd_gear},

  {"-entry",		tcl_query_subcmd_entry},
  {NULL,	NULL},
};

static int
tcl_GrViewerQueryCmd (GrViewer *game,
		      Tcl_Interp *interp,
		      int objc,
		      Tcl_Obj *CONST objv[])
{
  int i;
  char *str;
  Tcl_HashEntry *entry;
  GrViewerQueryInfo *query;
  int res;

  for (i=1; i<objc; i++) {
    str = Tcl_GetStringFromObj (objv[i], NULL);
    if (!str) {
      goto ERROR;
    }

    entry = Tcl_FindHashEntry (&query_hash, str);
    if (!entry) {
      goto ERROR;
    }
    query = Tcl_GetHashValue (entry);
    res = (*query->func) (game, NULL, interp, objc-i, objv+i);
    if (res <= 0) {
      goto ERROR;
    }
    i += res;
  }
  return TCL_OK;

ERROR:
  Tcl_AppendResult (interp, ": wrong args. "
      "should be query {-entry <no> <subcmd> ...}",
      NULL);

  return TCL_ERROR;
}

static int
Tcl_GrViewerCmd (ClientData data,
    		 Tcl_Interp *interp,
		 int objc,
		 Tcl_Obj *CONST objv[])
{
  GlutObject obj = data;
  GrViewer *game = obj;
  GrVehicle *vehicle;
  GrVehicleData *vdata;
  char *str, *grc, *grs, *grv;
  FILE *file;
  GrScene *scene;
  GrObject *sobj;
  GrObjectDrawOption draw_option;
  int entry_no;
  GrViewerEntryInfo *gentry;
  Tcl_HashEntry *entry;
  Tcl_HashSearch search;
  int _new;
  int i;
  int res;
  double lf;
  int d;
  GrControl *control;
  char buf[2];

  if (objc < 2) {
    goto ERROR;
  }

  game = obj;

  str = Tcl_GetStringFromObj (objv[1], NULL);
  if (!strcmp (str, "control")) {
    if (!game->trace) {
      OBJ_RESULT (objv[0], ": you must specify trace entry before "
	  "quering maximum gear.");
      return TCL_ERROR;
    }
    vdata = game->trace->vehicle->data;
    control = &game->trace->vehicle->control;
    for (i=2; i<objc; ) {
      str = Tcl_GetStringFromObj (objv[2], NULL);
      if (!strcmp (str, "-steering") && i+1 < objc) {
	if (Tcl_GetDoubleFromObj (interp, objv[3], &lf) == TCL_ERROR) {
	  goto CTL_ERROR;
	}
	if (lf < -1) lf = -1;
	if (lf > 1) lf = 1;
	control->steering = lf;
	i+=2;
      } else if (!strcmp (str, "-footbreak") && i+1 < objc) {
	if (Tcl_GetDoubleFromObj (interp, objv[3], &lf) == TCL_ERROR) {
	  goto CTL_ERROR;
	}
	if (lf < 0) lf = 0;
	if (lf > 1) lf = 1;
	control->foot_break = lf;
	i+=2;
	i+=2;
      } else if (!strcmp (str, "-sidebreak") && i+1 < objc) {
	if (Tcl_GetDoubleFromObj (interp, objv[3], &lf) == TCL_ERROR) {
	  goto CTL_ERROR;
	}
	if (lf < 0) lf = 0;
	if (lf > 1) lf = 1;
	control->side_break = lf;
	i+=2;
	i+=2;
      } else if (!strcmp (str, "-accel") && i+1 < objc) {
	if (Tcl_GetDoubleFromObj (interp, objv[3], &lf) == TCL_ERROR) {
	  goto CTL_ERROR;
	}
	if (lf < 0) lf = 0;
	if (lf > 1) lf = 1;
	control->accel = lf;
	i+=2;
	i+=2;
      } else if (!strcmp (str, "-up")) {
	control->gear ++;
	if (control->gear >= vdata->engine->max_gear) {
	  control->gear = vdata->engine->max_gear - 1;
	}
	i++;
      } else if (!strcmp (str, "-down")) {
	control->gear --;
	if (control->gear < 0) {
	  control->gear = 0;
	}
	i++;
      } else if (!strcmp (str, "-gear")) {
	if (i+1 == objc ||
	    Tcl_GetIntFromObj (interp, objv[3], &d) == TCL_ERROR) {
	  d = game->trace->vehicle->data->engine->max_gear;
	  Tcl_SetObjResult (interp, Tcl_NewIntObj (d));
	  return TCL_OK;
	}
	if (lf < 0) lf = 0;
	if (lf >= game->trace->vehicle->data->engine->max_gear)
	  lf = game->trace->vehicle->data->engine->max_gear;
	control->gear = d;
	i+=2;
      } else {
CTL_ERROR:
	Tcl_SetObjResult (interp, objv[0]);
	Tcl_AppendResult (interp,
	    ": wrong sub command. should be -steering [-1:1], "
	    "-footbreak [0:1], -sidebreak [0:1], -accel [0:1], or "
	    "-gear [0:?].", NULL);
	return TCL_ERROR;
      }
    }
    return TCL_OK;

  } else if (!strcmp (str, "query")) {
    return tcl_GrViewerQueryCmd (game, interp, objc-1, objv+1);

  } else if (!strcmp (str, "trigger")) {
    Tcl_SetObjResult (interp, objv[0]);
    return tcl_GrViewerTrigger (game, interp, objc - 2, objv + 2);

  } else if (!strcmp (str, "configure")) {
    Tcl_SetObjResult (interp, objv[0]);
    return Tcl_GrViewerConfigure (interp, obj, objc-2, objv+2);

  } else if (!strcmp (str, "abort")) {
    /* do abort ... */

  } else if (!strcmp (str, "course")) {
    GrCourse *course;

    /* register course data ... */
    if (objc < 3) {
      OBJ_RESULT (objv[0], ": wrong # args. should course <grc url>.");
      return TCL_ERROR;
    }
    grc = strdup (Tcl_GetStringFromObj (objv[2], NULL));
    if (Tcl_VarEval (interp, "cache::get ", grc, NULL) == TCL_ERROR) {
      free (grc);
      return TCL_ERROR;
    }
    str = Tcl_GetStringResult (interp);

    course = tcl_GetCache (str);
    if (course) {
      gr_INCREF (course);
    } else {
      file = fopen (str, "r");
      if (!file) {
	OBJ_RESULT (objv[0], ": couldn't open grc file.");
	free (grc);
	return TCL_ERROR;
      }
      course = gr_course_new_from_file (file);
      fclose (file);
      if (!course) {
	OBJ_RESULT (objv[0], ": failed to read grc file.");
	free (grc);
	return TCL_ERROR;
      }

      tcl_PutCache (str, course);
    }

    grs = course->model;
    if (!grs) {
      OBJ_RESULT (objv[0], ": grc file does not include scene file url.");
      free (grc);
      return TCL_ERROR;
    }
    game->course = tcl_GetGrScene (interp, grs, grc);
    free (grc);

    if (!game->course) {
      OBJ_RESULT (objv[0], ": failed to read course scene file.");
      return TCL_ERROR;
    }

    gr_world_set_course (game->world, course);
    return TCL_OK;

  } else if (!strcmp (str, "entry")) {
    /* put vehicle in the game world ... */
    if (objc < 4) {
      OBJ_RESULT (objv[0],
	  ": wrong # args. should entry <no> <grv url>.");
      return TCL_ERROR;
    }
    if (Tcl_GetIntFromObj (interp, objv[2], &entry_no) == TCL_ERROR) {
      OBJ_RESULT (objv[0],
	  ": wrong arg. entry no. should be integer value.");
      return TCL_ERROR;
    }
    grv = strdup(Tcl_GetStringFromObj (objv[3], NULL));

    vdata = gr_get_vehicle_data (grv);
    if (!vdata) {
      OBJ_RESULT (objv[0], ": failed to read grs file.");
      return TCL_ERROR;
    }
    if (!vdata->model_url) {
      OBJ_RESULT (objv[0], ": scene file is not specified in grv file.");
      gr_DECREF (vdata);
      return TCL_ERROR;
    }

    vehicle = gr_vehicle_new (vdata);
    vehicle->scene = tcl_GetGrScene (interp, vdata->model_url, grv);

    if (!vehicle->scene) {
      OBJ_RESULT (objv[0], ": failed to read grs file.");
      free (grv);
      gr_DECREF (vehicle);
      return TCL_ERROR;
    }
    if (vdata->object_name) {
      vehicle->obj = gr_scene_find_object (vehicle->scene,
					   vdata->object_name, NULL);
      if (!vehicle->obj) {
	OBJ_RESULT (objv[0], ": couldn't find object of vehicle body.");
	free (grv);
	gr_DECREF (vehicle);
	return TCL_ERROR;
      }
    }

    for (i=0; i<vdata->num_wheel; i++) {
      if (vdata->wheel[i].model_url) {
	vehicle->wheel[i].scene = tcl_GetGrScene (interp, vdata->model_url,
						  grv);
	if (!vehicle->wheel[i].scene) {
	  OBJ_RESULT (objv[0], ": failed to read grs file.");
	  free (grv);
	  gr_DECREF (vehicle);
	  return TCL_ERROR;
	}
      }
      if (vdata->wheel[i].object_name) {
	if (vehicle->wheel[i].scene) {
	  scene = vehicle->wheel[i].scene;
	} else {
	  scene = vehicle->scene;
	}
	vehicle->wheel[i].obj = gr_scene_find_object (scene,
					  vdata->wheel[i].object_name, NULL);
	if (!vehicle->wheel[i].obj) {
	  OBJ_RESULT (objv[0], ": couldn't find object of wheel.");
	  free (grv);
	  gr_DECREF (vehicle);
	  return TCL_ERROR;
	}
      }
    }

    entry = Tcl_CreateHashEntry (&game->entry_hash,
				 (ClientData) entry_no, &_new);
    if (!_new) {
      gentry = Tcl_GetHashValue (entry);
      if (gentry->vehicle) {
	gr_DECREF (gentry->vehicle);
      }
    } else {
      gentry = gr_new0 (GrViewerEntryInfo, 1);
      if (!gentry) {
	OBJ_RESULT (objv[0], ": failed to allocate memory.");
	gr_DECREF (vehicle);
	return TCL_ERROR;
      }
      Tcl_SetHashValue (entry, gentry);
    }
    gentry->vehicle = vehicle;

#if 0
    /* set vehicle orientation */
    vehicle->body.state[0].quat.q0 = 1;
    vehicle->body.state[0].quat.q.f[0] = 0;
    vehicle->body.state[0].quat.q.f[1] = 0;
    vehicle->body.state[0].quat.q.f[2] = 0;
    vehicle->body.state[1].quat.q0 = 1;
    vehicle->body.state[1].quat.q.f[0] = 0;
    vehicle->body.state[1].quat.q.f[1] = 0;
    vehicle->body.state[1].quat.q.f[2] = 0;
#endif

    if (!gr_vehicle_put (gentry->vehicle, game->world->course_data, 0.0001,
			 MIN_INTERVAL, 10000)) {
      fprintf (stderr, "putting vehicle failed.\n");
    }
    gentry->no = entry_no;

    gr_INCREF (vehicle);
    gr_world_add_vehicle (game->world, vehicle);
    return TCL_OK;

  } else if (!strcmp (str, "sky")) {
    /* specify sky ... */
    if (objc < 3) {
      OBJ_RESULT (objv[0],
	  ": wrong # args. should sky <grs url>.");
      return TCL_ERROR;
    }
    grs = Tcl_GetStringFromObj (objv[2], NULL);
    scene = tcl_GetGrScene (interp, grs, NULL);
    if (!scene) {
      OBJ_RESULT (objv[0], ": failed to read grs file.");
      return TCL_ERROR;
    }
    if (game->sky) {
      gr_DECREF (game->sky);
    }
    game->sky = scene;
    return TCL_OK;

  } else if (!strcmp (str, "font")) {
    /* specify font ... */
    if (objc < 3) {
      OBJ_RESULT (objv[0],
	  ": wrong # args. should font <grs url>.");
      return TCL_ERROR;
    }
    grs = Tcl_GetStringFromObj (objv[2], NULL);
    scene = tcl_GetGrScene (interp, grs, NULL);
    if (!scene) {
      OBJ_RESULT (objv[0], ": failed to read grs file.");
      return TCL_ERROR;
    }
    if (game->font) {
      gr_DECREF (game->font);
    }
    game->font = scene;
    return TCL_OK;

  } else if (!strcmp (str, "rpm")) {
    /* specify rpm ... */
    if (objc < 3) {
      OBJ_RESULT (objv[0],
	  ": wrong # args. should rpm <grs url>.");
      return TCL_ERROR;
    }
    grs = Tcl_GetStringFromObj (objv[2], NULL);
    scene = tcl_GetGrScene (interp, grs, NULL);
    if (!scene) {
      OBJ_RESULT (objv[0], ": failed to read grs file.");
      return TCL_ERROR;
    }
    if (game->rpm) {
      gr_DECREF (game->rpm);
    }
    game->rpm = scene;
    return TCL_OK;

  } else if (!strcmp (str, "compile")) {
    if (game->course) {
      if (!game->dl) {
	game->dl = glGenLists (1);
      }
      gr_scene_setup_gl (game->course, game->draw_option);
      glNewList (game->dl, GL_COMPILE);
      glPushMatrix ();
      gr_scene_draw (game->course, NULL, game->draw_option, 1);
      glPopMatrix ();
      glEndList ();
    }

    if (game->sky) {
      if (!game->sky_dl) {
	game->sky_dl = glGenLists (1);
      }
      gr_scene_setup_gl (game->sky, game->draw_option);
      glNewList (game->sky_dl, GL_COMPILE);
      draw_option = game->draw_option & ~GR_OBJECT_NORMAL;
      glPushMatrix ();
      gr_scene_draw (game->sky, NULL, draw_option, 1);
      glPopMatrix ();
      glEndList ();
    }

    if (game->font) {
      if (!game->lfont_dl) {
	GL_CHECK(game->lfont_dl = glGenLists (128));
      }
      if (!game->sfont_dl) {
	GL_CHECK(game->sfont_dl = glGenLists (128));
      }
      /* make invisible font boundary information */
      sobj = gr_scene_find_object (game->font, "frame", NULL);
      while (sobj) {
	sobj->draw_option = 0;
	sobj = gr_scene_find_object (game->font, "frame", sobj);
      }

      draw_option = game->draw_option &
		    ~GR_OBJECT_COLOR &
		    ~GR_OBJECT_MATERIAL &
		    ~GR_OBJECT_NORMAL &
		    ~GR_OBJECT_SMOOTH;

      gr_scene_setup_gl (game->font, draw_option);

      buf[1] = '\0';
      for (i=0; i<128; i++) {
	buf[0] = i;
	sobj = gr_scene_find_object (game->font, buf, NULL);
	if (!sobj)
	  continue;

	/* LARGE FONT */
	gr_object_scale (sobj, LFONT_SIZE, LFONT_SIZE, LFONT_SIZE, 1);
	glNewList (game->lfont_dl + i, GL_COMPILE);
	glPushMatrix ();
	gr_object_draw (sobj, draw_option, 1);
	glPopMatrix ();
	glTranslatef (LFONT_WIDTH, 0, 0);
	glEndList ();

	gr_object_scale (sobj, 1.0 / LFONT_SIZE * SFONT_SIZE,
			       1.0 / LFONT_SIZE * SFONT_SIZE,
			       1.0 / LFONT_SIZE * SFONT_SIZE, 1);

	/* SMALL FONT */
	glNewList (game->sfont_dl + i, GL_COMPILE);
	glPushMatrix ();
	gr_object_draw (sobj, draw_option, 1);
	glPopMatrix ();
	glTranslatef (SFONT_WIDTH, 0, 0);
	glEndList ();
	gr_object_scale (sobj, 1.0/SFONT_SIZE,
			       1.0/SFONT_SIZE,
			       1.0/SFONT_SIZE, 1);
      }
    }

    draw_option = game->draw_option &
//		  ~GR_OBJECT_NORMAL &
		  ~GR_OBJECT_SMOOTH;
    if (game->rpm) {
      if (!game->rpm_measure_dl) {
	game->rpm_measure_dl = glGenLists (1);
      }
      if (!game->rpm_arrow_dl) {
	game->rpm_arrow_dl = glGenLists (1);
      }
      gr_scene_setup_gl (game->rpm, game->draw_option);

      obj = gr_scene_find_object (game->rpm, "measure_group", NULL);
      glNewList (game->rpm_measure_dl, GL_COMPILE);
      glPushMatrix ();
      gr_scene_draw (game->rpm, obj, draw_option, 1);
      glPopMatrix ();
      glEndList ();

      obj = gr_scene_find_object (game->rpm, "arrow_group", NULL);
      glNewList (game->rpm_arrow_dl, GL_COMPILE);
      glPushMatrix ();
      gr_scene_draw (game->rpm, obj, draw_option, 1);
      glPopMatrix ();
      glEndList ();
    }

    GL_CHECK(game->laps_dl = glGenLists (1));

    entry = Tcl_FirstHashEntry (&game->entry_hash, &search);
    while (entry) {
      gentry = Tcl_GetHashValue (entry);
      if (!gentry) {
	Tcl_DeleteHashEntry (entry);
	continue;
      }
      vehicle = gentry->vehicle;

      if (!vehicle->dl)
	vehicle->dl = glGenLists (1);
      gr_scene_setup_gl (vehicle->scene, game->draw_option);
      glNewList (vehicle->dl, GL_COMPILE);
      glPushMatrix ();
      gr_scene_draw (vehicle->scene, vehicle->obj, game->draw_option, 1);
      glPopMatrix ();
      glEndList ();

      for (i=0; i<vehicle->data->num_wheel; i++) {
	if (!vehicle->wheel[i].dl) {
	  vehicle->wheel[i].dl = glGenLists (1);
	}
	if (vehicle->wheel[i].scene) {
	  gr_scene_setup_gl (vehicle->wheel[i].scene, game->draw_option);
	  glNewList (vehicle->wheel[i].dl, GL_COMPILE);
	  glPushMatrix ();
	  gr_scene_draw (vehicle->wheel[i].scene,
			 vehicle->wheel[i].obj, game->draw_option, 1);
	  glPopMatrix ();
	} else {
	  glNewList (vehicle->wheel[i].dl, GL_COMPILE);
	  glPushMatrix ();
	  gr_object_draw (vehicle->wheel[i].obj, game->draw_option, 1);
	  glPopMatrix ();
	}
	glEndList ();
      }

      entry = Tcl_NextHashEntry (&search);
    }
    return TCL_OK;

  } else if (!strcmp (str, "trace")) {
    if (objc == 2) {
      game->trace = NULL;
    } else {
      if (Tcl_GetIntFromObj (interp, objv[2], &d) == TCL_ERROR) {
	OBJ_RESULT (objv[0], ": wrong args. entry num must be interger value.");
	return TCL_ERROR;
      }

      entry = Tcl_FindHashEntry (&game->entry_hash, (ClientData) d);
      if (!entry) {
	Tcl_SetObjResult (interp, objv[0]);
	Tcl_AppendResult (interp, ": entry no ",
			  Tcl_GetStringFromObj (objv[2], NULL),
			  " is not registered.");
	return TCL_ERROR;
      }
      game->trace = Tcl_GetHashValue (entry);
    }

    return TCL_OK;

  } else if (!strcmp (str, "overhead")) {
    for (i=2; i<objc;) {
      str = Tcl_GetStringFromObj (objv[i], NULL);
      if (!strcmp (str, "-xpan") && i+1<objc) {
	TCL_CHECK (Tcl_GetDoubleFromObj (interp, objv[i+1], &lf), OH_ERROR);
	game->projection_info.overhead.xpan
	  = lf + game->trace->vehicle->data->cockpit_height;
	i+=2;
	continue;
      } else if (!strcmp (str, "-xmax") && i+1<objc) {
	TCL_CHECK (Tcl_GetDoubleFromObj (interp, objv[i+1], &lf), OH_ERROR);
	game->projection_info.overhead.xmax = lf;
	i+=2;
	continue;
      } else if (!strcmp (str, "-zmax") && i+1<objc) {
	TCL_CHECK (Tcl_GetDoubleFromObj (interp, objv[i+1], &lf), OH_ERROR);
	game->projection_info.overhead.zmax = lf;
	i+=2;
	continue;
      } else if (!strcmp (str, "-far") && i+1<objc) {
	TCL_CHECK (Tcl_GetDoubleFromObj (interp, objv[i+1], &lf), OH_ERROR);
	game->projection_info.overhead.far = lf;
	i+=2;
	continue;
      } else {
OH_ERROR:
	OBJ_RESULT (objv[0], ": wrong args. should overhead -xpan <d>, "
	    	"-xmax <d>, -zmax <d>, -cockpit <d>,  -far <d>, or "
		"-trace <entry>");
	return TCL_ERROR;
      }
    }
    glut_game_overhead_reshape (obj, screen_width, screen_height);

    return TCL_OK;

  } else if (!strcmp (str, "lap")) {
    /* specify how many lap ... */
    if (objc < 3) {
      OBJ_RESULT (objv[0],
	  ": wrong # args. should lap <num>.");
      return TCL_ERROR;
    }
    if (Tcl_GetIntFromObj (interp, objv[2], &d) == TCL_ERROR) {
      OBJ_RESULT (objv[0],
	  ": wrong arg. maximum lap should be integer value.");
      return TCL_ERROR;
    }
    game->max_lap = d;
    return TCL_OK;

  } else if (!strcmp (str, "start")) {
    game->current_time = gr_get_current_time ();
    game->start_time = game->current_time;
    game->world->current_time = 0;
    game->world->previous_time = 0;

    entry = Tcl_FirstHashEntry (&game->entry_hash, &search);
    while (entry) {
      gentry = Tcl_GetHashValue (entry);
      if (!gentry)
	continue;
      vehicle = gentry->vehicle;
      vehicle->prev_laptime = game->current_time;

      entry = Tcl_NextHashEntry (&search);
    }

    /* FIX ME */
    /* sound function must be implemented as tcl command. */

    if (game->use_audio) {
      res = Tcl_VarEval (interp, "cache::get sounds/exhaust.au", NULL);
      if (res != TCL_ERROR) {
	str = Tcl_GetStringResult (interp);
	game->exhaust = gr_sample_new (str);
	if (game->exhaust) {
	  gr_sample_adjust_volume (game->exhaust, 0.05);
	  gr_sample_loop (game->exhaust, 0);
	  game->exhaust_freq = gr_envelope_new (1, GR_SAMPLE_LOOP);
	  gr_envelope_set_step (game->exhaust_freq, 0, 1.0, 1.0);
	  gr_sample_add_envelope (game->exhaust, 0, 0,
				  game->exhaust_freq, GR_ENVELOPE_PITCH);
	}
      }
      res = Tcl_VarEval (interp, "cache::get sounds/slip.au", NULL);
      if (res != TCL_ERROR) {
	str = Tcl_GetStringResult (interp);
	game->slip = gr_sample_new (str);
	if (game->slip) {
	  gr_sample_adjust_volume (game->slip, 0.05);
	  gr_sample_loop (game->slip, 0);
	  gr_sample_pause (game->slip, 0);
	}
      }
    }

    return TCL_OK;
  }

ERROR:
  OBJ_RESULT (objv[0], ": wrong # args. should ...");
  return TCL_ERROR;
}

static void
glut_game_destroy (GlutObject obj)
{
  GrViewer *game = obj;
  GrViewerEntryInfo *gentry;
  Tcl_HashEntry *entry;
  Tcl_HashSearch search;
  int i;
  GrVehicle *vehicle;
  GrTrigger *trigger;

  Tcl_DeleteCommandFromToken (game->interp, game->token);

  if (game->world)
    gr_DECREF (game->world);

  if (game->dl) {
    glDeleteLists (game->dl, 1);
  }
  if (game->course) {
    gr_scene_release_gl (game->course);
    gr_DECREF (game->course);
  }
  if (game->sky_dl) {
    glDeleteLists (game->sky_dl, 1);
  }
  if (game->sky) {
    gr_scene_release_gl (game->sky);
    gr_DECREF (game->sky);
  }

  if (game->rpm_measure_dl) {
    glDeleteLists (game->rpm_measure_dl, 1);
  }
  if (game->rpm_arrow_dl) {
    glDeleteLists (game->rpm_arrow_dl, 1);
  }
  if (game->rpm) {
    gr_scene_release_gl (game->rpm);
    gr_DECREF (game->rpm);
  }
  if (game->lfont_dl) {
    glDeleteLists (game->lfont_dl, 128);
  }
  if (game->sfont_dl) {
    glDeleteLists (game->sfont_dl, 128);
  }
  if (game->font) {
    gr_scene_release_gl (game->font);
    gr_DECREF (game->font);
  }

  entry = Tcl_FirstHashEntry (&game->entry_hash, &search);
  while (entry) {
    gentry = Tcl_GetHashValue (entry);
    if (!gentry)
      continue;

    vehicle = gentry->vehicle;
    for (i=0; i<vehicle->data->num_wheel; i++) {
      if (vehicle->wheel[i].dl) {
	glDeleteLists (vehicle->wheel[i].dl, 1);
      }
      if (gentry->vehicle->wheel[i].scene) {
	gr_scene_release_gl (gentry->vehicle->wheel[i].scene);
      }
    }
    if (gentry->vehicle->dl) {
      glDeleteLists (gentry->vehicle->dl, 1);
    }
    if (gentry->vehicle->scene) {
      gr_scene_release_gl (gentry->vehicle->scene);
    }
    gr_DECREF (vehicle);

    entry = Tcl_NextHashEntry (&search);
  }
  Tcl_DeleteHashTable (&game->entry_hash);

  entry = Tcl_FirstHashEntry (&game->trigger_hash, &search);
  while (entry) {
    trigger = Tcl_GetHashValue (entry);
    if (!trigger)
      continue;
    gr_DECREF (trigger);
    entry = Tcl_NextHashEntry (&search);
  }
  Tcl_DeleteHashTable (&game->trigger_hash);

  if (game->use_audio) {
    gr_sample_stop (game->exhaust, 0);
    gr_sample_stop (game->slip, 0);
    gr_sound_update ();

  /* FIX ME */
  //gr_sample_free (game->exhaust);
  //gr_envelope_free (game->exhaust_freq);
  }

  glut_root_destroy (obj);
}


static void
glut_game_overhead_view (GlutObject obj)
{
  GrViewer *game = obj;
  GrViewerOverheadInfo *info = &game->projection_info.overhead;
  GrVehicle *vehicle;
  double dangle;

  if (!game->trace || !game->trace->vehicle)
    return;

  vehicle = game->trace->vehicle;

  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  glFrustum (info->left, info->right, info->bottom, info->top,
	     info->near, info->far);
  glMatrixMode (GL_MODELVIEW);
  glLoadIdentity ();
  glRotatef (-80, 1, 0, 0);
  glRotatef (90, 0, 0, 1);
  GL_CHECK(glTranslatef (info->xpan, 0, -info->zpan));

  dangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[0], info->xangle);
  info->xangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[0],
				   0.7 * dangle);

  dangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[1], info->yangle);
  info->yangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[1],
				   0.7 * dangle);

  dangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[2], info->zangle);
  info->zangle = gr_angle_sub_rad (vehicle->body.state[0].rot.f[2],
				   0.7 * dangle);

  GL_CHECK(glRotatef (-DEG(info->yangle), 0, -1, 0));
  GL_CHECK(glRotatef (-DEG(info->xangle), -1, 0, 0));

  GL_CHECK(glTranslatef (- vehicle->data->cockpit.c.x,
			 - vehicle->data->cockpit.c.y,
			 - (vehicle->data->cockpit.c.z
			     - vehicle->data->cockpit_height)));

  GL_CHECK(glRotatef (DEG(info->xangle), -1, 0, 0));
  GL_CHECK(glRotatef (DEG(info->yangle), 0, -1, 0));
  GL_CHECK(glRotatef (DEG(info->zangle), 0, 0, -1));

  if (game->use_texture && game->show_sky) {
    GL_CHECK(glDisable (GL_LIGHTING));
    GL_CHECK(glDisable (GL_DEPTH_TEST));
    GL_CHECK(glCallList (game->sky_dl));
    GL_CHECK(glEnable (GL_LIGHTING));
    GL_CHECK(glEnable (GL_DEPTH_TEST));
  }

  GL_CHECK(glTranslatef (-vehicle->body.state[0].pos.f[0],
			 -vehicle->body.state[0].pos.f[1],
			 -vehicle->body.state[0].pos.f[2]));
}

static void
glut_game_overhead_reshape (GlutObject obj, int width, int height)
{
  GrViewer *game = obj;
  GrViewerOverheadInfo *info = &game->projection_info.overhead;
  float aspect;

  if (game->trace && game->trace->vehicle) {
    info->near = game->trace->vehicle->data->cockpit_height;
    aspect = ((double)(screen_height)) / screen_width;
    info->left = -0.5 * info->near;
    info->right = 0.5 * info->near;
    info->bottom = -0.4 * info->near;
    info->top = info->near * aspect + info->bottom;

    info->zpan = info->zmax * info->xpan / info->xmax + info->near;
  }
}

static void
glut_game_simulate (double interval, GrViewer *game) {
  gr_world_do_simulate (game->world, interval);

#if 0
  Tcl_HashSearch search;
  Tcl_HashEntry *entry;
  int i, loop;
  GrVehicle *vehicle;
  GrViewerEntryInfo *gentry;
  GrLapHistory *lap;

  loop = ceil (interval / (MIN_INTERVAL * 2.0));
  interval = interval / (loop * 2);

  entry = Tcl_FirstHashEntry (&game->entry_hash, &search);
  while (entry) {
    gentry = Tcl_GetHashValue (entry);
    if (gentry && gentry->vehicle) {
      vehicle = gentry->vehicle;

      for (i=0; i<loop; i++) {
	gr_vehicle_integral (vehicle, game->course_data, 0, 1, interval);
	gr_vehicle_integral (vehicle, game->course_data, 1, 0, interval);
      }

      vehicle->cinfo.prev = vehicle->cinfo.current;
      vehicle->cinfo.current.pos = vehicle->body.state[0].pos;
      gr_course_check_control_line (game->course_data, &vehicle->cinfo);

      switch (vehicle->cinfo.res) {
      case GR_CLINE_A_TO_B:
	vehicle->lap_count ++;
	if (vehicle->lap < vehicle->lap_count) {
	  lap = gr_new (GrLapHistory, 1);
	  lap->next = vehicle->laphistory;
	  lap->lap = vehicle->lap;
	  vehicle->lap = vehicle->lap_count;
	  lap->time = (game->current_time - game->prev_time)
			* vehicle->cinfo.cross_ratio + game->prev_time;
	  lap->laptime = lap->time - vehicle->prev_laptime;
	  vehicle->prev_laptime = lap->time;

						      /* CHECK IF BESTLAP */
	  if (!vehicle->bestlap || lap->laptime < vehicle->bestlap->laptime) {
	    vehicle->bestlap = lap;
	  }

	  vehicle->laphistory = lap;
	}
	break;

      case GR_CLINE_B_TO_A:
	vehicle->lap_count --;
	break;

      default:
      }
    }
    entry = Tcl_NextHashEntry (&search);
  }
#endif
}

void draw_font (void *font);

static void
glut_game_display (GlutObject obj)
{
  GrViewer *game = obj;
  Tcl_HashSearch search;
  Tcl_HashEntry *entry;
  GrViewerEntryInfo *gentry;
  GrVehicle *vehicle;
  int i;
  float scale;
  float slip;
  double time;
  double interval;
//  float angle, x, y, z;

  time = gr_get_current_time ();
  interval = time - game->current_time;
  game->current_time = time;

  glut_game_simulate (interval, game);

  GL_CHECK(glPushAttrib (GL_CURRENT_BIT));

  (* game->projection_func)(game);

  GL_CHECK(glCallList (game->dl));

  entry = Tcl_FirstHashEntry (&game->entry_hash, &search);
  while (entry) {
    gentry = Tcl_GetHashValue (entry);
    if (gentry && gentry->vehicle) {
      vehicle = gentry->vehicle;

      GL_CHECK(glPushMatrix ());
      GL_CHECK(glTranslatef (vehicle->body.state[0].pos.f[0],
			     vehicle->body.state[0].pos.f[1],
			     vehicle->body.state[0].pos.f[2]));
#if 0
      gr_quaternion_make_rotation_axis (&vehicle->body.state[0].quat,
	  				&angle, &x, &y, &z);
      GL_CHECK(glRotatef (DEG(angle), x, y, z));
      printf ("Axis:%f %f %f %f\n", angle, x, y, z);
#else
      GL_CHECK(glRotatef (DEG(vehicle->body.state[0].rot.f[2]), 0, 0, 1));
      GL_CHECK(glRotatef (DEG(vehicle->body.state[0].rot.f[1]), 0, 1, 0));
      GL_CHECK(glRotatef (DEG(vehicle->body.state[0].rot.f[0]), 1, 0, 0));
#endif

      for (i=0; i<vehicle->data->num_wheel; i++) {
	GL_CHECK(glPushMatrix ());
	GL_CHECK(glTranslatef (vehicle->data->wheel[i].pos.f[0],
			       vehicle->data->wheel[i].pos.f[1],
			       vehicle->data->wheel[i].pos.f[2]));

	scale = vehicle->wheel[i].state[0].ds;
	GL_CHECK(glTranslatef (vehicle->data->wheel[i].susp.f[0] * scale,
			       vehicle->data->wheel[i].susp.f[1] * scale,
			       vehicle->data->wheel[i].susp.f[2] * scale));

#if 0
	/* SHOW VARIOUS VECTOR */
	if (vehicle->wheel[i].state[0].surf) {
	  glDisable (GL_LIGHTING);
	  glBegin (GL_LINES);
	  glColor3f (1, 0, 0);
	  glVertex3f (0, 0, 0);
	  glVertex3f (vehicle->wheel[i].state[0].grip.c.x,
		      vehicle->wheel[i].state[0].grip.c.y,
		      vehicle->wheel[i].state[0].grip.c.z);
	  glColor3f (0, 1, 0);
	  glVertex3f (0, 0, 0);
	  glVertex3f (vehicle->wheel[i].state[0].speed.c.x,
		      vehicle->wheel[i].state[0].speed.c.y,
		      vehicle->wheel[i].state[0].speed.c.z);
	  glColor3f (0, 0, 1);
	  glVertex3f (0, 0, 0);
	  glVertex3f (vehicle->wheel[i].state[0].force.c.x,
		      vehicle->wheel[i].state[0].force.c.y,
		      vehicle->wheel[i].state[0].force.c.z);
	  glEnd ();
	  glEnable (GL_LIGHTING);
	}
#endif
	if (vehicle->data->wheel[i].flag & GR_WHEEL_STEERING) {
	  GL_CHECK(glRotatef (DEG(vehicle->wheel[i].control.angle),
			      vehicle->data->wheel[i].susp.f[0],
			      vehicle->data->wheel[i].susp.f[1],
			      vehicle->data->wheel[i].susp.f[2]));
	}
	GL_CHECK(glCallList (vehicle->wheel[i].dl));
	GL_CHECK(glPopMatrix ());
      }

      GL_CHECK(glCallList (vehicle->dl));

      GL_CHECK(glPopMatrix ());
    }
    entry = Tcl_NextHashEntry (&search);
  }

  GL_CHECK(glPopAttrib ());

  glut_game_draw_panel (obj);

  /* FIX ME */
  if (game->trace) {
    vehicle = game->trace->vehicle;
    gr_envelope_set_step (game->exhaust_freq, 0, 1.0,
			  vehicle->state[0].rpm / 2000);

    if (vehicle->data->num_wheel > 0) {
      slip = vehicle->wheel[0].state[0].slip;
      for (i=1; i<vehicle->data->num_wheel; i++) {
	if (slip < vehicle->wheel[i].state[0].slip) {
	  slip = vehicle->wheel[i].state[0].slip;
	}
      }
      if (game->use_audio) {
	if (slip > 0.15 && !game->slip_playing) {
	  gr_sample_resume (game->slip, 0);
	  game->slip_playing = 1;
	  //printf ("start slip sound\n");
	} else if (slip <= 0.15 && game->slip_playing) {
	  gr_sample_pause (game->slip, 0);
	  game->slip_playing = 0;
	  //printf ("stop slip sound\n");
	}
      }
    }
  }
}

static void
gl_draw_string (GLuint dl, char *str)
{
  int i;

  for (i=0; str[i] != '\0'; i++) {
    glCallList (dl + str[i]);
  }
}

static void
gl_draw_string_r (GLuint dl, char *str, float size)
{
  int len;

  len = strlen (str);
  glTranslatef (-size * len, 0, 0);
  gl_draw_string (dl, str);
}

static void
glut_game_draw_panel (GlutObject obj) {
  GrViewer *game = obj;
  double top = 2.0 * screen_height / screen_width;
  char buf[256];
  int i;
  double speed;
  GrVehicle *vehicle;
  GrLapHistory *lap;
  double engine_rpm, angle, dangle;
  int gear;

  GR_BEGIN_FUNCTION ();

  GL_CHECK(glPushAttrib (GL_CURRENT_BIT | GL_ENABLE_BIT));

  GL_CHECK(glMatrixMode (GL_PROJECTION));
  GL_CHECK(glLoadIdentity ());
  GL_CHECK(glOrtho (-1, 1, 0, top, -10, 10));
  GL_CHECK(glMatrixMode (GL_MODELVIEW));
  GL_CHECK(glLoadIdentity ());

  GL_CHECK(glDisable (GL_DEPTH_TEST));
  GL_CHECK(glDisable (GL_TEXTURE_2D));
  GL_CHECK(glEnable (GL_LIGHTING));
  GL_CHECK(glEnable (GL_LIGHT0));
  GL_CHECK(glEnable (GL_COLOR_MATERIAL));

  if (game->trace) {
    vehicle = game->trace->vehicle;

    /*
     * SPEED [km/h]
     */

    /* [m/sec] */
    speed = gr_vertex_length (&vehicle->body.state[0].spd);
    
    /* [km/h] */
    speed *= 3600.0 / 1000;

    sprintf (buf, "%03d", (int)(speed));

    GL_CHECK(glPushMatrix ());
    {
      GL_CHECK(glTranslatef (0.55, 0.10, 0));
      GL_CHECK(glColor3f (1.0, 1.0, 1.0));
      gl_draw_string (game->lfont_dl, buf);
    }
    GL_CHECK(glPopMatrix ());

    if (0 && game->lap_changed) {
      GL_CHECK(glCallList (game->laps_dl));
    } else {
#if 0
      GL_CHECK(glNewList (game->laps_dl, GL_COMPILE_AND_EXECUTE));
#endif

      /*
       * LAPS TO GO
       */
      if (game->max_lap - vehicle->lap <= 1) {
	sprintf (buf, "FINAL LAP");
      } else {
	sprintf (buf, "L%d TO GO", game->max_lap - vehicle->lap);
      }
      GL_CHECK(glPushMatrix ());
      {
	GL_CHECK(glTranslatef (1.0, top - 0.08, 0));
	GL_CHECK(glColor3f (1.0, 1.0, 1.0));
	gl_draw_string_r (game->sfont_dl, buf, SFONT_WIDTH);
      }
      GL_CHECK(glPopMatrix ());

      /*
       * LAP TIME
       */
      GL_CHECK(glPushMatrix ());
      {
	sprintf (buf, "%.2f", game->current_time - vehicle->prev_laptime);
	GL_CHECK(glTranslatef (0.15, top - LFONT_HEIGHT, 0));
	GL_CHECK(glColor3f (1.0, 1.0, 1.0));
	gl_draw_string_r (game->lfont_dl, buf, LFONT_WIDTH);
      }
      GL_CHECK(glPopMatrix ());

      /*
       * THE BEST LAP
       */
      if (vehicle->bestlap) {
	GL_CHECK(glPushMatrix ());
	{
	  GL_CHECK(glTranslatef (1.0, top - 0.18, 0));
	  GL_CHECK(glPushMatrix ());
	  {
	    GL_CHECK(glColor3f (1.0, 1.0, 1.0));
	    gl_draw_string_r (game->sfont_dl, "BEST LAP", SFONT_WIDTH);
	  }
	  GL_CHECK(glPopMatrix ());

	  GL_CHECK(glTranslatef (0, -SFONT_HEIGHT, 0));
	  sprintf (buf, "%d: %.3f",
		  vehicle->bestlap->lap + 1, vehicle->bestlap->laptime);
	  gl_draw_string_r (game->sfont_dl, buf, SFONT_WIDTH);
	}
	GL_CHECK(glPopMatrix ());
      }

      /*
       * LAP HISTORY
       */
      GL_CHECK(glPushMatrix ());
      {
	GL_CHECK(glTranslatef (-0.98, top - LFONT_HEIGHT, 0));

	lap = vehicle->laphistory;
	for (i=0; i < 9 && lap; i++, lap=lap->next) {
	  sprintf (buf, "%2d: %.3f", lap->lap + 1, lap->laptime);

	  GL_CHECK(glTranslatef (0, -SFONT_HEIGHT, 0));
	  GL_CHECK(glPushMatrix ());
	  {
	    if (vehicle->bestlap == lap) {
	      GL_CHECK(glColor3f (1.0, 0.5, 0.0));
	    } else {
	      GL_CHECK(glColor3f (1.0, 1.0, 1.0));
	    }
	    gl_draw_string (game->sfont_dl, buf);
	  }
	  GL_CHECK(glPopMatrix ());
	}
      }
      GL_CHECK(glPopMatrix ());

#if 0
      GL_CHECK(glEndList ());
      game->lap_changed = 0;
#endif
    }

    /*
     * GEAR
     */

    gear = vehicle->control.gear;
    engine_rpm = vehicle->state[0].rpm;

    angle = RPM_ANGLE * engine_rpm / vehicle->data->engine->limit;
    if (angle < 0) angle = 0;

    dangle = gr_angle_sub_deg (angle, game->rpm_angle);
    game->rpm_angle = gr_angle_add_deg (angle, - 0.7 * dangle);

    GL_CHECK(glPushMatrix ());
    {
      GL_CHECK(glTranslatef (-0.55, 0.1, 0));
      GL_CHECK(glColor3f (1.0, 1.0, 1.0));
      buf[0] = '1' + gear;
      buf[1] = '\0';
      gl_draw_string (game->lfont_dl, buf);
    }
    GL_CHECK(glPopMatrix ());

    /*
     * RPM meter
     */

    //printf ("%f %f\n", speed, vehicle->state[0].rpm);
    GL_CHECK(glPushMatrix ());
    {
      GL_CHECK(glTranslatef (-0.6, 0.3, 0));
      GL_CHECK(glPushMatrix ());
      {


	GL_CHECK(glRotatef (game->rpm_angle, 0, 0, -1));
	GL_CHECK(glCallList (game->rpm_arrow_dl));
      }
      GL_CHECK(glPopMatrix ());

      GL_CHECK(glCallList (game->rpm_measure_dl));
    }
    GL_CHECK(glPopMatrix ());
  }

  GL_CHECK (glPopAttrib ());
}

static void
glut_game_init (Tcl_Interp *interp, GlutObject obj)
{
  GrViewer *game = obj;

  glut_root_init (obj);
  
  gr_FREE_FUNC (obj, glut_game_destroy);

  game->core.type = GR_GLUT_ROOT_GAME;

  game->core.display_func = glut_game_display;

  game->world = gr_world_new ();
  game->interp = interp;

  game->zpan = -0.5;
  game->xangle = -90.0;
  game->zangle = 90.0;

  game->use_texture = 1;
  game->use_mipmap = 1;
  game->use_linear = 1;
  game->use_shading = 1;
  game->show_sky = 1;
  game->show_decr = 1;
  game->use_audio = 1;
  game->draw_option = GR_OBJECT_ALL;

  game->projection_func = glut_game_overhead_view;
  game->core.reshape_func = glut_game_overhead_reshape;

  game->projection_info.overhead.xmax = 400;
  game->projection_info.overhead.zmax = 50;
  game->projection_info.overhead.xpan = 2.0;
  game->projection_info.overhead.zpan = 2.0;
  game->projection_info.overhead.left = -1.0;
  game->projection_info.overhead.right = 1.0;
  game->projection_info.overhead.top = 1.0;
  game->projection_info.overhead.bottom = -1.0;
  game->projection_info.overhead.near = 2.0;
  game->projection_info.overhead.far = 1000.0;


  Tcl_InitHashTable (&game->entry_hash, TCL_ONE_WORD_KEYS);
  Tcl_InitHashTable (&game->trigger_hash, TCL_ONE_WORD_KEYS);
}

static int
Tcl_GrViewerCreateCmd (ClientData data,
		      Tcl_Interp *interp,
		      int objc,
		      Tcl_Obj *CONST objv[])
{
  char *str;
  GlutObject obj;
  GlutRoot *root;
  GrViewer *game;
  int res;

  Tcl_SetObjResult (interp, objv[0]);

  if (objc < 2) {
    Tcl_AppendResult (interp, ": wrong # args. should be <name> ...", NULL);
    return TCL_ERROR;
  }

  obj = gr_new0 (GrViewer, 1);
  root = obj;
  game = obj;
  glut_game_init (interp, obj);

  res = Tcl_GrViewerConfigure (interp, obj, objc-2, objv+2);
  if (res == TCL_ERROR) {
    gr_DECREF (obj);
    return TCL_ERROR;
  }

  str = Tcl_GetStringFromObj (objv[1], NULL);
  if (Tcl_GlutWidgetInsertHash (interp, obj, str) == TCL_ERROR) {
    gr_DECREF (obj);
    return TCL_ERROR;
  }

  game->token = Tcl_CreateObjCommand (interp, str, Tcl_GrViewerCmd, obj, NULL);
  game->interp = interp;

  return TCL_OK;
}

int
GrViewer_Init (Tcl_Interp *interp)
{
  static int do_init = 1;
  int i;
  Tcl_HashEntry *entry;
  int _new;

  if (do_init) {
    do_init = 0;

    obj_time = Tcl_NewStringObj ("LAPTIME", 7);
    obj_lap = Tcl_NewStringObj ("LAP", 3);
    obj_speed = Tcl_NewStringObj ("SPEED", 5);
    obj_rpm = Tcl_NewStringObj ("RPM", 3);
    obj_entry = Tcl_NewStringObj ("ENTRY", 5);

    Tcl_InitHashTable (&query_hash, TCL_STRING_KEYS);
    for (i=0; query_subcmds[i].name != NULL; i++) {
      entry = Tcl_CreateHashEntry (&query_hash, query_subcmds[i].name, &_new);
      if (!entry) {
	Tcl_AppendResult (interp, "GrViewer_Init: failed to create hash entry.",
			  NULL);
	return TCL_ERROR;
      }
      Tcl_SetHashValue (entry, (ClientData) (query_subcmds + i));
    }
  }

  Tcl_CreateObjCommand (interp, "glutgame",
      			Tcl_GrViewerCreateCmd, NULL, NULL);

  return TCL_OK;
}