Clementine-audio-player-Mac.../3rdparty/libprojectm/MilkdropPresetFactory/Param.cpp

200 lines
5.0 KiB
C++
Raw Normal View History

2010-06-06 23:43:45 +02:00
/**
* 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 <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "fatal.h"
#include "Common.hpp"
#include "CustomShape.hpp"
#include "Eval.hpp"
#include "Expr.hpp"
#include "InitCond.hpp"
#include "Param.hpp"
#include "Preset.hpp"
#include <map>
#include <iostream>
#include <cassert>
/** Constructor */
Param::Param( std::string _name, short int _type, short int _flags, void * _engine_val, void * _matrix,
CValue _default_init_val, CValue _upper_bound, CValue _lower_bound):
name(_name),
type(_type),
flags (_flags),
matrix_flag (0),
engine_val(_engine_val),
matrix (_matrix),
default_init_val (_default_init_val),
upper_bound (_upper_bound),
lower_bound (_lower_bound)
{
}
/* Creates a user defined parameter */
Param::Param(std::string _name) :
name(_name),
type(P_TYPE_DOUBLE),
flags(P_FLAG_USERDEF),
matrix_flag(0),
matrix(0)
{
engine_val = new float();
default_init_val.float_val = DEFAULT_DOUBLE_IV;
upper_bound.float_val = DEFAULT_DOUBLE_UB;
lower_bound.float_val = DEFAULT_DOUBLE_LB;
/// @note may have fixed a recent bug. testing
*((float*)engine_val) = default_init_val.float_val;
}
/* Free's a parameter type */
Param::~Param() {
// I hate this, but will let it be for now
if (flags & P_FLAG_USERDEF) {
delete((double*)engine_val);
}
if (PARAM_DEBUG) printf("~Param: freeing \"%s\".\n", name.c_str());
}
/* Returns nonzero if the string is valid parameter name */
bool Param::is_valid_param_string( const 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;
}
/* Loads a float parameter into the builtin database */
Param * Param::new_param_float(const 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;
assert(engine_val);
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(const char * name, short int flags, void * engine_val,
int upper_bound, int lower_bound, int init_val) {
Param * param;
CValue iv, ub, lb;
assert(engine_val);
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(const char * name, short int flags, void * engine_val,
bool upper_bound, bool lower_bound, bool init_val) {
Param * param;
CValue iv, ub, lb;
assert(engine_val);
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;
}
/* Creates a new parameter of type string */
Param * Param::new_param_string(const char * name, short int flags, void * engine_val) {
Param * param;
CValue iv, ub, lb;
assert(engine_val);
iv.bool_val = 0;
ub.bool_val = 0;
lb.bool_val = 0;
if ((param = new Param(name, P_TYPE_STRING, flags, engine_val, NULL, iv, ub, lb)) == NULL)
return NULL;
/* Finished, return success */
return param;
}