HGKeeper

#include <assert.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include "cc_interface.h"

#include "crazychat.h"

#include "Utilities.h"

#include "QTUtilities.h"

#include "camdata.h"

#include "camproc.h"

#include "util.h"

#include <unistd.h>

#ifdef __APPLE_CC__

#include <Carbon/Carbon.h>

#else

#include <Carbon.h>

#endif

/* temporarily including for development testing */

#include "cc_gtk_gl.h"

/* hard coding the webcam dimensions: BAD, but we're not probing hardware yet */

#define WEBCAM_X 644 /* webcam's x dim */

#define WEBCAM_Y 480 /* webcam's y dim */

/* default webcam timer callback delay */

#define WEBCAM_CALLBACK_DELAY 40 /* in ms */

int x_click, y_click;

int mode_change=0;

struct input_instance input_data;

/* move this to input_instance eventually */

UInt32 colorBuf[WEBCAM_Y][WEBCAM_X];

unsigned int (*colorBuf)[640];

int detection_mode=0;

int draw_mode=0; //0=pixels, 1=face

int easter_count;

static void *kickstart(void *data);

static void *facefind(void *data);

/**

* Resets the OpenGL viewport stuff on widget reconfiguration (resize,

* reposition)

* @param widget widget that got reconfigured

* @param event the configuration event

* @param data unused

* @return TRUE ( i don't know what FALSE would do )

static gboolean config_wrapper(GtkWidget *widget, GdkEventConfigure *event,

void *data);

/**

* Debug features test. Draws pixels directly to the frame buffer.

* @param widget widget that we're drawing

* @param event the draw event

* @param data array of pixels

* @return DUNNO

static gboolean mydraw(GtkWidget *widget, GdkEventExpose *event,

void *data);

/**

* Periodically querys the webcam for more data.

* @param instance webcam input instance data

* @return TRUE to stop other handler, FALSE to continue

static gboolean webcam_cb(struct input_instance *instance);

/**

* Init window code, adding our click callback.

* @param widget the window we clicked in

* @param instance webcam input instance data

static void init_cb(GtkWidget *widget, struct input_instance *instance);

/**

* Click callback

* @param widget the window we clicked in

* @param event the button click event structure

* @param instance input instance data

* @return TRUE to stop other handler, FALSE to continue

static gboolean click_cb(GtkWidget *widget, GdkEventButton *event,

struct input_instance *instance);

/**

* Button callback

* @param button the button we clicked on

* @param instance input instance data

static void button_cb(GtkWidget *button, struct input_instance *instance);

/**

* Destroy callback. Called when the input processing window is destroyed.

* @param widget the window we clicked in

* @param cc crazychat global data structure

static void destroy_cb(GtkWidget *widget, struct crazychat *cc);

/**

* Set feature material.

* @param entry model selector combo box entry

* @param material pointer to material we're setting

static void material_set(GtkWidget *entry, guint8 *material);

struct input_instance *init_input(struct crazychat *cc)

{

/*pthread_t userinput_t; // should we put this in a nicer wrapper?*/

struct draw_info *info;

struct input_instance *instance;

info = (struct draw_info*)malloc(sizeof(*info));

assert(info);

memset(info, 0, sizeof(*info));

info->timeout = TRUE;

info->delay_ms = DEFAULT_FRAME_DELAY;

info->data = &input_data;

instance = (struct input_instance*)info->data;

memset(instance, 0, sizeof(*instance));

instance->output.features = &instance->face;

EnterMovies();

filter_bank *bank;

bank = Filter_Initialize();

assert(CamProc(instance, bank) == noErr); // change this prototype-> no windows

instance->timer_id = g_timeout_add(WEBCAM_CALLBACK_DELAY,

(GSourceFunc)webcam_cb, instance);

/* THREAD_CREATE(&userinput_t, facefind, instance); // is this being created correctly?*/

struct window_box ret;

cc_new_gl_window(init_cb, config_wrapper, mydraw,

info, &ret);

instance->widget = ret.window;

gtk_window_set_title(GTK_WINDOW(ret.window), "Local User");

instance->box = ret.vbox;

GtkWidget *label = gtk_label_new("Click your face");

instance->label = label;

gtk_box_pack_start(GTK_BOX(ret.vbox), label, FALSE, FALSE, 0);

gtk_box_reorder_child(GTK_BOX(ret.vbox), label, 0);

gtk_widget_show(label);

GtkWidget *button = gtk_button_new_with_label("Confirm");

gtk_box_pack_start(GTK_BOX(ret.vbox), button, FALSE, FALSE, 0);

g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(button_cb),

instance);

instance->button = button;

gtk_widget_show(button);

GtkWidget *hbox = gtk_hbox_new(TRUE, 0);

gtk_box_pack_start(GTK_BOX(ret.vbox), hbox, FALSE, FALSE, 0);

gtk_widget_show(hbox);

GList *glist = NULL;

glist = g_list_append(glist, "Dog");

glist = g_list_append(glist, "Shark");

instance->model = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(model_combo),

// 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->model, TRUE, TRUE, 0);

gtk_widget_show(instance->model);

glist = NULL;

glist = g_list_append(glist, "Red");

glist = g_list_append(glist, "Dark Brown");

glist = g_list_append(glist, "Light Brown");

glist = g_list_append(glist, "White");

glist = g_list_append(glist, "Green");

glist = g_list_append(glist, "Black");

instance->head = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(head_material_combo),

// 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->head, TRUE, TRUE, 0);

gtk_widget_show(instance->head);

glist = NULL;

glist = g_list_append(glist, "Red");

glist = g_list_append(glist, "Dark Brown");

glist = g_list_append(glist, "Light Brown");

glist = g_list_append(glist, "White");

glist = g_list_append(glist, "Green");

glist = g_list_append(glist, "Black");

instance->appendage = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(appendage_material_combo), 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->appendage,

TRUE, TRUE, 0);

gtk_widget_show(instance->appendage);

hbox = gtk_hbox_new(TRUE, 0);

gtk_box_pack_start(GTK_BOX(ret.vbox), hbox, FALSE, FALSE, 0);

gtk_widget_show(hbox);

glist = NULL;

glist = g_list_append(glist, "Red");

glist = g_list_append(glist, "Dark Brown");

glist = g_list_append(glist, "Light Brown");

glist = g_list_append(glist, "White");

glist = g_list_append(glist, "Green");

glist = g_list_append(glist, "Black");

instance->lid = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(lids_material_combo), 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->lid, TRUE, TRUE, 0);

gtk_widget_show(instance->lid);

glist = NULL;

glist = g_list_append(glist, "Red");

glist = g_list_append(glist, "Dark Brown");

glist = g_list_append(glist, "Light Brown");

glist = g_list_append(glist, "White");

glist = g_list_append(glist, "Green");

glist = g_list_append(glist, "Black");

instance->left_iris = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(left_iris_material_combo), 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->left_iris, TRUE, TRUE, 0);

gtk_widget_show(instance->left_iris);

glist = NULL;

glist = g_list_append(glist, "Red");

glist = g_list_append(glist, "Dark Brown");

glist = g_list_append(glist, "Light Brown");

glist = g_list_append(glist, "White");

glist = g_list_append(glist, "Green");

glist = g_list_append(glist, "Black");

instance->right_iris = pidgin_text_combo_box_entry_new(NULL, glist);

g_list_free(glist);

//gtk_combo_box_set_column_span_column(GTK_COMBO(right_iris_material_combo), 10);

gtk_box_pack_start(GTK_BOX(hbox), instance->right_iris, TRUE, TRUE, 0);

gtk_widget_show(instance->right_iris);

gtk_widget_add_events(ret.draw_area, GDK_BUTTON_PRESS_MASK);

g_signal_connect(G_OBJECT(ret.draw_area), "button_press_event",

G_CALLBACK(click_cb), instance);

g_signal_connect(G_OBJECT(ret.window), "destroy",

G_CALLBACK(destroy_cb), cc);

// gtk_widget_set_size_request(window, 640, 480);

gtk_window_set_default_size(GTK_WINDOW(ret.window),320,300);

GdkGeometry hints;

hints.max_width = 640;

hints.max_height = 480;

gtk_window_set_geometry_hints (GTK_WINDOW(ret.window),

NULL,

&hints,

GDK_HINT_MAX_SIZE);

gtk_widget_show(ret.window);

return instance;

}

static gboolean webcam_cb(struct input_instance *instance)

{

assert(instance);

QueryCam();

return TRUE;

}

static void *facefind(void *data)

{

fprintf(stderr, "waiting\n");

getchar();

fprintf(stderr,"got you");

detection_mode=1;

return;

}

void destroy_input(struct input_instance *instance)

{

extern filter_bank *bank;

assert(instance);

Filter_Destroy(bank);

g_source_remove(instance->timer_id);

Die();

ExitMovies();

}

static gboolean config_wrapper(GtkWidget *widget, GdkEventConfigure *event,

void *data)

{

GdkGLContext *glcontext = gtk_widget_get_gl_context(widget);

GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);

GLfloat w = widget->allocation.width;

GLfloat h = widget->allocation.height;

GLfloat aspect;

// fprintf(stderr,"Homicide %f %f %d\n", w,h,draw_mode);

if (draw_mode==1){

// fprintf(stderr, "Bad place to be- actually not so bad\n");

return configure(widget, event, data);

}

/*** OpenGL BEGIN ***/

if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext))

return FALSE;

/* Undo all of the Model lighting here*/

// glDisable(GL_LIGHTING);

glDisable(GL_DEPTH_TEST);

// glDisable(GL_CULL_FACE);

// glDisable(GL_LIGHT0);

// glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

/* */

glViewport(0,-(h/14),w*2,h*2);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(0,0,640,640);

glRasterPos2i(0,0);

glPixelZoom(-w/(1*640),(-h/(1*480)));

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

gdk_gl_drawable_gl_end(gldrawable);

/*** OpenGL END ***/

return TRUE;

}

static gboolean mydraw(GtkWidget *widget, GdkEventExpose *event,

void *data)

{

GdkGLContext *glcontext = gtk_widget_get_gl_context (widget);

GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget);

struct input_instance *instance = (struct input_instance*)data;

unsigned int *boo;

struct cc_features *features = &instance->face;

char *string = gtk_entry_get_text(GTK_COMBO(instance->model)->entry);

if (purple_strequal(string, "Dog")) {

features->kind = 0;

} else if (purple_strequal(string, "Shark")) {

features->kind = 1;

}

material_set(GTK_ENTRY(GTK_COMBO(instance->head)->entry),

&features->head_color);

material_set(GTK_ENTRY(GTK_COMBO(instance->appendage)->entry),

&features->appendage_color);

material_set(GTK_ENTRY(GTK_COMBO(instance->lid)->entry),

&features->lid_color);

material_set(GTK_ENTRY(GTK_COMBO(instance->left_iris)->entry),

&features->left_iris_color);

material_set(GTK_ENTRY(GTK_COMBO(instance->left_iris)->entry),

&features->right_iris_color);

if (easter_count>0) {

easter_count--;

} else {

instance->face.mode = 0;

}

if (mode_change>0){

mode_change--;

config_wrapper(widget, event, data);

}

if (draw_mode==1){

instance->output.my_output=LOCAL;

return draw(widget,event,&instance->output);

}

boo = (unsigned int*)colorBuf;

assert(instance);

assert(gtk_widget_is_gl_capable(widget));

/*** OpenGL BEGIN ***/

if (!gdk_gl_drawable_gl_begin(gldrawable, glcontext)) {

// fprintf(stderr, "We're fucked this time.\n");

return FALSE;

}

glClearColor(0.0, 0.0, 0.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);

glDrawPixels(WEBCAM_X, WEBCAM_Y-70, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, boo);

if (gdk_gl_drawable_is_double_buffered(gldrawable))

gdk_gl_drawable_swap_buffers(gldrawable);

else

glFlush();

gdk_gl_drawable_gl_end(gldrawable);

/*** OpenGL END ***/

return TRUE;

}

static void init_cb(GtkWidget *widget, struct input_instance *instance)

{

// setupDrawlists(LOCAL);

// fprintf(stderr,"init_cb\n");

}

static gboolean click_cb(GtkWidget *widget, GdkEventButton *event,

struct input_instance *instance)

{

GLfloat w = widget->allocation.width;

GLfloat h = widget->allocation.height;

GLfloat aspect;

if (draw_mode==1) {

switch (event->button) {

case 1:

Debug("F U!\n");

instance->face.mode = 1;

easter_count = 5;

break;

case 3:

Debug("should never get here\n");

instance->face.mode = 2;

easter_count = 5;

break;

default:

instance->face.mode = 0;

break;

}

return FALSE;

}

x_click=(event->x*(640/w));

x_click=640-x_click;

y_click=(event->y-(h/14))*(480/(h-(h/14)));

detection_mode=1;

//Debug("@@@ x:%d y:%d\n", x_click, y_click);

gtk_label_set_text(instance->label,

"Put on the box, then press confirm.");

if (x_click <= 10) x_click=10;

if (x_click >= WEBCAM_X-10) x_click=WEBCAM_X-60;

if (y_click <= 10) y_click=10;

if (y_click >= WEBCAM_Y-10) y_click=WEBCAM_Y-60;

return FALSE;

}

static void button_cb(GtkWidget *button, struct input_instance *instance)

{

if (!draw_mode) { /* transition to face mode */

if (detection_mode == 0) { /* ignore confirm if no calibrate */

return;

}

setupLighting(instance->widget);

mode_change = 1;

gtk_button_set_label(GTK_BUTTON(button), "Calibrate");

gtk_label_set_label(instance->label,

"If things get too crazy, click Calibrate.");

} else { /* transition to calibration mode */

gtk_label_set_label(instance->label, "Click your face");

mode_change = 2;

gtk_button_set_label(GTK_BUTTON(button), "Confirm");

}

draw_mode = !draw_mode;

}

static void destroy_cb(GtkWidget *widget, struct crazychat *cc)

{

cc->features_state = 0;

destroy_input(cc->input_data);

cc->input_data = NULL;

}

static void material_set(GtkWidget *entry, guint8 *material)

{

char *string = gtk_entry_get_text(GTK_ENTRY(entry));

if (purple_strequal(string, "Red")) {

*material = 0;

} else if (purple_strequal(string, "Dark Brown")) {

*material = 1;

} else if (purple_strequal(string, "Light Brown")) {

*material = 2;

} else if (purple_strequal(string, "White")) {

*material = 3;

} else if (purple_strequal(string, "Green")) {

*material = 4;

} else if (purple_strequal(string, "Black")) {

*material = 5;

}

pidgin/pidgin