/** * projectM -- Milkdrop-esque visualisation SDK * Copyright (C)2003-2004 projectM Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * See 'LICENSE.txt' included within this release * */ /* Basic Parameter Functions */ #include #include #include #include #include "projectM.h" #include "fatal.h" #include "common.h" #include "CustomShape.h" #include "Eval.h" #include "Expr.h" #include "InitCond.h" #include "Param.h" #include "Preset.h" #include "SplayTree.h" #include "wipemalloc.h" /** Constructor */ Param::Param( char * name, short int type, short int flags, void * engine_val, void * matrix, CValue default_init_val, CValue upper_bound, CValue lower_bound) { /* Clear name space, think the strncpy statement makes this redundant */ //memset(param->name, 0, MAX_TOKEN_SIZE); /* Copy given name into parameter structure */ strncpy(this->name, name, MAX_TOKEN_SIZE-1); /* Assign other entries in a constructor like fashion */ this->type = type; this->flags = flags; this->matrix_flag = 0; this->matrix = matrix; this->engine_val = engine_val; this->default_init_val = default_init_val; //*param->init_val = default_init_val; this->upper_bound = upper_bound; this->lower_bound = lower_bound; /** @@FIX THIS */ this->gx = projectM::currentEngine->gx; this->gy = projectM::currentEngine->gy; } /* Creates a user defined parameter */ Param * Param::create_user_param(char * name) { Param * param; CValue iv; CValue ub; CValue lb; float * engine_val; /* Set initial values to default */ iv.float_val = DEFAULT_DOUBLE_IV; ub.float_val = DEFAULT_DOUBLE_UB; lb.float_val = DEFAULT_DOUBLE_LB; /* Argument checks */ if (name == NULL) return NULL; /* Allocate space for the engine variable */ if ((engine_val = (float*)wipemalloc(sizeof(float))) == NULL) return NULL; (*engine_val) = iv.float_val; /* set some default init value */ /* Create the new user parameter */ if ((param = new Param(name, P_TYPE_DOUBLE, P_FLAG_USERDEF, engine_val, NULL, iv, ub, lb)) == NULL) { free(engine_val); engine_val = NULL; return NULL; } if (PARAM_DEBUG) printf("create_param: \"%s\" initialized\n", param->name); /* Return the instantiated parameter */ return param; } /* Free's a parameter type */ Param::~Param() { int x; if (flags & P_FLAG_USERDEF) { free(engine_val); engine_val = NULL; } //if (!(param->flags & P_FLAG_DONT_FREE_MATRIX)) { if (matrix && !(flags & P_FLAG_DONT_FREE_MATRIX)) { if (flags & P_FLAG_PER_POINT) { free(matrix); matrix = NULL; }//FIX THIS NOW XMAS05 else if (flags & P_FLAG_PER_PIXEL) { for(x = 0; x < gx; x++) free(((float**)matrix)[x]); free(matrix); matrix = NULL; } } if (PARAM_DEBUG) printf("free_param: freeing \"%s\".\n", name); } /* Compare string name with parameter name */ int Param::compare_param( char * name, char * name2 ) { int cmpval; printf("am i used\n"); /* Uses string comparison function */ cmpval = strncmp(name, name2, MAX_TOKEN_SIZE-1); return cmpval; } /* Returns nonzero if the string is valid parameter name */ int Param::is_valid_param_string( char * string ) { if (string == NULL) return FALSE; /* This ensures the first character is non numeric */ if( ((*string) >= 48) && ((*string) <= 57)) return FALSE; /* These probably should never happen */ if (*string == '.') return FALSE; if (*string == '+') return FALSE; if (*string == '-') return FALSE; /* Could also add checks for other symbols. May do later */ return TRUE; } /* Sets the parameter engine value to value val. clipping occurs if necessary */ void Param::set_param( float val) { switch (type) { case P_TYPE_BOOL: if (val < 0) *((int*)engine_val) = 0; else if (val > 0) *((int*)engine_val) = 1; else *((int*)engine_val) = 0; break; case P_TYPE_INT: /* Make sure value is an integer */ val = floor(val); if (val < lower_bound.int_val) *((int*)engine_val) = lower_bound.int_val; else if (val > upper_bound.int_val) *((int*)engine_val) = upper_bound.int_val; else *((int*)engine_val) = (int)val; break; case P_TYPE_DOUBLE: /* Make sure value is an integer */ if (val < lower_bound.float_val) *((float*)engine_val) = lower_bound.float_val; else if (val > upper_bound.float_val) *((float*)engine_val) = upper_bound.float_val; else *((float*)engine_val) = val; break; default: break; } return; } /* Find a parameter given its name, will create one if not found */ Param * Param::find_param(char * name, Preset * preset, int flags) { Param * param = NULL; /* Null argument checks */ if (name == NULL) return NULL; if (preset == NULL) return NULL; /* First look in the builtin database */ param = (Param *)projectM::currentEngine->builtin_param_tree->splay_find(name); /* If the search failed, check the user database */ if (param == NULL) { param = (Param*)preset->user_param_tree->splay_find(name); } /* If it doesn't exist in the user (or builtin) database and create_flag is set, then make it and insert into the database */ if ((param == NULL) && (flags & P_CREATE)) { /* Check if string is valid */ if (!is_valid_param_string(name)) { if (PARAM_DEBUG) printf("find_param: invalid parameter name:\"%s\"\n", name); return NULL; } /* Now, create the user defined parameter given the passed name */ if ((param = create_user_param(name)) == NULL) { if (PARAM_DEBUG) printf("find_param: failed to create a new user parameter!\n"); return NULL; } /* Finally, insert the new parameter into this preset's proper splaytree */ if (preset->user_param_tree->splay_insert(param, param->name) < 0) { if (PARAM_DEBUG) printf("PARAM \"%s\" already exists in user parameter tree!\n", param->name); delete param; return NULL; } } /* Return the found (or created) parameter. Note that if P_CREATE is not set, this could be null */ return param; } /* Loads a float parameter into the builtin database */ Param * Param::new_param_float(char * name, short int flags, void * engine_val, void * matrix, float upper_bound, float lower_bound, float init_val) { Param * param; CValue iv, ub, lb; iv.float_val = init_val; ub.float_val = upper_bound; lb.float_val = lower_bound; if ((param = new Param(name, P_TYPE_DOUBLE, flags, engine_val, matrix,iv, ub, lb)) == NULL) return NULL; /* Finished, return success */ return param; } /* Creates a new parameter of type int */ Param * Param::new_param_int(char * name, short int flags, void * engine_val, int upper_bound, int lower_bound, int init_val) { Param * param; CValue iv, ub, lb; iv.int_val = init_val; ub.int_val = upper_bound; lb.int_val = lower_bound; if ((param = new Param(name, P_TYPE_INT, flags, engine_val, NULL, iv, ub, lb)) == NULL) return NULL; /* Finished, return success */ return param; } /* Creates a new parameter of type bool */ Param * Param::new_param_bool(char * name, short int flags, void * engine_val, int upper_bound, int lower_bound, int init_val) { Param * param; CValue iv, ub, lb; iv.bool_val = init_val; ub.bool_val = upper_bound; lb.bool_val = lower_bound; if ((param = new Param(name, P_TYPE_BOOL, flags, engine_val, NULL, iv, ub, lb)) == NULL) return NULL; /* Finished, return success */ return param; } void Param::load_init_cond() { InitCond * init_cond; CValue init_val; /* Don't count read only parameters as initial conditions */ if (flags & P_FLAG_READONLY) return; /* If initial condition was not defined by the preset file, force a default one with the following code */ if ((init_cond = (InitCond*)(Preset::active_preset->init_cond_tree->splay_find(name))) == NULL) { /* Make sure initial condition does not exist in the set of per frame initial equations */ if ((init_cond = (InitCond*)(Preset::active_preset->per_frame_init_eqn_tree->splay_find(name))) != NULL) return; if (type == P_TYPE_BOOL) init_val.bool_val = 0; else if (type == P_TYPE_INT) init_val.int_val = *(int*)engine_val; else if (type == P_TYPE_DOUBLE) init_val.float_val = *(float*)engine_val; /* Create new initial condition */ if ((init_cond = new InitCond(this, init_val)) == NULL) return; /* Insert the initial condition into this presets tree */ if (Preset::active_preset->init_cond_tree->splay_insert(init_cond, init_cond->param->name) < 0) { delete init_cond; return; } } } void Param::load_unspec_init_cond() { InitCond * init_cond; CValue init_val; /* Don't count these parameters as initial conditions */ if (flags & P_FLAG_READONLY) return; if (flags & P_FLAG_QVAR) return; if (flags & P_FLAG_TVAR) return; if (flags & P_FLAG_USERDEF) return; /* If initial condition was not defined by the preset file, force a default one with the following code */ if ((init_cond = (InitCond*)CustomWave::interface_wave->init_cond_tree->splay_find(name)) == NULL) { /* Make sure initial condition does not exist in the set of per frame initial equations */ if ((init_cond = (InitCond*)CustomWave::interface_wave->per_frame_init_eqn_tree->splay_find(name)) != NULL) return; if (type == P_TYPE_BOOL) init_val.bool_val = 0; else if (type == P_TYPE_INT) init_val.int_val = *(int*)engine_val; else if (type == P_TYPE_DOUBLE) init_val.float_val = *(float*)engine_val; //printf("%s\n", param->name); /* Create new initial condition */ if ((init_cond = new InitCond(this, init_val)) == NULL) return; /* Insert the initial condition into this presets tree */ if (CustomWave::interface_wave->init_cond_tree->splay_insert(init_cond, init_cond->param->name) < 0) { delete init_cond; return; } } } void Param::load_unspec_init_cond_shape() { InitCond * init_cond; CValue init_val; /* Don't count read only parameters as initial conditions */ if (flags & P_FLAG_READONLY) return; if (flags & P_FLAG_QVAR) return; if (flags & P_FLAG_TVAR) return; if (flags & P_FLAG_USERDEF) return; /* If initial condition was not defined by the preset file, force a default one with the following code */ if ((init_cond =(InitCond*)CustomShape::interface_shape->init_cond_tree->splay_find(name)) == NULL) { /* Make sure initial condition does not exist in the set of per frame initial equations */ if ((init_cond = (InitCond*)CustomShape::interface_shape->per_frame_init_eqn_tree->splay_find(name)) != NULL) return; if (type == P_TYPE_BOOL) init_val.bool_val = 0; else if (type == P_TYPE_INT) init_val.int_val = *(int*)engine_val; else if (type == P_TYPE_DOUBLE) init_val.float_val = *(float*)engine_val; //printf("%s\n", param->name); /* Create new initial condition */ if ((init_cond = new InitCond(this, init_val)) == NULL) return; /* Insert the initial condition into this presets tree */ if (CustomShape::interface_shape->init_cond_tree->splay_insert(init_cond, init_cond->param->name) < 0) { delete init_cond; return; } } }