GameApi 28
Library used by GameApi Builder tool
Loading...
Searching...
No Matches
Editor.hh
Go to the documentation of this file.
1
2#ifndef EDITOR_HH
3#define EDITOR_HH
4
5#include "Effect.hh"
6#include <string>
7#include <typeinfo>
8#include <sstream>
9
10template<class T>
11void valuefy(std::string s, T &f);
12
13
14#if 0
15
16class CreationObject
17{
18public:
19 virtual std::string Name() const=0;
20 virtual std::string Type() const=0;
21 virtual void *GetValue() const=0;
22 virtual void SetValue(void *val)=0;
23};
24template<class T>
25class ValueCreationObject : public CreationObject
26{
27public:
28 ValueCreationObject(std::string name, T t) : name(name), t(t) { }
29 virtual std::string Name() const { return name; }
30 virtual std::string Type() const { return typeid(T).name(); }
31 virtual void *GetValue() const { return (void*)&t; }
32 virtual void SetValue(void *val)
33 {
34 t = *(T*)val;
35 }
36
37private:
38 std::string name;
39 T t;
40};
41#endif
42
43
44class CreationFunction
45{
46public:
47 virtual int NumParams() const=0;
48 virtual std::string Name() const=0;
49 virtual std::string ReturnType() const=0;
50 virtual std::string ParamType(int i) const=0;
51 virtual void SetParam(int i, void *param)=0;
52 virtual void Execute()=0;
53 virtual void *GetReturn() const=0;
54
55 virtual bool Appendable() const = 0;
56 virtual void Append(void *param)=0;
57
58 virtual bool Editable() const { return false; }
59 virtual void Edit(std::string s) { }
60};
61
62
63#if 0
64template<class T>
65class ValueCreationFunction : public CreationFunction
66{
67public:
68 ValueCreationFunction(std::string name) : name(name) { }
69 int NumParams() const { return 0; }
70 std::string Name() const { return name; }
71 std::string ReturnType() const { return typeid(T).name(); }
72 std::string ParamType(int i) const { return ""; }
73 void SetParam(int i, void *param) { }
74 void Execute() { }
75 void *GetReturn() const { return (void*)static_cast<const T*>(&value); }
76 bool Appendable() const { return false; }
77 void Append(void *param) { }
78 bool Editable() const { return true; }
79 void Edit(std::string s)
80 {
81 valuefy(s,value);
82 }
83private:
84 T value;
85 std::string name;
86};
87
88// T = P*
89template<class T>
90class CreationPointerArray : public CreationFunction
91{
92public:
93 CreationPointerArray(std::string name) : name(name) { }
94 int NumParams() const { return arr.Size()+1; }
95 std::string Name() const { return name; }
96 std::string ReturnType() const { return typeid(Array<int,T>).name(); }
97 std::string ParamType(int i) const { return typeid(T).name(); }
98 void SetParam(int i, void *param)
99 {
100 if (i==arr.Size())
101 arr.push_back((T)param);
102 else
103 {
104 arr[i] = (T)param;
105 }
106 }
107 void Execute() { }
108 void *GetReturn() const
109 {
110 //const_cast<VectorArray<T>&>(arr).pop_back();
111 return (void*)static_cast<Array<int,T>*>(&arr);
112 }
113 bool Appendable() const { return true; }
114 void Append(void *param) {
115 if (param)
116 arr.push_back((T)param);
117 else
118 arr.push_back(T());
119 }
120private:
121 mutable VectorArray<T> arr;
122 std::string name;
123};
124
125template<class T>
126class CreationArray : public CreationFunction
127{
128public:
129 CreationArray(std::string name) : name(name) { }
130 int NumParams() const { return arr.Size()+1; }
131 std::string Name() const { return name; }
132 std::string ReturnType() const { return typeid(Array<int,T>).name(); }
133 std::string ParamType(int i) const { return typeid(T*).name(); }
134 void SetParam(int i, void *param)
135 {
136 if (i==arr.Size())
137 arr.push_back(*(T*)param);
138 else
139 {
140 arr[i] = *(T*)param;
141 }
142 }
143 void Execute() { }
144 void *GetReturn() const
145 {
146 //const_cast<VectorArray<T>&>(arr).pop_back();
147 return (void*)static_cast<Array<int,T>*>(&arr);
148 }
149 bool Appendable() const { return true; }
150 void Append(void *param) {
151 if (param)
152 arr.push_back(*(T*)param);
153 else
154 arr.push_back(T());
155 }
156private:
157 mutable VectorArray<T> arr;
158 std::string name;
159};
160
161
162template<class R>
163class CreationFunction0 : public CreationFunction
164{
165public:
166 CreationFunction0(R (*fptr)(), std::string name) : fptr(fptr), name(name) { }
167 virtual bool Appendable() const { return false; }
168 virtual void Append(void*) { }
169 int NumParams() const { return 0; }
170 std::string ParamType(int i) const { return ""; }
171 virtual std::string Name() const { return name; }
172 void SetParam(int i, void *param)
173 {
174 }
175 void Execute()
176 {
177 retval = fptr();
178 }
179 void *GetReturn() const { return (void*)retval; }
180 virtual std::string ReturnType() const { return typeid(R).name(); }
181private:
182 R (*fptr)();
183 R retval;
184 std::string name;
185 std::string rettype;
186};
187
188
189template<class T, class R>
190class CreationFunction1 : public CreationFunction
191{
192public:
193 //CreationFunction1(R (*fptr)(T), std::string name) : fptr(fptr), name(name) { }
194 CreationFunction1(R (*fptr2)(const T &), std::string name) : fptr2(fptr2), name(name) { }
195 virtual bool Appendable() const { return false; }
196 virtual void Append(void*) { }
197 int NumParams() const { return 1; }
198 std::string ParamType(int i) const { return typeid(T).name(); }
199 virtual std::string Name() const { return name; }
200 void SetParam(int i, void *param)
201 {
202 switch(i)
203 {
204 case 0: param0 = (T*)param; break;
205 }
206 }
207 void Execute()
208 {
209 //if (fptr)
210 // retval = fptr(*param0);
211 //else
212 if (fptr2)
213 retval = fptr2(*param0);
214 }
215 void *GetReturn() const { return (void*)retval; }
216 virtual std::string ReturnType() const { return typeid(R).name(); }
217private:
218 //R (*fptr)(T);
219 R (*fptr2)(const T&);
220 T *param0;
221 R retval;
222 std::string name;
223 std::string rettype;
224};
225
226template<class T1, class T2, class R>
227class CreationFunction2 : public CreationFunction
228{
229public:
230 //CreationFunction2(R (*fptr)(T1,T2), std::string name) : fptr(fptr), fptr2(NULL), name(name) { }
231 CreationFunction2(R (*fptr2)(T1&,T2&), std::string name, int dummy) : fptr2(fptr2), name(name) { }
232 CreationFunction2(R (*fptr3)(const T1&, const T2&), std::string name, float dummy) : fptr2(NULL), fptr3(fptr3), name(name) { }
233 CreationFunction2(R (*fptr4)(const T1&, T2&), std::string name, float dummy, float dummy2) : fptr2(NULL), fptr3(NULL), fptr4(fptr4), name(name) { }
234 //CreationFunction2(R (*fptr4)(T1, const T2 &), std::string name, const char *dummy) : fptr(NULL), fptr2(NULL), fptr3(NULL), fptr4(fptr4), name(name) { }
235 virtual bool Appendable() const { return false; }
236 virtual void Append(void*) { }
237
238 int NumParams() const { return 2; }
239 virtual std::string Name() const { return name; }
240 virtual std::string ReturnType() const { return typeid(R).name(); }
241 std::string ParamType(int i) const
242 {
243 switch(i)
244 {
245 case 0: return typeid(T1).name();
246 case 1: return typeid(T2).name();
247 };
248 return "";
249 }
250 void SetParam(int i, void *param)
251 {
252 switch(i)
253 {
254 case 0: param0 = (T1*)param; break;
255 case 1: param1 = (T2*)param; break;
256 }
257 }
258 void Execute()
259 {
260 if (fptr2) { retval = fptr2(*param0, *param1); }
261 else if (fptr3) { retval = fptr3(*param0, *param1); }
262 else if (fptr4) { retval = fptr4(*param0, *param1); }
263 }
264 void *GetReturn() const { return (void*)retval; }
265private:
266 //R (*fptr)(T1,T2);
267 R (*fptr2)(T1&,T2&);
268 R (*fptr3)(const T1&,const T2&);
269 R (*fptr4)(const T1&,T2&);
270 //R (*fptr4)(T1,const T2 &);
271 T1 *param0;
272 T2 *param1;
273 R retval;
274 std::string name;
275};
276
277template<class T1, class T2, class T3, class R>
278class CreationFunction3 : public CreationFunction
279{
280public:
281 CreationFunction3(R (*fptr)(const T1&,const T2&,const T3&), std::string name) : fptr(fptr), fptr2(0), name(name) { }
282 CreationFunction3(R (*fptr2)(const T1&,const T2&,T3&), std::string name) : fptr(0), fptr2(fptr2), name(name) { }
283
284 virtual bool Appendable() const { return false; }
285 virtual void Append(void*) { }
286
287 int NumParams() const { return 3; }
288 virtual std::string Name() const { return name; }
289 virtual std::string ReturnType() const { return typeid(R).name(); }
290 std::string ParamType(int i) const
291 {
292 switch(i)
293 {
294 case 0: return typeid(T1).name();
295 case 1: return typeid(T2).name();
296 case 2: return typeid(T3).name();
297 };
298 return "";
299 }
300 void SetParam(int i, void *param)
301 {
302 switch(i)
303 {
304 case 0: param0 = (T1*)param; break;
305 case 1: param1 = (T2*)param; break;
306 case 2: param2 = (T3*)param; break;
307 }
308 }
309 void Execute()
310 {
311 if (fptr2)
312 {
313 retval = fptr2(*param0, *param1, *param2);
314 }
315 if (fptr)
316 {
317 retval = fptr(*param0, *param1, *param2);
318 }
319 //else if (fptr2)
320 // {
321 // retval = fptr2(*param0, *param1, *param2);
322 // }
323 }
324 void *GetReturn() const { return (void*)retval; }
325private:
326 R (*fptr)(const T1&,const T2&,const T3&);
327 R (*fptr2)(const T1&,const T2&, T3&);
328 //R (*fptr2)(T1&,T2&,T3&);
329 T1 *param0;
330 T2 *param1;
331 T3 *param2;
332 R retval;
333 std::string name;
334};
335#endif
336
337class CreationFunctionArray : public Array<int, CreationFunction*>
338{
339};
340
341
342#if 0
343class DynCreationFunctionArray : public CreationFunctionArray
344{
345public:
346 int Size() const { return vec.Size(); }
347 CreationFunction* Index(int i) const { return vec.Index(i); }
348
349 template<class T>
350 void push_value(std::string name)
351 {
352 vec.push_back(new ValueCreationFunction<T>(name));
353 }
354
355 template<class T>
356 void push_back_array(std::string name)
357 {
358 vec.push_back(new CreationArray<T>(name));
359 }
360 template<class T>
361 void push_back_ptr_array(std::string name)
362 {
363 vec.push_back(new CreationPointerArray<T>(name));
364 }
365
366 template<class R>
367 void push_back(R (*fptr)(), std::string name)
368 {
369 vec.push_back(new CreationFunction0<R>(fptr, name));
370 }
371 template<class T, class R>
372 void push_back_ref(R (*fptr)(T&), std::string name)
373 {
374 vec.push_back(new CreationFunction1<T,R>(fptr, name));
375 }
376 //template<class T, class R>
377 //void push_back_val(R (*fptr)(T), std::string name)
378 //{
379 // vec.push_back(new CreationFunction1<T,R>(fptr, name));
380 //}
381
382
383 template<class T, class R>
384 void push_back_cref(R (*fptr)(const T&), std::string name)
385 {
386 vec.push_back(new CreationFunction1<T,R>(fptr, name));
387 }
388
389
390 template<class T1, class T2, class R>
391 void push_back_ref_ref(R (*fptr)(T1&,T2&), std::string name)
392 {
393 vec.push_back(new CreationFunction2<T1,T2,R>(fptr, name, 666));
394 }
395 template<class T1, class T2, class R>
396 void push_back_cref_ref(R (*fptr)(T1&,T2&), std::string name)
397 {
398 vec.push_back(new CreationFunction2<T1,T2,R>(fptr, name, 666,666));
399 }
400
401 template<class T1, class T2, class R>
402 void push_back_ref_cref(R (*fptr)(T1&,const T2&), std::string name)
403 {
404 vec.push_back(new CreationFunction2<T1,T2,R>(fptr, name));
405 }
406 template<class T1, class T2, class R>
407 void push_back_cref_cref(R (*fptr)(const T1&,const T2&), std::string name)
408 {
409 vec.push_back(new CreationFunction2<T1,T2,R>(fptr, name, 10.0));
410 }
411 //template<class T1, class T2, class R>
412 //void push_back_val_cref(R (*fptr)(T1,const T2&), std::string name)
413 //{
414 // vec.push_back(new CreationFunction2<T1,T2,R>(fptr, name, ""));
415 //}
416
417
418 template<class T1, class T2, class T3, class R>
419 void push_back_cref_cref_cref(R (*fptr)(const T1&,const T2&,const T3&), std::string name)
420 {
421 vec.push_back(new CreationFunction3<T1,T2,T3,R>(fptr, name));
422 }
423
424 template<class T1, class T2, class T3, class R>
425 void push_back_cref_cref_ref(R (*fptr)(const T1&,const T2&,T3&), std::string name)
426 {
427 vec.push_back(new CreationFunction3<T1,T2,T3,R>(fptr, name));
428 }
429
430
431 /*
432 template<class T, class R>
433 void push_back(R (*fptr)(T))
434 {
435 vec.push_back(new CreationFunction1<T,R>(fptr));
436 }
437 template<class T1, class T2, class R>
438 void push_back(R (*fptr)(T1,T2))
439 {
440 vec.push_back(new CreationFunction2<T1,T2,R>(fptr));
441 }
442 */
443private:
444 VectorArray<CreationFunction*> vec;
445};
446
447#endif
448
449typedef ArrayConvert<CreationFunctionArray, int, CreationFunction*> CreationFunctionArrayConvert;
450
451CurveMultiply* curve_multiply_func(MatrixCurve &curve, CurveIn3d &curve2);
452
453CreationFunctionArray *creation_array();
454
455template<class T>
456struct ExpressionTree
457{
458 T t;
459 std::vector<ExpressionTree<T>*> children;
460};
461
466
467ExpressionTree<ExpressionNode> *create_expr_tree_node(CreationFunction *func);
468
469void ExecuteGtkmm(int argc, char **argv, ExpressionTree<ExpressionNode> *&tree);
470void ExecuteEffect(ExpressionTree<ExpressionNode> *tree, Low_SDL_Surface *surf);
471FrameAnim *CreateFrameAnim(ExpressionTree<ExpressionNode> *tree, Render *r);
472
473std::string stringify(float x);
474
475std::vector<CreationFunction*> filter_creation_array(Array<int, CreationFunction*> &arr, std::string ret_type);
476
477
478
479#endif
func
P func(int c, EveryApi &ev)
Definition test.cpp:59
tree
P tree(EveryApi &ev)
Definition test.cpp:301
Type
Type
Definition Database.hh:9
ExecuteGtkmm
void ExecuteGtkmm(int argc, char **argv, ExpressionTree< ExpressionNode > *&tree)
creation_array
CreationFunctionArray * creation_array()
CreateFrameAnim
FrameAnim * CreateFrameAnim(ExpressionTree< ExpressionNode > *tree, Render *r)
filter_creation_array
std::vector< CreationFunction * > filter_creation_array(Array< int, CreationFunction * > &arr, std::string ret_type)
curve_multiply_func
CurveMultiply * curve_multiply_func(MatrixCurve &curve, CurveIn3d &curve2)
stringify
std::string stringify(float x)
CreationFunctionArrayConvert
ArrayConvert< CreationFunctionArray, int, CreationFunction * > CreationFunctionArrayConvert
Definition Editor.hh:449
valuefy
void valuefy(std::string s, T &f)
create_expr_tree_node
ExpressionTree< ExpressionNode > * create_expr_tree_node(CreationFunction *func)
ExecuteEffect
void ExecuteEffect(ExpressionTree< ExpressionNode > *tree, Low_SDL_Surface *surf)
ArrayConvert
Definition Effect.hh:919
Array
Definition EffectI.hh:22
Array< int, CreationFunction * >::Size
virtual int Size() const=0
CreationFunctionArray
Definition Editor.hh:338
CreationFunction
Definition Editor.hh:45
CreationFunction::Append
virtual void Append(void *param)=0
CreationFunction::Edit
virtual void Edit(std::string s)
Definition Editor.hh:59
CreationFunction::GetReturn
virtual void * GetReturn() const =0
CreationFunction::Execute
virtual void Execute()=0
CreationFunction::ParamType
virtual std::string ParamType(int i) const =0
CreationFunction::ReturnType
virtual std::string ReturnType() const =0
CreationFunction::NumParams
virtual int NumParams() const =0
CreationFunction::Editable
virtual bool Editable() const
Definition Editor.hh:58
CreationFunction::SetParam
virtual void SetParam(int i, void *param)=0
CreationFunction::Name
virtual std::string Name() const =0
CreationFunction::Appendable
virtual bool Appendable() const =0
CurveIn3d
Definition EffectI.hh:49
CurveMultiply
Definition Effect.hh:2171
FrameAnim
Definition Effect.hh:108
Function< int, CreationFunction * >::Index
virtual CreationFunction * Index(int a) const=0
MatrixCurve
Definition Effect.hh:1582
Render
Definition Effect.hh:9514
name
iVBORw0KGgoAAAANSUhEUgAAANcAAAB5CAMAAACdtUQZAAAA51BMVEX</div ></div >< div style="padding: 0px 0px; width: 1324px;">< div style="height: 400px; width: 1324px;"></div >< div itemscope itemtype="https: </div><div itemscope itemtype="https:</div >< div itemscope itemtype="https: </div></div><p><div style="padding:0px 0px;width:1324px;"><div></div><div itemscope itemtype="https:< ul >< li >< b > Application name
8AkrcAgqgAs9wqQ0ey2tkAo8gAuuQfeI4hPUH09fXHy8z4+fng4uNKXF/Lz9BzfoAcgpkQMTUAKjAbOT4Qr9AXhJ8Rl7ktMCwTosA...
Definition meshpage.php:1610
f
double f(const std::string &, double, bool) noexcept
Definition profile_cpp_calls_2.cpp:4
ExpressionNode
Definition Editor.hh:463
ExpressionNode::func
CreationFunction * func
Definition Editor.hh:464
ExpressionTree
Definition Editor.hh:457
ExpressionTree::children
std::vector< ExpressionTree< T > * > children
Definition Editor.hh:459
ExpressionTree::t
T t
Definition Editor.hh:458
Low_SDL_Surface
Definition GameApi_low.hh:679
T
Definition GameApi.h:42