Line data Source code
1 : /**
2 : * @file command.h
3 : * @brief Script binding functionality.
4 : *
5 : * This file describes the CubeScript API for binding and executing code from within
6 : * the engine's CubeScript context.
7 : */
8 :
9 : #ifndef COMMAND_H_
10 : #define COMMAND_H_
11 :
12 : enum
13 : {
14 : Value_Null = 0,
15 : Value_Integer,
16 : Value_Float,
17 : Value_String,
18 : Value_Any,
19 : Value_Code,
20 : Value_Macro,
21 : Value_Ident,
22 : Value_CString,
23 : Value_CAny,
24 : Value_Word,
25 : Value_Pop,
26 : Value_Cond,
27 : };
28 :
29 : enum
30 : {
31 : Id_Var, //0
32 : Id_FloatVar,
33 : Id_StringVar,
34 : Id_Command,
35 : Id_Alias,
36 : Id_Local, //5
37 : Id_Do,
38 : Id_DoArgs,
39 : Id_If,
40 : Id_Result,
41 : Id_Not, //10
42 : Id_And,
43 : Id_Or, //12
44 : };
45 :
46 : enum
47 : {
48 : Idf_Persist = 1<<0,
49 : Idf_Override = 1<<1,
50 : Idf_Hex = 1<<2,
51 : Idf_ReadOnly = 1<<3,
52 : Idf_Overridden = 1<<4,
53 : Idf_Unknown = 1<<5,
54 : Idf_Arg = 1<<6,
55 : };
56 :
57 : struct ident;
58 :
59 : struct identval
60 : {
61 : union
62 : {
63 : int i; // Id_Var, ValueInteger
64 : float f; // Id_FloatVar, ValueFloat
65 : char *s; // Id_StringVar, ValueString
66 : const uint *code; // ValueCode
67 : ident *id; // ValueIdent
68 : const char *cstr; // ValueCString
69 : };
70 : };
71 :
72 : struct tagval : identval
73 : {
74 : int type;
75 :
76 : void setint(int val);
77 : void setfloat(float val);
78 : void setnumber(double val);
79 : void setstr(char *val);
80 : void setnull();
81 : void setcode(const uint *val);
82 : void setmacro(const uint *val);
83 : void setcstr(const char *val);
84 : void setident(ident *val);
85 :
86 : const char *getstr() const;
87 : int getint() const;
88 : float getfloat() const;
89 : double getnumber() const;
90 : bool getbool() const;
91 : void getval(tagval &r) const;
92 :
93 : void cleanup();
94 : };
95 :
96 : struct identstack
97 : {
98 : identval val;
99 : int valtype;
100 : identstack *next;
101 : };
102 :
103 : typedef void (__cdecl *identfun)(ident *id);
104 :
105 : /**
106 : * @brief An object representing all Cubescript objects.
107 : *
108 : * This object defines all possible state for any object in Cubescript. Different
109 : * types will have different members due to the union types, but the ident object
110 : * is common to them regardless. This allows storage of CS objects in a uniform
111 : * map consisting of one type.
112 : */
113 : struct ident
114 : {
115 : //this pointer will point to different types depending upon the type of variable
116 : union identvalptr /**< points to an ident's value */
117 : {
118 : void *p; /**< can point to any Id_*Var */
119 : int *i; /**< points to an Id_Var (int) */
120 : float *f; /**< points to an Id_FloatVar */
121 : char **s; /**< points to a pointer to a Id_StringVar (C string) */
122 : };
123 :
124 : uchar type; /**< one of Id_* in Id_ enum */
125 : union
126 : {
127 : uchar valtype; /**< if alias, points to Id_Alias's type */
128 : uchar numargs; /**< if command, number of commands the Id_Command has */
129 : };
130 : ushort flags;
131 : int index;
132 : const char *name;
133 : union
134 : {
135 : struct // Id_Var, Id_FloatVar, Id_StringVar
136 : {
137 : union //number var range union type
138 : {
139 : struct
140 : {
141 : int min, /**< if an int variable, its min allowed value*/
142 : max; /**< if an int variable, its max allowed value*/
143 : } i; // Id_Var
144 : struct
145 : {
146 : float min, /**< if a float variable, its min allowed value*/
147 : max; /**< if a float variable, its max allowed value*/
148 : } f; // Id_FloatVar
149 : };
150 : identvalptr storage;
151 : identval overrideval;
152 : } val;
153 : struct // Id_Alias
154 : {
155 : uint *code;
156 : identval val;
157 : identstack *stack;
158 : } alias;
159 : struct // Id_Command
160 : {
161 : const char *args;
162 : uint argmask;
163 : } cmd;
164 : };
165 : identfun fun; /**< the pointer a command or variable points to (the on-change command for a var)*/
166 :
167 1114 : ident() {}
168 : /**
169 : * @brief Constructor for an ident for an int variable.
170 : */
171 387 : ident(int t, const char *n, int m, int x, int *s, void *f = nullptr, int flags = 0)
172 387 : : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
173 : {
174 387 : val.storage.i = s;
175 387 : val.i.min = m;
176 387 : val.i.max = x;
177 387 : }
178 :
179 : /**
180 : * @brief Constructor for an ident for a float variable.
181 : */
182 112 : ident(int t, const char *n, float m, float x, float *s, void *f = nullptr, int flags = 0)
183 112 : : type(t), flags(flags | (m > x ? Idf_ReadOnly : 0)), name(n), fun(reinterpret_cast<identfun>(f))
184 : {
185 112 : val.storage.f = s;
186 112 : val.f.min = m;
187 112 : val.f.max = x;
188 112 : }
189 :
190 : /**
191 : * @brief Constructor for an ident for a string variable.
192 : */
193 5 : ident(int t, const char *n, char **s, void *f = nullptr, int flags = 0)
194 5 : : type(t), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
195 : {
196 5 : val.storage.s = s;
197 5 : }
198 :
199 : // Id_Alias
200 : ident(int t, const char *n, char *a, int flags)
201 : : type(t), valtype(Value_String), flags(flags), name(n)
202 : {
203 : alias.code = nullptr;
204 : alias.stack = nullptr;
205 : alias.val.s = a;
206 : }
207 :
208 : ident(int t, const char *n, int a, int flags)
209 : : type(t), valtype(Value_Integer), flags(flags), name(n)
210 : {
211 : alias.code = nullptr;
212 : alias.stack = nullptr;
213 : alias.val.i = a;
214 : }
215 :
216 : ident(int t, const char *n, float a, int flags)
217 : : type(t), valtype(Value_Float), flags(flags), name(n)
218 : {
219 : alias.code = nullptr;
220 : alias.stack = nullptr;
221 : alias.val.f = a;
222 : }
223 :
224 32 : ident(int t, const char *n, int flags)
225 32 : : type(t), valtype(Value_Null), flags(flags), name(n)
226 : {
227 32 : alias.code = nullptr;
228 32 : alias.stack = nullptr;
229 32 : }
230 :
231 2 : ident(int t, const char *n, const tagval &v, int flags)
232 2 : : type(t), valtype(v.type), flags(flags), name(n)
233 : {
234 2 : alias.code = nullptr;
235 2 : alias.stack = nullptr;
236 2 : alias.val = v;
237 2 : }
238 :
239 : /**
240 : * @brief Constructor for an ident for a C++ bound command.
241 : */
242 596 : ident(int t, const char *n, const char *args, uint argmask, int numargs, void *f = nullptr, int flags = 0)
243 596 : : type(t), numargs(numargs), flags(flags), name(n), fun(reinterpret_cast<identfun>(f))
244 : {
245 596 : cmd.args = args;
246 596 : cmd.argmask = argmask;
247 596 : }
248 :
249 : /**
250 : * @brief Calls a change effect for this ident, if one exists.
251 : *
252 : * If there is no function pointed to by `fun` (it is null), then nothing
253 : * will occur.
254 : */
255 1 : void changed()
256 : {
257 1 : if(fun)
258 : {
259 0 : fun(this);
260 : }
261 1 : }
262 :
263 : /**
264 : * @brief Sets the value and type of value of this ident given a tagval
265 : *
266 : * Sets this ident's value type and value to the corresponding values from
267 : * the passed tagval object.
268 : *
269 : * @param v the tagval to set values from
270 : */
271 285 : void setval(const tagval &v)
272 : {
273 285 : valtype = v.type;
274 285 : alias.val = v;
275 285 : }
276 :
277 : /**
278 : * @brief Sets the value and type of value of this ident given an identstack
279 : *
280 : * Sets this ident's value type and value to the corresponding values from
281 : * the passed identstack object.
282 : *
283 : * @param v the identstack to set values from
284 : */
285 95 : void setval(const identstack &v)
286 : {
287 95 : valtype = v.valtype;
288 95 : alias.val = v.val;
289 95 : }
290 :
291 : /**
292 : * @brief Sets the value type of this ident to null.
293 : *
294 : * If a string is being stored inside this ident, it is freed.
295 : */
296 28 : void forcenull()
297 : {
298 28 : if(valtype==Value_String)
299 : {
300 2 : delete[] alias.val.s;
301 : }
302 28 : valtype = Value_Null;
303 28 : }
304 :
305 : /**
306 : * @brief Returns the saved value of the ident as a float.
307 : *
308 : * Returns a float even if the ident is of another type, e.g. integer
309 : *
310 : * @return the float value of the ident
311 : */
312 : float getfloat() const;
313 :
314 : /**
315 : * @brief Returns the saved value of the ident as an integer.
316 : *
317 : * Returns an int even if the ident is of another type, e.g. float
318 : */
319 : int getint() const;
320 :
321 : /**
322 : * @brief Returns the saved value of the ident as a double.
323 : *
324 : * Returns a double even if the ident is of another type, e.g. integer
325 : *
326 : * @return the double value of the ident
327 : */
328 : double getnumber() const;
329 : const char *getstr() const;
330 : void getval(tagval &r) const;
331 : void getcstr(tagval &v) const;
332 : void getcval(tagval &v) const;
333 : };
334 :
335 : /**
336 : * @brief Returns an integer value from a Cubescript command.
337 : *
338 : * When writing a CS command, this function returns an integer value to the inheriting
339 : * CS environment.
340 : *
341 : * @param v the value to return
342 : */
343 : extern void intret(int v);
344 :
345 : extern const char *floatstr(float v);
346 :
347 : /**
348 : * @brief Returns a float value from a Cubescript command.
349 : *
350 : * When writing a CS command, this function returns a float value to the inheriting
351 : * CS environment.
352 : *
353 : * @param v the value to return
354 : */
355 : extern void floatret(float v);
356 :
357 : /**
358 : * @brief Returns a string value from a Cubescript command.
359 : *
360 : * When writing a CS command, this function returns a string value to the inheriting
361 : * CS environment.
362 : *
363 : * @param v the value to return
364 : */
365 : extern void stringret(char *s);
366 :
367 : /**
368 : * @brief Returns an alias' name from a Cubescript command.
369 : *
370 : * When writing a CS command, this functions a string value representing the name
371 : * of a Cubescript object to the inheriting CS environment.
372 : *
373 : * @param s the name of the ident to return
374 : */
375 : extern void result(const char *s);
376 :
377 : /**
378 : * @brief Returns the string passed as an integer.
379 : *
380 : * Parses the entire string, returning the value of the passed value as an integer.
381 : * The value of this value will always be greater than zero unless there is an
382 : * overflow beyond the size of `int`. The output may be converted by a trailing
383 : * radix digit as described in `strtoul`.
384 : *
385 : * @param s the string to turn into an integer
386 : */
387 596 : inline int parseint(const char *s)
388 : {
389 596 : return static_cast<int>(std::strtoul(s, nullptr, 0));
390 : }
391 :
392 : /**
393 : * @brief Registers an int variable in the Cubescript ident table.
394 : *
395 : * @param name the name of the aliased variable in Cubescript
396 : * @param min the minimum value the variable can be set at
397 : * @param cur the starting value of the variable
398 : * @param max the maximum value the variable can be set at
399 : * @param storage the pointer to the variable to be aliased to Cubescript
400 : * @param fun a function pointer to be called upon modification of the variable
401 : * @param flags the handling flags for the variable
402 : *
403 : * @return the value cur passed
404 : */
405 : extern int variable(const char *name, int min, int cur, int max, int *storage, identfun fun, int flags);
406 :
407 : /**
408 : * @brief Registers a float variable in the Cubescript ident table.
409 : *
410 : * Adds a float variable to the Cubescript ident table. The name of the Cubescript
411 : * variable does not necessarily need to correspond to the C++ variable's name.
412 : *
413 : * @param name the name of the aliased variable in Cubescript
414 : * @param min the minimum value the variable can be set at
415 : * @param cur the starting value of the variable
416 : * @param max the maximum value the variable can be set at
417 : * @param storage the pointer to the variable to be aliased to Cubescript
418 : * @param fun a function pointer to be called upon modification of the variable
419 : * @param flags the handling flags for the variable
420 : *
421 : * @return the value cur passed
422 : */
423 : extern float fvariable(const char *name, float min, float cur, float max, float *storage, identfun fun, int flags);
424 :
425 : /**
426 : * @brief Registers a C string variable in the Cubescript ident table.
427 : *
428 : * @param name the name of the aliased variable in Cubescript
429 : * @param cur the starting value of the variable
430 : * @param storage the pointer to the pointer to the variable to be aliased to Cubescript
431 : * @param fun a function pointer to be called upon modification of the variable
432 : * @param flags the handling flags for the variable
433 : *
434 : * @return the value cur passed
435 : */
436 : extern char *svariable(const char *name, const char *cur, char **storage, identfun fun, int flags);
437 :
438 : /**
439 : * @brief Sets a Cubescript integer value to the given value.
440 : *
441 : * @param name the name of the cubescript alias to change
442 : * @param i the value to set
443 : * @param dofunc whether to run the onchange function
444 : * @param doclamp whether to clamp the value to the specified limits
445 : */
446 : extern void setvar(const char *name, int i, bool dofunc = true, bool doclamp = true);
447 :
448 : /**
449 : * @brief Sets a Cubescript float value to the given value.
450 : *
451 : * @param name the name of the cubescript alias to change
452 : * @param i the value to set
453 : * @param dofunc whether to run the onchange function
454 : * @param doclamp whether to clamp the value to the specified limits
455 : */
456 : extern void setfvar(const char *name, float f, bool dofunc = true, bool doclamp = true);
457 :
458 : /**
459 : * @brief Sets a Cubescript string value to the given value.
460 : *
461 : * @param name the name of the cubescript alias to change
462 : * @param i the value to set
463 : * @param dofunc whether to run the onchange function
464 : */
465 : extern void setsvar(const char *name, const char *str, bool dofunc = true);
466 :
467 : /**
468 : * @brief Registers a command in the Cubescript ident table.
469 : *
470 : * The arguments of the function passed are cast away, so they are reconstructed using
471 : * the char * string passed to `narg`.
472 : *
473 : * @param name of the command in Cubescript
474 : * @param fun a function pointer to be called when the command is executed
475 : * @param narg string containing the arguments of the function
476 : * @param type the type of the command to create
477 : */
478 : extern bool addcommand(const char *name, identfun fun, const char *narg = "", int type = Id_Command);
479 :
480 : extern std::queue<ident *> triggerqueue; /**< A queue of game events for the engine to process */
481 :
482 : /**
483 : * @brief Returns the pointer to the ident object with the given CS alias.
484 : *
485 : * @param the name of the cubescript object to get
486 : *
487 : * @return The address of the ident object.
488 : */
489 : extern ident *getident(const char *name);
490 : extern int execute(const uint *code);
491 :
492 : /**
493 : * @brief Executes the contents of the string passed.
494 : *
495 : * Parses and executes the line of Cubescript given.
496 : *
497 : * @param p the C string containing the code to execute
498 : *
499 : * @return an int from the results of the execution
500 : */
501 : extern int execute(const char *p);
502 :
503 : /**
504 : * @brief Executes the contents of an ident, searched by name.
505 : *
506 : * Attempts to find in the ident table an ident with the given name, and
507 : * if found executes it.
508 : *
509 : * @param name the name of the ident to look for
510 : * @param noid the value to return if no ident is found
511 : * @param lookup if a command, and parameters are of format 'N', sets to -1
512 : */
513 : extern int execident(const char *name, int noid = 0, bool lookup = false);
514 : extern bool executebool(const uint *code);
515 :
516 : /**
517 : * @brief Executes the contents of the referenced file.
518 : *
519 : * @param cfgfile the relative director of the file to execute
520 : * @param msg whether to print to console a failure message
521 : *
522 : * @return true if the file was successfully loaded
523 : * @return false if the file was not found
524 : */
525 : extern bool execfile(const char *cfgfile, bool msg = true);
526 :
527 : /**
528 : * @brief Replaces C style excape characters with Cubescript ones
529 : *
530 : * The resulting string is also wrapped in quotes ("").
531 : *
532 : * @param s the string to convert
533 : *
534 : * @return a string containing the escaped changes
535 : */
536 : extern const char *escapestring(const char *s);
537 :
538 : /**
539 : * @brief Prints out the formatted variable
540 : *
541 : * The param is intended to represent the value the ident object represents.
542 : *
543 : * @param id the ident object to print out
544 : * @param i the value to print out the variable equalling.
545 : */
546 : extern void printvar(const ident *id, int i);
547 :
548 : /**
549 : * @brief Modifies the value passed to fall within the boundaries passed.
550 : *
551 : * Clamps the value i to within minval and maxval. If hex is passed, warns in hex
552 : * mode, otherwise decimal. If the values are not within bounds, issued aformentioned
553 : * warning, refering to the passed name in the console message.
554 : *
555 : * @param hex toggles whether to display hex warning instead of decimal
556 : * @param name the name
557 : * @param i the value to clamp
558 : * @param minval the lowest value to clamp to
559 : * @param maxval the largest value to clamp to
560 : *
561 : * @return the clamped value
562 : */
563 : extern int clampvar(bool hex, std::string name, int i, int minval, int maxval);
564 : extern void loopiter(ident *id, identstack &stack, int i);
565 : extern void loopend(ident *id, identstack &stack);
566 :
567 : /**
568 : * @brief Escapes a string unless it is null.
569 : *
570 : * If an empty string is passed, escapestring() is not called. Otherwise, the same
571 : * behavior as in escapestring() is executed.
572 : *
573 : * @param s the string to convert
574 : *
575 : * @return a string containing the potentially applied escape changes
576 : */
577 : const char *escapeid(const char *s);
578 :
579 : /**
580 : * @brief Writes out the state of the CubeScript idents to a file.
581 : *
582 : * @param savedconfig the path to write to if name is nullptr
583 : * @param autoexec the path for the autoexec file for user modification, for display in top of file comment
584 : * @param defaultconfig the path for the master copy of the configuration file, for display in top of file comment
585 : * @param name the path to write to, if nullptr savedconfig is used instead
586 : */
587 : extern void writecfg(const char *savedconfig, const char *autoexec = nullptr, const char *defaultconfig = nullptr, const char *name = nullptr);
588 :
589 : /**
590 : * @brief Processes the cubescript sleep queue.
591 : *
592 : * At most, one sleep command is removed from the queue per cycle. Removes
593 : * queued sleep commands as they expire, which stops CS commands from executing
594 : * for a certain period of time.
595 : *
596 : * @param millis the current timestamp
597 : */
598 : extern void checksleep(int millis);
599 :
600 : /**
601 : * @brief Initializes the CubeScript preset argument idents.
602 : *
603 : * Intitializes the argument parameters (arg1, arg2, ..., arg<Max_Args>) as CS
604 : * ident objects. Required to use of $argN variables.
605 : * Also initializes the dummy ident, `//dummy`.
606 : *
607 : * @return always returns true
608 : */
609 : extern bool initidents();
610 :
611 : extern int identflags; /**< The flags to automatically set on ident objects */
612 :
613 : /**
614 : * @brief Clears all aliases from the ident map.
615 : *
616 : * All aliases, aka objects created from within CubeScript, have their contents
617 : * (the names and code values associated with them) freed. Does not remove the
618 : * ident object itself from the global ident map.
619 : */
620 : extern void clear_command();
621 :
622 : // nasty macros for registering script functions, abuses globals to avoid excessive infrastructure
623 :
624 : //* note: many of the VARF comments are very repetitive, because the code itself is nearly duplicated too *//
625 :
626 : /* how command registration works:
627 : * In C++, all global variables must be initiated before main() is called
628 : * Each of these macro kludges (which are placed at the global scope level) initializes some kind of global variable
629 : * Because the macro kludges are the definition of global variables, at program initializiation, they must be run first
630 : * The values of the variables themselves don't matter because they only exist to cheat and run before main()
631 : * The macro kludges themselves register commands or values within some vector<>-s which keeps track of all cmds/vars
632 : */
633 :
634 : /*
635 : * Parameter Flags (exhaustive list, not exhaustive descriptions)
636 : * i an integer parameter
637 : * b a boolean parameter
638 : * f a float parameter (sets to 0 if over parameter limit)
639 : * F a float parameter (sets to value of previous parameter if over parameter limit)
640 : * s a string parameter (sets to new allocated string "" if over parameter limit)
641 : * S a string paremter (sets current string to "" if over parameter limit)
642 : * t sets to null if over parameter limit
643 : * T same as "t"
644 : * e a code block parameter
645 : * E a code block paremter (null)
646 : * r an ident parameter
647 : * $ an ident parameter
648 : * N a number parameter
649 : * D a bind parameter (e.g. player movement), adds a release action for the command
650 : * C an ident parameter, ComC
651 : * V a series of variadic parameter(s) (open ended series of values)
652 : * 1 repeat one arg
653 : * 2 repeat two args
654 : * 3 repeat three args
655 : * 4 repeat four args
656 : */
657 :
658 : //integer var macros
659 : //VAR_, _VARF, VARM_ are templates for "normal" macros that do not execute an inline function
660 : #define VAR_(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, nullptr, persist)
661 : #define VARN(name, global, min, cur, max) VAR_(name, global, min, cur, max, 0)
662 : #define VARNP(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Persist)
663 : #define VARNR(name, global, min, cur, max) VAR_(name, global, min, cur, max, Idf_Override)
664 : #define VAR(name, min, cur, max) VAR_(name, name, min, cur, max, 0)
665 : #define VARP(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Persist)
666 : #define VARR(name, min, cur, max) VAR_(name, name, min, cur, max, Idf_Override)
667 :
668 : //variable with inline function to be executed on change (VARiable with Function = VARF)
669 : #define VARF_(name, global, min, cur, max, body, persist) \
670 : int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
671 :
672 : #define VARFN(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, 0)
673 : #define VARF(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, 0)
674 : #define VARFP(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Persist)
675 : #define VARFR(name, min, cur, max, body) VARF_(name, name, min, cur, max, body, Idf_Override)
676 : #define VARFNP(name, global, min, cur, max, body) VARF_(name, global, min, cur, max, body, Idf_Persist)
677 :
678 : //hexadecimal var macros
679 : #define HVAR_(name, global, min, cur, max, persist) int global = variable(#name, min, cur, max, &global, nullptr, persist | Idf_Hex)
680 : #define HVARP(name, min, cur, max) HVAR_(name, name, min, cur, max, Idf_Persist)
681 :
682 : //hex variable with function to be executed on change (Hexadecimal VARiable with Function = HVARF)
683 : //the CVAR series of macros borrows the HVARF macro as it deals with hex colors
684 : #define HVARF_(name, global, min, cur, max, body, persist) \
685 : int global = variable(#name, min, cur, max, &global, [] (ident *) { body; }, persist | Idf_Hex); /* assign variable, needs fxn prototype declared above */
686 :
687 : //color var macros
688 : #define CVAR_(name, cur, init, body, persist) bvec name = bvec::hexcolor(cur); HVARF_(name, _##name, 0, cur, 0xFFFFFF, { init; name = bvec::hexcolor(_##name); body; }, persist)
689 : #define CVARP(name, cur) CVAR_(name, cur, , , Idf_Persist)
690 : #define CVARR(name, cur) CVAR_(name, cur, , , Idf_Override)
691 : #define CVARFP(name, cur, body) CVAR_(name, cur, , body, Idf_Persist)
692 : #define CVAR0_(name, cur, body, persist) CVAR_(name, cur, { if(!_##name) _##name = cur; }, body, persist)
693 : #define CVAR0R(name, cur) CVAR0_(name, cur, , Idf_Override)
694 : #define CVAR1_(name, cur, body, persist) CVAR_(name, cur, { if(_##name <= 255) _##name |= (_##name<<8) | (_##name<<16); }, body, persist)
695 : #define CVAR1R(name, cur) CVAR1_(name, cur, , Idf_Override)
696 : #define CVAR1FR(name, cur, body) CVAR1_(name, cur, body, Idf_Override)
697 :
698 : //float var macros
699 : #define FVAR_(name, global, min, cur, max, persist) float global = fvariable(#name, min, cur, max, &global, nullptr, persist)
700 : #define FVARNP(name, global, min, cur, max) FVAR_(name, global, min, cur, max, Idf_Persist)
701 : #define FVAR(name, min, cur, max) FVAR_(name, name, min, cur, max, 0)
702 : #define FVARP(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Persist)
703 : #define FVARR(name, min, cur, max) FVAR_(name, name, min, cur, max, Idf_Override)
704 :
705 : //float variable with function to be executed on change (Float VARiable with Function = FVARF)
706 : #define FVARF_(name, global, min, cur, max, body, persist) \
707 : float global = fvariable(#name, min, cur, max, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */ \
708 :
709 : #define FVARF(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, 0)
710 : #define FVARFP(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Persist)
711 : #define FVARFR(name, min, cur, max, body) FVARF_(name, name, min, cur, max, body, Idf_Override)
712 :
713 : //string var macros
714 : #define SVAR_(name, global, cur, persist) char *global = svariable(#name, cur, &global, nullptr, persist)
715 : #define SVAR(name, cur) SVAR_(name, name, cur, 0)
716 : #define SVARP(name, cur) SVAR_(name, name, cur, Idf_Persist)
717 : #define SVARR(name, cur) SVAR_(name, name, cur, Idf_Override)
718 :
719 : //string variable with function to be executed on change (Float VARiable with Function = FVARF)
720 : #define SVARF_(name, global, cur, body, persist) \
721 : char *global = svariable(#name, cur, &global, [] (ident *) { body; }, persist); /* assign variable, needs fxn prototype declared above */
722 :
723 : #define SVARF(name, cur, body) SVARF_(name, name, cur, body, 0)
724 : #define SVARFR(name, cur, body) SVARF_(name, name, cur, body, Idf_Override)
725 :
726 : #endif /* COMMAND_H_ */
|
