mirror of
https://github.com/clementine-player/Clementine
synced 2024-12-24 16:51:59 +01:00
200 lines
5.0 KiB
C++
Executable File
200 lines
5.0 KiB
C++
Executable File
/**
|
|
* 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;
|
|
}
|
|
|
|
|