home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / unofficial-plug-ins / mathmap / macros.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-26  |  7.5 KB  |  274 lines
  1. /*
  2.  * macros.c
  3.  *
  4.  * MathMap
  5.  *
  6.  * Copyright (C) 1997-2000 Mark Probst
  7.  *
  8.  * This program is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU General Public License
  10.  * as published by the Free Software Foundation; either version 2
  11.  * of the License, or (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <assert.h>
  26.  
  27. #include <libgimp/gimp.h>
  28.  
  29. #include "postfix.h"
  30. #include "internals.h"
  31. #include "tags.h"
  32. #include "exprtree.h"
  33. #include "overload.h"
  34.  
  35. #include "macros.h"
  36.  
  37. static var_macro_t *first = 0;
  38.  
  39. void
  40. register_variable_macro (const char *name,  macro_function_t function, tuple_info_t info)
  41. {
  42.     var_macro_t *macro = (var_macro_t*)malloc(sizeof(var_macro_t));
  43.  
  44.     strncpy(macro->name, name, MAX_MACRO_LENGTH);
  45.     macro->name[MAX_MACRO_LENGTH] = '\0';
  46.     macro->info = info;
  47.     macro->function = function;
  48.  
  49.     macro->next = first;
  50.     first = macro;
  51. }
  52.  
  53. macro_function_t
  54. lookup_variable_macro (const char *name, tuple_info_t *info)
  55. {
  56.     var_macro_t *macro;
  57.  
  58.     for (macro = first; macro != 0; macro = macro->next)
  59.     if (strcmp(macro->name, name) == 0)
  60.     {
  61.         *info = macro->info;
  62.         return macro->function;
  63.     }
  64.  
  65.     return 0;
  66. }
  67.  
  68. exprtree*
  69. macro_var_x (exprtree *args)
  70. {
  71.     return make_select(make_var("xy"), make_number(0));
  72. }
  73.  
  74. exprtree*
  75. macro_var_y (exprtree *args)
  76. {
  77.     return make_select(make_var("xy"), make_number(1));
  78. }
  79.  
  80. exprtree*
  81. macro_var_r (exprtree *args)
  82. {
  83.     return make_select(make_var("ra"), make_number(0));
  84. }
  85.  
  86. exprtree*
  87. macro_var_a (exprtree *args)
  88. {
  89.     return make_select(make_var("ra"), make_number(1));
  90. }
  91.  
  92. exprtree*
  93. macro_var_big_x (exprtree *args)
  94. {
  95.     return make_select(make_var("XY"), make_number(0));
  96. }
  97.  
  98. exprtree*
  99. macro_var_big_y (exprtree *args)
  100. {
  101.     return make_select(make_var("XY"), make_number(1));
  102. }
  103.  
  104. exprtree*
  105. macro_var_big_w (exprtree *args)
  106. {
  107.     return make_select(make_var("WH"), make_number(0));
  108. }
  109.  
  110. exprtree*
  111. macro_var_big_h (exprtree *args)
  112. {
  113.     return make_select(make_var("WH"), make_number(1));
  114. }
  115.  
  116. exprtree*
  117. macro_var_pi (exprtree *args)
  118. {
  119.     return make_number(G_PI);
  120. }
  121.  
  122. exprtree*
  123. macro_func_origVal (exprtree *args)
  124. {
  125.     return make_function("origVal", exprlist_append(make_function("toXY", args),
  126.                             make_cast("image", make_number(0))));
  127. }
  128.  
  129. exprtree*
  130. macro_func_origValImage (exprtree *args)
  131. {
  132.     variable_t *tmpvar = new_temporary_variable(args->result);
  133.  
  134.     return make_sequence(make_assignment(tmpvar->name, args),
  135.              make_function("origVal", exprlist_append(make_function("toXY", make_var(tmpvar->name)),
  136.                                   args->next)));
  137. }
  138.  
  139. exprtree*
  140. macro_func_origValXY (exprtree *args)
  141. {
  142.     return make_function("origVal", make_cast("xy", make_tuple(args)));
  143. }
  144.  
  145. exprtree*
  146. macro_func_origValRA (exprtree *args)
  147. {
  148.     return make_function("origVal", make_cast("ra", make_tuple(args)));
  149. }
  150.  
  151. exprtree*
  152. macro_func_red (exprtree *arg)
  153. {
  154.     return make_select(arg, make_number(0));
  155. }
  156.  
  157. exprtree*
  158. macro_func_green (exprtree *arg)
  159. {
  160.     return make_select(arg, make_number(1));
  161. }
  162.  
  163. exprtree*
  164. macro_func_blue (exprtree *arg)
  165. {
  166.     return make_select(arg, make_number(2));
  167. }
  168.  
  169. exprtree*
  170. macro_func_alpha (exprtree *arg)
  171. {
  172.     return make_select(arg, make_number(3));
  173. }
  174.  
  175. exprtree*
  176. macro_func_rgbColor (exprtree *args)
  177. {
  178.     return make_cast("rgba", make_tuple(exprlist_append(args, make_number(1.0))));
  179. }
  180.  
  181. exprtree*
  182. macro_func_rgbaColor (exprtree *args)
  183. {
  184.     return make_cast("rgba", make_tuple(args));
  185. }
  186.  
  187. exprtree*
  188. macro_func_grayColor (exprtree *arg)
  189. {
  190.     variable_t *tmpvar = new_temporary_variable(arg->result);
  191.  
  192.     return make_sequence(make_assignment(tmpvar->name, arg),
  193.              make_cast("rgba",
  194.                    make_tuple(exprlist_append(make_var(tmpvar->name),
  195.                                   exprlist_append(make_var(tmpvar->name),
  196.                                           exprlist_append(make_var(tmpvar->name),
  197.                                                   make_number(1.0)))))));
  198. }
  199.  
  200. exprtree*
  201. macro_func_grayaColor (exprtree *arg)
  202. {
  203.     variable_t *tmpvar = new_temporary_variable(arg->result);
  204.  
  205.     return make_sequence(make_assignment(tmpvar->name, arg),
  206.              make_cast("rgba",
  207.                    make_tuple(exprlist_append(make_var(tmpvar->name),
  208.                                   exprlist_append(make_var(tmpvar->name),
  209.                                           exprlist_append(make_var(tmpvar->name),
  210.                                                   arg->next))))));
  211. }
  212.  
  213. exprtree*
  214. macro_func_toXY (exprtree *arg)
  215. {
  216.     return arg;
  217. }
  218.  
  219. exprtree*
  220. macro_func_toRA (exprtree *arg)
  221. {
  222.     return arg;
  223. }
  224.  
  225. exprtree*
  226. macro_func_curve (exprtree *arg)
  227. {
  228.     return make_userval("user_curve", "curve", arg);
  229. }
  230.  
  231. void
  232. init_macros (void)
  233. {
  234.     register_variable_macro("x", macro_var_x, make_tuple_info(nil_tag_number, 1));
  235.     register_variable_macro("y", macro_var_y, make_tuple_info(nil_tag_number, 1));
  236.     register_variable_macro("r", macro_var_r, make_tuple_info(nil_tag_number, 1));
  237.     register_variable_macro("a", macro_var_a, make_tuple_info(nil_tag_number, 1));
  238.     register_variable_macro("X", macro_var_big_x, make_tuple_info(nil_tag_number, 1));
  239.     register_variable_macro("Y", macro_var_big_y, make_tuple_info(nil_tag_number, 1));
  240.     register_variable_macro("W", macro_var_big_w, make_tuple_info(nil_tag_number, 1));
  241.     register_variable_macro("H", macro_var_big_h, make_tuple_info(nil_tag_number, 1));
  242.  
  243.     register_variable_macro("pi", macro_var_pi, make_tuple_info(nil_tag_number, 1));
  244.  
  245.     register_overloaded_macro("origVal", "((rgba 4) (xy 2))", macro_func_origVal);
  246.     register_overloaded_macro("origVal", "((rgba 4) (ra 2))", macro_func_origVal);
  247.     register_overloaded_macro("origVal", "((rgba 4) (ra 2) (image 1))", macro_func_origValImage);
  248.     register_overloaded_macro("origValIntersample", "((rgba 4) (xy 2))", macro_func_origVal);
  249.     register_overloaded_macro("origValIntersample", "((rgba 4) (ra 2))", macro_func_origVal);
  250.     register_overloaded_macro("origValIntersample", "((rgba 4) (ra 2) (image 1))", macro_func_origValImage);
  251.     register_overloaded_macro("origValXY", "((rgba 4) (T 1) (T 1))", macro_func_origValXY);
  252.     register_overloaded_macro("origValRA", "((rgba 4) (T 1) (T 1))", macro_func_origValRA);
  253.  
  254.     register_overloaded_macro("red", "((nil 1) (rgba 4))", macro_func_red);
  255.     register_overloaded_macro("green", "((nil 1) (rgba 4))", macro_func_green);
  256.     register_overloaded_macro("blue", "((nil 1) (rgba 4))", macro_func_blue);
  257.     register_overloaded_macro("alpha", "((nil 1) (rgba 4))", macro_func_alpha);
  258.  
  259.     register_overloaded_macro("red", "((nil 1) (rgba 4))", macro_func_red);
  260.     register_overloaded_macro("green", "((nil 1) (rgba 4))", macro_func_green);
  261.     register_overloaded_macro("blue", "((nil 1) (rgba 4))", macro_func_blue);
  262.     register_overloaded_macro("alpha", "((nil 1) (rgba 4))", macro_func_alpha);
  263.  
  264.     register_overloaded_macro("rgbColor", "((rgba 4) (T 1) (T 1) (T 1))", macro_func_rgbColor);
  265.     register_overloaded_macro("rgbaColor", "((rgba 4) (T 1) (T 1) (T 1) (T 1))", macro_func_rgbaColor);
  266.     register_overloaded_macro("grayColor", "((rgba 4) (T 1))", macro_func_grayColor);
  267.     register_overloaded_macro("grayaColor", "((rgba 4) (T 1) (T 1))", macro_func_grayaColor);
  268.  
  269.     register_overloaded_macro("toXY", "((xy 2) (xy 2))", macro_func_toXY);
  270.     register_overloaded_macro("toRA", "((ra 2) (ra 2))", macro_func_toRA);
  271.  
  272.     register_overloaded_macro("curve", "((nil 1) (_ 1))", macro_func_curve);
  273. }
  274.