void AddFmodGlobals(VM_ID vm)
{
code_object *a_globals = CreateCodeObject(str_Copy("fmod_code"));
AddCodeCFunction((object*)a_globals,"Sleep",&fmod_Sleep);
AddCodeCFunction((object*)a_globals,"playSound",&fmod_playSound);
AddCodeCFunction((object*)a_globals,"__init__",&fmod_Init);
AddCodeCFunction((object*)a_globals,"__del__",&fmod_Close);
class_object *fmod_global = CreateClassObject(a_globals,NULL);
vm_AddGlobal(vm,(object*)CreateUnicodeObject(str_Copy("fmod")),fmod_global);
}
char *str_Cat(char *a,char *b)
{
if(a == NULL && b != NULL)
return(str_Copy(b));
else
if(a != NULL && b == NULL)
return(str_Copy(a));
else
if(a == NULL && b == NULL)
return(str_CreateEmpty());
char *tmp = (char*)malloc(strlen(a) + strlen(b) + 1);
memcpy(tmp, a, strlen(a));
memcpy(tmp + strlen(a), b, strlen(b)+1);
return(tmp);
}
OBJECT_ID fmod_Init(VM_ID vm,TUPLE_ID locals,TUPLE_ID kw_locals)
{
object *self = GetItem((object*)locals,0);
unsigned int version;
FMOD_SYSTEM *fmod_sys;
FMOD_RESULT result;
result = FMOD_System_Create(&fmod_sys);
ERRCHECK(result);
result = FMOD_System_GetVersion(fmod_sys, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(fmod_sys, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
unicode_object *sys = CreateUnicodeObject(str_Copy("__fmod_sys__"));
tag_object *tag = CreateTagObject(fmod_sys);
SetAttribute(self,sys,tag);
object *tmp =CreateEmptyObject(TYPE_NONE);
return (tmp);
}
extern void
dep_AddDependency(string* filename) {
if (!hasDependency(filename)) {
SDependency* dependency = (SDependency*) mem_Alloc(sizeof(SDependency));
dependency->filename = str_Copy(filename);
dependency->next = NULL;
*g_nextDependency = dependency;
g_nextDependency = &dependency->next;
}
}
struct razer_chroma *razer_open(void)
{
struct razer_chroma *chroma =(struct razer_chroma*)malloc(sizeof(struct razer_chroma));
#ifdef USE_DEBUGGING
printf("opening chroma lib\n");
#endif
chroma->sys_mouse_event_path = str_Copy(razer_sys_mouse_event_default_path);
chroma->sys_keyboard_event_path = str_Copy(razer_sys_keyboard_event_default_path);
chroma->custom_mode_file = NULL;
chroma->update_keys_file = NULL;
chroma->keyboard_input_file = 0;
chroma->mouse_input_file = 0;
chroma->device_path = razer_get_device_path();
if(!chroma->device_path)
{
#ifdef USE_DEBUGGING
printf("error no compatible device found\n");
#endif
return(NULL);
}
#ifdef USE_VERBOSE_DEBUGGING
printf("found device at path:%s\n",chroma->device_path);
#endif
chroma->keys = (struct razer_keys*)malloc(sizeof(struct razer_keys));
razer_init_keys(chroma->keys);
chroma->custom_mode_filename = str_CreateEmpty();
chroma->custom_mode_filename = str_CatFree(chroma->custom_mode_filename,chroma->device_path);
chroma->custom_mode_filename = str_CatFree(chroma->custom_mode_filename,razer_custom_mode_pathname);
chroma->update_keys_filename = str_CreateEmpty();
chroma->update_keys_filename = str_CatFree(chroma->update_keys_filename,chroma->device_path);
chroma->update_keys_filename = str_CatFree(chroma->update_keys_filename,razer_update_keys_pathname);
chroma->input_handler = NULL;
chroma->last_key_pos.x = -1;
chroma->last_key_pos.y = -1;
chroma->key_pos.x = -1;
chroma->key_pos.y = -1;
return(chroma);
}
OBJECT_ID fmod_Close(VM_ID vm,TUPLE_ID locals,TUPLE_ID kw_locals)
{
object *self = GetItem((object*)locals,0);
unicode_object *sys_name = CreateUnicodeObject(str_Copy("__fmod_sys__"));
object *sys = GetAttribute(self,sys_name);
gc_IncRefCount(sys_name);
gc_DecRefCount(sys_name);
FMOD_RESULT result;
result = FMOD_System_Close(((tag_object*)sys)->tag);
ERRCHECK(result);
result = FMOD_System_Release(((tag_object*)sys)->tag);
ERRCHECK(result);
object *tmp =CreateEmptyObject(TYPE_NONE);
return (tmp);
}
OBJECT_ID fmod_playSound(VM_ID vm,TUPLE_ID locals,TUPLE_ID kw_locals)
{
object *self = GetItem((object*)locals,0);
object *filename = GetItem((object*)locals,1);
object *mode = GetItem((object*)locals,2);
unicode_object *sys_name = CreateUnicodeObject(str_Copy("__fmod_sys__"));
object *sys = GetAttribute(self,(object*)sys_name);
gc_IncRefCount((object*)sys_name);
gc_DecRefCount((object*)sys_name);
if(filename->type == TYPE_KV)
filename = (object*)((kv_object*)filename)->value;
if(mode->type == TYPE_KV)
mode = (object*)((kv_object*)mode)->value;
if(filename->type == TYPE_UNICODE)
fmod_play_sound(((tag_object*)sys)->tag,((unicode_object*)filename)->value,0);
object *tmp =CreateEmptyObject(TYPE_NONE);
return (tmp);
}
struct razer_fx_render_node *daemon_create_render_node(struct razer_daemon *daemon,struct razer_effect *effect,int input_render_node_uid,int second_input_render_node_uid,int output_render_node_uid,char *name,char *description)
{
struct razer_fx_render_node *render_node = (struct razer_fx_render_node*)malloc(sizeof(struct razer_fx_render_node));
render_node->daemon = daemon;
//render_node->effect = effect;
if(effect)
render_node->effect = daemon_create_effect_instance(daemon,effect);
else
render_node->effect = NULL;
render_node->opacity = 1.0f;
if(input_render_node_uid == -1)
{
struct razer_rgb_frame *iframe = razer_create_rgb_frame();
render_node->input_frame = iframe;
render_node->input_frame_linked_uid = -1;
}
else if(input_render_node_uid == 0) //set input to daemon output buffer
{
render_node->input_frame = daemon->frame_buffer;
render_node->input_frame_linked_uid = 0;
}
else
{
struct razer_fx_render_node *rn = daemon_get_render_node(daemon,input_render_node_uid);
render_node->input_frame = rn->output_frame;
render_node->input_frame_linked_uid = input_render_node_uid;
}
if(second_input_render_node_uid == -1)
{
struct razer_rgb_frame *siframe = razer_create_rgb_frame();
render_node->second_input_frame = siframe;
render_node->second_input_frame_linked_uid = -1;
}
else if(second_input_render_node_uid == 0) //set input to daemon output buffer
{
render_node->second_input_frame = daemon->frame_buffer;
render_node->second_input_frame_linked_uid = 0;
}
else
{
struct razer_fx_render_node *srn = daemon_get_render_node(daemon,second_input_render_node_uid);
render_node->second_input_frame = srn->output_frame;
render_node->second_input_frame_linked_uid = second_input_render_node_uid;
}
if(output_render_node_uid == -1)
{
struct razer_rgb_frame *oframe = razer_create_rgb_frame();
render_node->output_frame = oframe;
render_node->output_frame_linked_uid = -1;
}
else if(output_render_node_uid == 0) //set input to daemon output buffer
{
render_node->output_frame = daemon->frame_buffer;
render_node->output_frame_linked_uid = 0;
}
/*else //not used
{
struct razer_fx_render_node *orn = daemon_get_render_node(daemon,output_render_node_uid);
render_node->output_frame = orn->output_frame;
render_node->output_frame_linked_uid = output_render_node_uid;
}*/
render_node->description = str_Copy(description);
render_node->name = str_Copy(name);
//render_node->fps = daemon->fps;
render_node->compose_mode = RAZER_COMPOSE_MODE_MIX;
render_node->next = NULL;
render_node->parent = NULL;
//render_node->parameters = NULL;
//render_node->parameters_num = 0;
render_node->subs = list_Create(0,0);
render_node->start_ticks = 0;
render_node->running = 0;//set to 1 with first update
render_node->limit_render_time_ms = 0;
render_node->move_frame_buffer_linkage_to_next = 1;
//render_node->continue_chain=1;
render_node->loop_count = -1;
return(render_node);
}
extern void
dep_SetMainOutput(string* filename) {
g_mainOutput = str_Copy(filename);
}
struct razer_parameter *daemon_copy_parameter(struct razer_parameter *parameter)
{
struct razer_parameter *copy = daemon_create_parameter();
copy->id = parameter->id;
copy->key = str_Copy(parameter->key);
copy->description = str_Copy(parameter->description);
copy->type = parameter->type;
switch(parameter->type)
{
case RAZER_PARAMETER_TYPE_STRING:
daemon_set_parameter_string(copy,str_Copy(daemon_get_parameter_string(parameter)));
break;
case RAZER_PARAMETER_TYPE_INT:
daemon_set_parameter_int(copy,daemon_get_parameter_int(parameter));
break;
case RAZER_PARAMETER_TYPE_FLOAT:
daemon_set_parameter_float(copy,daemon_get_parameter_float(parameter));
break;
case RAZER_PARAMETER_TYPE_RGB:
{
struct razer_rgb *color = rgb_copy(daemon_get_parameter_rgb(parameter));
daemon_set_parameter_rgb(copy,color);
}
break;
case RAZER_PARAMETER_TYPE_POS:
{
struct razer_pos *pos = razer_pos_copy(daemon_get_parameter_pos(parameter));
daemon_set_parameter_pos(copy,pos);
}
break;
case RAZER_PARAMETER_TYPE_RENDER_NODE:
daemon_set_parameter_render_node(copy,daemon_get_parameter_render_node(parameter));
break;
case RAZER_PARAMETER_TYPE_FLOAT_RANGE:
{
struct razer_float_range *range = razer_float_range_copy(daemon_get_parameter_float_range(parameter));
daemon_set_parameter_float_range(copy,range);
}
break;
case RAZER_PARAMETER_TYPE_INT_RANGE:
{
struct razer_int_range *range = razer_int_range_copy(daemon_get_parameter_int_range(parameter));
daemon_set_parameter_int_range(copy,range);
}
break;
case RAZER_PARAMETER_TYPE_UINT_RANGE:
{
struct razer_uint_range *range = razer_uint_range_copy(daemon_get_parameter_uint_range(parameter));
daemon_set_parameter_uint_range(copy,range);
}
break;
case RAZER_PARAMETER_TYPE_RGB_RANGE:
{
struct razer_rgb_range *range = razer_rgb_range_copy(daemon_get_parameter_rgb_range(parameter));
daemon_set_parameter_rgb_range(copy,range);
}
break;
case RAZER_PARAMETER_TYPE_POS_RANGE:
{
struct razer_pos_range *range = razer_pos_range_copy(daemon_get_parameter_pos_range(parameter));
daemon_set_parameter_pos_range(copy,range);
}
break;
case RAZER_PARAMETER_TYPE_FLOAT_ARRAY:
{
struct razer_float_array *array = razer_float_array_copy(daemon_get_parameter_float_array(parameter));
daemon_set_parameter_float_array(copy,array);
}
break;
case RAZER_PARAMETER_TYPE_INT_ARRAY:
{
struct razer_int_array *array = razer_int_array_copy(daemon_get_parameter_int_array(parameter));
daemon_set_parameter_int_array(copy,array);
}
break;
case RAZER_PARAMETER_TYPE_UINT_ARRAY:
{
struct razer_uint_array *array = razer_uint_array_copy(daemon_get_parameter_uint_array(parameter));
daemon_set_parameter_uint_array(copy,array);
}
break;
case RAZER_PARAMETER_TYPE_RGB_ARRAY:
{
struct razer_rgb_array *array = razer_rgb_array_copy(daemon_get_parameter_rgb_array(parameter));
daemon_set_parameter_rgb_array(copy,array);
}
break;
case RAZER_PARAMETER_TYPE_POS_ARRAY:
{
struct razer_pos_array *array = razer_pos_array_copy(daemon_get_parameter_pos_array(parameter));
daemon_set_parameter_pos_array(copy,array);
}
break;
}
return(copy);
}
