1 | // This file is a part of the Framsticks GDK. |
---|
2 | // Copyright (C) 1999-2014 Maciej Komosinski and Szymon Ulatowski. See LICENSE.txt for details. |
---|
3 | // Refer to http://www.framsticks.com/ for further information. |
---|
4 | |
---|
5 | #include <frams/util/3d.h> |
---|
6 | #include "3dobject.h" |
---|
7 | #include <frams/param/param.h> |
---|
8 | #include "collectionobj.h" |
---|
9 | |
---|
10 | ParamEntry* Pt3D_Ext::getStaticParamtab() |
---|
11 | { |
---|
12 | #define FIELDSTRUCT Pt3D_Ext |
---|
13 | static ParamEntry paramtab[]= |
---|
14 | { |
---|
15 | {"XYZ",1,18,"XYZ","3D vector"}, |
---|
16 | |
---|
17 | {"x",0,PARAM_NOSTATIC,"x","f",FIELD(p.x),}, |
---|
18 | {"y",0,PARAM_NOSTATIC,"y","f",FIELD(p.y),}, |
---|
19 | {"z",0,PARAM_NOSTATIC,"z","f",FIELD(p.z),}, |
---|
20 | {"new",0,0,"create new XYZ object","p oXYZ(f x,f y,f z)",PROCEDURE(p_new),"3D vectors objects can be also created using the (x,y,z) notation, i.e. var v=(1,2,3) is the same as var v=XYZ.new(1,2,3);",}, |
---|
21 | {"newFromVector",0,0,"create new XYZ object","p oXYZ(oVector)",PROCEDURE(p_newFromVector),"used for deserialization"}, |
---|
22 | {"clone",0,PARAM_NOSTATIC,"create new XYZ object copying the coordinates","p oXYZ()",PROCEDURE(p_clone),"Note: copying object references does not create new objects. Use clone() if a new object is needed.\n\nExample:\nvar o1=(1,2,3), o2=o1, o3=o1.clone();\no1.y=9999;\n//o2 is now (1,9999,3) but o3 is still (1,2,3)",}, |
---|
23 | {"set",0,PARAM_NOSTATIC,"set (copy) coordinates from another XYZ object","p(oXYZ)",PROCEDURE(p_set),}, |
---|
24 | {"set3",0,PARAM_NOSTATIC,"set individual 3 coordinates","p(f x,f y,f z)",PROCEDURE(p_set3),}, |
---|
25 | {"add",0,PARAM_NOSTATIC,"add","p(oXYZ)",PROCEDURE(p_addvec),"Note: it does not return a new object, just modifies the existing one"}, |
---|
26 | {"sub",0,PARAM_NOSTATIC,"subtract","p(oXYZ)",PROCEDURE(p_subvec),"Note: it does not return a new object, just modifies the existing one"}, |
---|
27 | {"scale",0,PARAM_NOSTATIC,"multiply by scalar","p(f)",PROCEDURE(p_scale),}, |
---|
28 | {"length",0,PARAM_READONLY | PARAM_NOSTATIC,"length","f",GETONLY(length),}, |
---|
29 | {"normalize",0,PARAM_NOSTATIC,"normalize","p()",PROCEDURE(p_normalize),"scales the vector length to 1.0"}, |
---|
30 | {"toString",0,PARAM_READONLY | PARAM_NOSTATIC,"textual form","s",GETONLY(toString),}, |
---|
31 | {"toVector",0,PARAM_READONLY | PARAM_NOSTATIC,"vector of [x,y,z]","oVector",GETONLY(toVector),}, |
---|
32 | {"rotate",0,PARAM_NOSTATIC,"rotate using Orient object","p(oOrient)",PROCEDURE(p_rotate),}, |
---|
33 | {"revRotate",0,PARAM_NOSTATIC,"reverse rotate using Orient object","p(oOrient)",PROCEDURE(p_revrotate),}, |
---|
34 | {"get",0,PARAM_NOSTATIC,"get one of coordinates","p f(d index)",PROCEDURE(p_get),"this function makes the XYZ objects \"indexable\" (so you can use [] for accessing subsequent fields, like in Vector)",}, |
---|
35 | {0,0,0,}, |
---|
36 | }; |
---|
37 | #undef FIELDSTRUCT |
---|
38 | return paramtab; |
---|
39 | } |
---|
40 | |
---|
41 | void Pt3D_Ext::p_new(ExtValue *args,ExtValue *ret) |
---|
42 | { |
---|
43 | *ret=makeDynamicObject(new Pt3D_Ext(args[2].getDouble(),args[1].getDouble(),args[0].getDouble())); |
---|
44 | } |
---|
45 | |
---|
46 | static double doubleFromVec(VectorObject *vec,int i) |
---|
47 | { |
---|
48 | if (i>=vec->data.size()) return 0; |
---|
49 | ExtValue *v=(ExtValue*)vec->data.get(i); |
---|
50 | if (v) |
---|
51 | return v->getDouble(); |
---|
52 | return 0; |
---|
53 | } |
---|
54 | |
---|
55 | static Pt3D pt3DFromVec(VectorObject* v,int offset=0) |
---|
56 | { |
---|
57 | return Pt3D(doubleFromVec(v,offset),doubleFromVec(v,offset+1),doubleFromVec(v,offset+2)); |
---|
58 | } |
---|
59 | |
---|
60 | void Pt3D_Ext::p_newFromVector(ExtValue *args,ExtValue *ret) |
---|
61 | { |
---|
62 | VectorObject *vec=VectorObject::fromObject(args->getObject()); |
---|
63 | if (vec) |
---|
64 | *ret=makeDynamicObject(new Pt3D_Ext(pt3DFromVec(vec))); |
---|
65 | else |
---|
66 | ret->setEmpty(); |
---|
67 | } |
---|
68 | |
---|
69 | void Pt3D_Ext::p_clone(ExtValue *args,ExtValue *ret) |
---|
70 | { |
---|
71 | *ret=makeDynamicObject(new Pt3D_Ext(p.x,p.y,p.z)); |
---|
72 | } |
---|
73 | |
---|
74 | void Pt3D_Ext::p_set3(ExtValue *args,ExtValue *ret) |
---|
75 | { |
---|
76 | p.x=args[2].getDouble(); |
---|
77 | p.y=args[1].getDouble(); |
---|
78 | p.z=args[0].getDouble(); |
---|
79 | ret->setEmpty(); |
---|
80 | } |
---|
81 | |
---|
82 | void Pt3D_Ext::p_set(ExtValue *args,ExtValue *ret) |
---|
83 | { |
---|
84 | Pt3D_Ext *other=fromObject(args[0]); |
---|
85 | if (other) |
---|
86 | p=other->p; |
---|
87 | ret->setEmpty(); |
---|
88 | } |
---|
89 | |
---|
90 | void Pt3D_Ext::get_length(ExtValue *ret) |
---|
91 | { |
---|
92 | ret->setDouble(p.length()); |
---|
93 | } |
---|
94 | |
---|
95 | void Pt3D_Ext::get_toString(ExtValue *ret) |
---|
96 | { |
---|
97 | SString s="("; |
---|
98 | ExtValue v; |
---|
99 | v.setDouble(p.x); s+=v.getString(); |
---|
100 | s+=","; |
---|
101 | v.setDouble(p.y); s+=v.getString(); |
---|
102 | s+=","; |
---|
103 | v.setDouble(p.z); s+=v.getString(); |
---|
104 | s+=")"; |
---|
105 | ret->setString(s); |
---|
106 | } |
---|
107 | |
---|
108 | static void add3Coords(VectorObject* vec,const Pt3D& p) |
---|
109 | { |
---|
110 | vec->data+=new ExtValue(p.x); |
---|
111 | vec->data+=new ExtValue(p.y); |
---|
112 | vec->data+=new ExtValue(p.z); |
---|
113 | } |
---|
114 | |
---|
115 | void Pt3D_Ext::get_toVector(ExtValue *ret) |
---|
116 | { |
---|
117 | VectorObject *vec=new VectorObject; |
---|
118 | add3Coords(vec,p); |
---|
119 | ret->setObject(ExtObject(&VectorObject::par,vec)); |
---|
120 | } |
---|
121 | |
---|
122 | void Pt3D_Ext::p_addvec(ExtValue *args,ExtValue *ret) |
---|
123 | { |
---|
124 | Pt3D_Ext *other=fromObject(args[0]); |
---|
125 | if (other) |
---|
126 | p+=other->p; |
---|
127 | ret->setEmpty(); |
---|
128 | } |
---|
129 | |
---|
130 | void Pt3D_Ext::p_subvec(ExtValue *args,ExtValue *ret) |
---|
131 | { |
---|
132 | Pt3D_Ext *other=fromObject(args[0]); |
---|
133 | if (other) |
---|
134 | p-=other->p; |
---|
135 | ret->setEmpty(); |
---|
136 | } |
---|
137 | |
---|
138 | void Pt3D_Ext::p_scale(ExtValue *args,ExtValue *ret) |
---|
139 | { |
---|
140 | double d=args[0].getDouble(); |
---|
141 | p.x*=d; p.y*=d; p.z*=d; |
---|
142 | ret->setEmpty(); |
---|
143 | } |
---|
144 | |
---|
145 | void Pt3D_Ext::p_normalize(ExtValue *args,ExtValue *ret) |
---|
146 | { |
---|
147 | p.normalize(); |
---|
148 | ret->setEmpty(); |
---|
149 | } |
---|
150 | |
---|
151 | void Pt3D_Ext::p_rotate(ExtValue *args,ExtValue *ret) |
---|
152 | { |
---|
153 | Orient_Ext *o=Orient_Ext::fromObject(args[0]); |
---|
154 | if (o) |
---|
155 | { |
---|
156 | Pt3D tmp=p; |
---|
157 | o->o.transform(p,tmp); |
---|
158 | } |
---|
159 | ret->setEmpty(); |
---|
160 | } |
---|
161 | |
---|
162 | void Pt3D_Ext::p_revrotate(ExtValue *args,ExtValue *ret) |
---|
163 | { |
---|
164 | Orient_Ext *o=Orient_Ext::fromObject(args[0]); |
---|
165 | if (o) |
---|
166 | { |
---|
167 | Pt3D tmp=p; |
---|
168 | o->o.revTransform(p,tmp); |
---|
169 | } |
---|
170 | ret->setEmpty(); |
---|
171 | } |
---|
172 | |
---|
173 | void Pt3D_Ext::p_get(ExtValue *args,ExtValue *ret) |
---|
174 | { |
---|
175 | int index=args->getInt(); |
---|
176 | if ((index<0)||(index>2)) |
---|
177 | ret->setEmpty(); |
---|
178 | else |
---|
179 | ret->setDouble((&p.x)[index]); |
---|
180 | } |
---|
181 | |
---|
182 | Param& Pt3D_Ext::getStaticParam() |
---|
183 | { |
---|
184 | #ifdef __CODEGUARD__ |
---|
185 | static Pt3D_Ext static_pt3dobj; |
---|
186 | static Param static_pt3dparam(getStaticParamtab(),&static_pt3dobj); |
---|
187 | #else |
---|
188 | static Param static_pt3dparam(getStaticParamtab()); |
---|
189 | #endif |
---|
190 | return static_pt3dparam; |
---|
191 | } |
---|
192 | |
---|
193 | Pt3D_Ext* Pt3D_Ext::fromObject(const ExtValue& v,bool warn) |
---|
194 | { |
---|
195 | return (Pt3D_Ext*)v.getObjectTarget(getStaticParam().getName(), warn); |
---|
196 | } |
---|
197 | |
---|
198 | ParamInterface* Pt3D_Ext::getInterface() {return &getStaticParam();} |
---|
199 | |
---|
200 | ExtObject Pt3D_Ext::makeStaticObject(Pt3D* p) |
---|
201 | {return ExtObject(&getStaticParam(),((char*)p)+(((char*)&p->x)-((char*)&((Pt3D_Ext*)p)->p.x)));} |
---|
202 | |
---|
203 | ExtObject Pt3D_Ext::makeDynamicObject(Pt3D_Ext* p) |
---|
204 | {return ExtObject(&getStaticParam(),p);} |
---|
205 | |
---|
206 | ExtObject Pt3D_Ext::makeDynamicObject(const Pt3D& p) |
---|
207 | { |
---|
208 | Pt3D_Ext *pe=new Pt3D_Ext(p); |
---|
209 | return ExtObject(&getStaticParam(),pe); |
---|
210 | } |
---|
211 | |
---|
212 | ////////////////////////////////////// |
---|
213 | |
---|
214 | ParamEntry* Orient_Ext::getStaticParamtab() |
---|
215 | { |
---|
216 | #define FIELDSTRUCT Orient_Ext |
---|
217 | static ParamEntry paramtab[]= |
---|
218 | { |
---|
219 | {"Orient",1,27,"Orient","3D orientation, stored as 3x3 matrix."}, |
---|
220 | |
---|
221 | {"xx",1,PARAM_NOSTATIC,"orientation.x.x","f",FIELD(o.x.x),}, |
---|
222 | {"xy",1,PARAM_NOSTATIC,"orientation.x.y","f",FIELD(o.x.y),}, |
---|
223 | {"xz",1,PARAM_NOSTATIC,"orientation.x.z","f",FIELD(o.x.z),}, |
---|
224 | {"yx",1,PARAM_NOSTATIC,"orientation.y.x","f",FIELD(o.y.x),}, |
---|
225 | {"yy",1,PARAM_NOSTATIC,"orientation.y.y","f",FIELD(o.y.y),}, |
---|
226 | {"yz",1,PARAM_NOSTATIC,"orientation.y.z","f",FIELD(o.y.z),}, |
---|
227 | {"zx",1,PARAM_NOSTATIC,"orientation.z.x","f",FIELD(o.z.x),}, |
---|
228 | {"zy",1,PARAM_NOSTATIC,"orientation.z.y","f",FIELD(o.z.y),}, |
---|
229 | {"zz",1,PARAM_NOSTATIC,"orientation.z.z","f",FIELD(o.z.z),}, |
---|
230 | |
---|
231 | {"x",0,PARAM_NOSTATIC | PARAM_READONLY,"x vector","oXYZ",GETONLY(x),}, |
---|
232 | {"y",0,PARAM_NOSTATIC | PARAM_READONLY,"y vector","oXYZ",GETONLY(y),}, |
---|
233 | {"z",0,PARAM_NOSTATIC | PARAM_READONLY,"z vector","oXYZ",GETONLY(z),}, |
---|
234 | |
---|
235 | {"new",0,0,"create new Orient object","p oOrient()",PROCEDURE(p_new),}, |
---|
236 | {"newFromVector",0,0,"create new Orient object","p oOrient(oVector)",PROCEDURE(p_newFromVector),}, |
---|
237 | {"toVector",0,PARAM_READONLY | PARAM_NOSTATIC,"vector representation","oVector",GETONLY(toVector),"for serialization"}, |
---|
238 | {"clone",0,PARAM_NOSTATIC,"create new Orient object","p oOrient()",PROCEDURE(p_clone),}, |
---|
239 | {"set",0,PARAM_NOSTATIC,"copy from another Orient object","p(oOrient)",PROCEDURE(p_set),}, |
---|
240 | {"reset",0,PARAM_NOSTATIC,"set identity matrix","p()",PROCEDURE(p_reset),}, |
---|
241 | {"rotate3",0,PARAM_NOSTATIC,"rotate around 3 axes","p(f x,f y,f z)",PROCEDURE(p_rotate3),}, |
---|
242 | {"rotate",0,PARAM_NOSTATIC,"rotate using Orient object","p(oOrient)",PROCEDURE(p_rotate),}, |
---|
243 | {"revRotate",0,PARAM_NOSTATIC,"reverse rotate using Orient object","p(oOrient)",PROCEDURE(p_revrotate),}, |
---|
244 | {"lookAt",0,PARAM_NOSTATIC,"calculate rotation from 2 vectors","p(oXYZ direction,oXYZ up)",PROCEDURE(p_lookat),}, |
---|
245 | {"normalize",0,PARAM_NOSTATIC,"normalize","p()",PROCEDURE(p_normalize),}, |
---|
246 | {"between2",0,PARAM_NOSTATIC,"interpolate orientation","p(oOrient,oOrient,f amount)",PROCEDURE(p_between2),"The calling Orient receives the orientation interpolated from 2 input orientations.\nExample:\n" |
---|
247 | "var o1=Orient.new(), o2=Orient.new(), o3=Orient.new();\n" |
---|
248 | "o2.rotate3(0,Math.pi/2,0);\n" |
---|
249 | "o3.between2(o1,o2,0); // o3 equals o2\n" |
---|
250 | "o3.between2(o1,o2,1); // o3 equals o1\n" |
---|
251 | "o3.between2(o1,o2,0.5); // o3 is halfway between o1 and o2\n"}, |
---|
252 | {"betweenOV",0,PARAM_NOSTATIC,"interpolate orientation","p(oOrient,oXYZ,f amount)",PROCEDURE(p_betweenOV),"Like between2(), but the second Orient is composed of the supplied XYZ vector (X component) and Y Z vectors from the calling object.\n" |
---|
253 | "Example:\n" |
---|
254 | "var o=Orient.new();\n" |
---|
255 | "o.betweenOV(o,(0,1,0),1); //no change, o remains 100 010 001\n" |
---|
256 | "o.betweenOV(o,(0,1,0),0.9); //o is slightly rotated towards (0,1,0)\n" |
---|
257 | "o.betweenOV(o,(0,1,0),0); //o is completely transformed, o.x=(0,1,0)\n" |
---|
258 | }, |
---|
259 | {"localToWorld",0,PARAM_NOSTATIC,"transform coordinates","p oXYZ(oXYZ point,oXYZ center)",PROCEDURE(p_localToWorld),}, |
---|
260 | {"worldToLocal",0,PARAM_NOSTATIC,"transform coordinates","p oXYZ(oXYZ point,oXYZ center)",PROCEDURE(p_worldToLocal),}, |
---|
261 | {0,0,0,}, |
---|
262 | }; |
---|
263 | #undef FIELDSTRUCT |
---|
264 | return paramtab; |
---|
265 | } |
---|
266 | |
---|
267 | void Orient_Ext::p_new(ExtValue *args,ExtValue *ret) |
---|
268 | { |
---|
269 | *ret=makeDynamicObject(new Orient_Ext()); |
---|
270 | } |
---|
271 | |
---|
272 | void Orient_Ext::p_newFromVector(ExtValue *args,ExtValue *ret) |
---|
273 | { |
---|
274 | VectorObject *vec=VectorObject::fromObject(args->getObject()); |
---|
275 | if (vec) |
---|
276 | *ret=makeDynamicObject(new Orient_Ext(Orient(pt3DFromVec(vec,0),pt3DFromVec(vec,3),pt3DFromVec(vec,6)))); |
---|
277 | else |
---|
278 | ret->setEmpty(); |
---|
279 | } |
---|
280 | |
---|
281 | void Orient_Ext::get_toVector(ExtValue *ret) |
---|
282 | { |
---|
283 | VectorObject *vec=new VectorObject; |
---|
284 | add3Coords(vec,o.x); |
---|
285 | add3Coords(vec,o.y); |
---|
286 | add3Coords(vec,o.z); |
---|
287 | ret->setObject(ExtObject(&VectorObject::par,vec)); |
---|
288 | } |
---|
289 | |
---|
290 | void Orient_Ext::p_clone(ExtValue *args,ExtValue *ret) |
---|
291 | { |
---|
292 | *ret=makeDynamicObject(new Orient_Ext(o)); |
---|
293 | } |
---|
294 | |
---|
295 | void Orient_Ext::p_set(ExtValue *args,ExtValue *ret) |
---|
296 | { |
---|
297 | Orient_Ext *other=fromObject(args[0]); |
---|
298 | if (other) |
---|
299 | o=other->o; |
---|
300 | ret->setEmpty(); |
---|
301 | } |
---|
302 | |
---|
303 | void Orient_Ext::p_reset(ExtValue *args,ExtValue *ret) |
---|
304 | { |
---|
305 | o=Orient_1; |
---|
306 | ret->setEmpty(); |
---|
307 | } |
---|
308 | |
---|
309 | void Orient_Ext::get_x(PARAMGETARGS) |
---|
310 | { |
---|
311 | *ret=Pt3D_Ext::makeStaticObject(&o.x); |
---|
312 | } |
---|
313 | |
---|
314 | void Orient_Ext::get_y(PARAMGETARGS) |
---|
315 | { |
---|
316 | *ret=Pt3D_Ext::makeStaticObject(&o.y); |
---|
317 | } |
---|
318 | |
---|
319 | void Orient_Ext::get_z(PARAMGETARGS) |
---|
320 | { |
---|
321 | *ret=Pt3D_Ext::makeStaticObject(&o.z); |
---|
322 | } |
---|
323 | |
---|
324 | void Orient_Ext::p_lookat(ExtValue *args,ExtValue *ret) |
---|
325 | { |
---|
326 | Pt3D_Ext *dir=Pt3D_Ext::fromObject(args[1]),*up=Pt3D_Ext::fromObject(args[0]); |
---|
327 | if (dir&&up) |
---|
328 | o.lookAt(dir->p,up->p); |
---|
329 | ret->setEmpty(); |
---|
330 | } |
---|
331 | |
---|
332 | void Orient_Ext::p_rotate3(ExtValue *args,ExtValue *ret) |
---|
333 | { |
---|
334 | Pt3D p(args[2].getDouble(),args[1].getDouble(),args[0].getDouble()); |
---|
335 | o.rotate(p); |
---|
336 | ret->setEmpty(); |
---|
337 | } |
---|
338 | |
---|
339 | void Orient_Ext::p_rotate(ExtValue *args,ExtValue *ret) |
---|
340 | { |
---|
341 | Orient_Ext *obj=Orient_Ext::fromObject(args[0]); |
---|
342 | if (!obj) |
---|
343 | { |
---|
344 | Orient tmp=o; |
---|
345 | obj->o.transform(o,tmp); |
---|
346 | } |
---|
347 | ret->setEmpty(); |
---|
348 | } |
---|
349 | |
---|
350 | void Orient_Ext::p_revrotate(ExtValue *args,ExtValue *ret) |
---|
351 | { |
---|
352 | Orient_Ext *obj=Orient_Ext::fromObject(args[0]); |
---|
353 | if (obj) |
---|
354 | { |
---|
355 | Orient tmp=o; |
---|
356 | obj->o.revTransform(o,tmp); |
---|
357 | } |
---|
358 | ret->setEmpty(); |
---|
359 | } |
---|
360 | |
---|
361 | void Orient_Ext::p_normalize(ExtValue *args,ExtValue *ret) |
---|
362 | { |
---|
363 | o.normalize(); |
---|
364 | ret->setEmpty(); |
---|
365 | } |
---|
366 | |
---|
367 | void Orient_Ext::p_between2(ExtValue *args,ExtValue *ret) |
---|
368 | { |
---|
369 | Orient_Ext *o1=Orient_Ext::fromObject(args[2]); |
---|
370 | Orient_Ext *o2=Orient_Ext::fromObject(args[1]); |
---|
371 | if (o1&&o2) |
---|
372 | { |
---|
373 | double q1=args[0].getDouble(),q2=1.0-q1; |
---|
374 | o.x.x=q1*o1->o.x.x+q2*o2->o.x.x; |
---|
375 | o.x.y=q1*o1->o.x.y+q2*o2->o.x.y; |
---|
376 | o.x.z=q1*o1->o.x.z+q2*o2->o.x.z; |
---|
377 | o.y.x=q1*o1->o.y.x+q2*o2->o.y.x; |
---|
378 | o.y.y=q1*o1->o.y.y+q2*o2->o.y.y; |
---|
379 | o.y.z=q1*o1->o.y.z+q2*o2->o.y.z; |
---|
380 | o.z.x=q1*o1->o.z.x+q2*o2->o.z.x; |
---|
381 | o.z.y=q1*o1->o.z.y+q2*o2->o.z.y; |
---|
382 | o.z.z=q1*o1->o.z.z+q2*o2->o.z.z; |
---|
383 | o.normalize(); |
---|
384 | } |
---|
385 | ret->setEmpty(); |
---|
386 | } |
---|
387 | |
---|
388 | void Orient_Ext::p_betweenOV(ExtValue *args,ExtValue *ret) |
---|
389 | { |
---|
390 | Orient_Ext *o1=Orient_Ext::fromObject(args[2]); |
---|
391 | Pt3D_Ext *p2=Pt3D_Ext::fromObject(args[1]); |
---|
392 | if (o1&&p2) |
---|
393 | { |
---|
394 | double q1=args[0].getDouble(),q2=1.0-q1; |
---|
395 | o.x.x=q1*o1->o.x.x+q2*p2->p.x; |
---|
396 | o.x.y=q1*o1->o.x.y+q2*p2->p.y; |
---|
397 | o.x.z=q1*o1->o.x.z+q2*p2->p.z; |
---|
398 | o.normalize(); |
---|
399 | } |
---|
400 | ret->setEmpty(); |
---|
401 | } |
---|
402 | |
---|
403 | void Orient_Ext::p_localToWorld(ExtValue *args,ExtValue *ret) |
---|
404 | { |
---|
405 | Pt3D_Ext *center,*point; |
---|
406 | point=Pt3D_Ext::fromObject(args[1]); |
---|
407 | center=Pt3D_Ext::fromObject(args[0]); |
---|
408 | if (center && point) |
---|
409 | { |
---|
410 | Pt3D d; |
---|
411 | Pt3D src=point->p; |
---|
412 | o.transform(d,src); |
---|
413 | d+=center->p; |
---|
414 | *ret=Pt3D_Ext::makeDynamicObject(new Pt3D_Ext(d)); |
---|
415 | } |
---|
416 | else |
---|
417 | ret->setEmpty(); |
---|
418 | } |
---|
419 | |
---|
420 | void Orient_Ext::p_worldToLocal(ExtValue *args,ExtValue *ret) |
---|
421 | { |
---|
422 | Pt3D_Ext *center,*point; |
---|
423 | point=Pt3D_Ext::fromObject(args[1]); |
---|
424 | center=Pt3D_Ext::fromObject(args[0]); |
---|
425 | if (center && point) |
---|
426 | { |
---|
427 | Pt3D d; |
---|
428 | Pt3D src=point->p; |
---|
429 | d-=center->p; |
---|
430 | o.revTransform(d,src); |
---|
431 | *ret=Pt3D_Ext::makeDynamicObject(new Pt3D_Ext(d)); |
---|
432 | } |
---|
433 | else |
---|
434 | ret->setEmpty(); |
---|
435 | } |
---|
436 | |
---|
437 | Param& Orient_Ext::getStaticParam() |
---|
438 | { |
---|
439 | #ifdef __CODEGUARD__ |
---|
440 | static Orient_Ext static_orientobj; |
---|
441 | static Param static_orientparam(getStaticParamtab(),&static_orientobj); |
---|
442 | #else |
---|
443 | static Param static_orientparam(getStaticParamtab()); |
---|
444 | #endif |
---|
445 | return static_orientparam; |
---|
446 | } |
---|
447 | |
---|
448 | Orient_Ext* Orient_Ext::fromObject(const ExtValue& v) |
---|
449 | { |
---|
450 | return (Orient_Ext*)v.getObjectTarget(getStaticParam().getName()); |
---|
451 | } |
---|
452 | |
---|
453 | ParamInterface* Orient_Ext::getInterface() {return &getStaticParam();} |
---|
454 | |
---|
455 | ExtObject Orient_Ext::makeStaticObject(Orient* o) |
---|
456 | {return ExtObject(&getStaticParam(),((char*)o)+(((char*)&o->x)-((char*)&((Orient_Ext*)o)->o.x)));} |
---|
457 | |
---|
458 | ExtObject Orient_Ext::makeDynamicObject(Orient_Ext* p) |
---|
459 | {return ExtObject(&getStaticParam(),p);} |
---|
460 | |
---|
461 | ParamEntry* ReferenceObj::getStaticParamtab() |
---|
462 | { |
---|
463 | #define FIELDSTRUCT ReferenceObj |
---|
464 | static ParamEntry paramtab[]= |
---|
465 | { |
---|
466 | {"Ref",1,5,"Ref","Reference objects. Useful for returning things from functions.\n\nExample:\nvar x=111;\nsquare(&x);// '&' creates the Reference object\nSimulator.print(x);//x is now 12321\n\nfunction square(r)\n{r.value=r.value*r.value;}\n//square receives the Reference objects and changes its 'value' field"}, |
---|
467 | |
---|
468 | {"value",0,PARAM_NOSTATIC,"value","x",GETSET(value),}, |
---|
469 | {"newS",0,0,"create new reference","p",PROCEDURE(p_newS),"(for internal use only) use &variablename to create Ref objects.",}, |
---|
470 | {"newO",0,0,"create new reference","p",PROCEDURE(p_newO),"(for internal use only) use &variablename to create Ref objects.",}, |
---|
471 | {"copyFrom",0,0,"copy the reference","p(oRef)",PROCEDURE(p_copyFrom),"make the reference point to the same target,"}, |
---|
472 | {"toString",0,PARAM_READONLY | PARAM_NOSTATIC,"textual form","s",GETONLY(toString),}, |
---|
473 | {0,0,0,}, |
---|
474 | }; |
---|
475 | #undef FIELDSTRUCT |
---|
476 | return paramtab; |
---|
477 | } |
---|
478 | |
---|
479 | Param& ReferenceObj::getStaticParam() |
---|
480 | { |
---|
481 | #ifdef __CODEGUARD__ |
---|
482 | static ReferenceObj static_referenceobj; |
---|
483 | static Param static_refobjectparam(getStaticParamtab(),&static_referenceobj); |
---|
484 | #else |
---|
485 | static Param static_refobjectparam(getStaticParamtab()); |
---|
486 | #endif |
---|
487 | return static_refobjectparam; |
---|
488 | } |
---|
489 | |
---|
490 | void ReferenceObj::p_newS(ExtValue *args,ExtValue *ret) |
---|
491 | { |
---|
492 | *ret=makeDynamicObject(new ReferenceObj((ExtValue*)args->getInt())); |
---|
493 | } |
---|
494 | |
---|
495 | void ReferenceObj::p_newO(ExtValue *args,ExtValue *ret) |
---|
496 | { |
---|
497 | if (args[0].type==TInt) |
---|
498 | *ret=makeDynamicObject(new ReferenceObj(args[1].getObject(),args[0].getInt())); |
---|
499 | else |
---|
500 | *ret=makeDynamicObject(new ReferenceObj(args[1].getObject(),args[0].getString())); |
---|
501 | } |
---|
502 | |
---|
503 | void ReferenceObj::p_copyFrom(ExtValue *args,ExtValue *ret) |
---|
504 | { |
---|
505 | ReferenceObj* other=fromObject(args[0]); |
---|
506 | if (other) |
---|
507 | { |
---|
508 | value=other->value; |
---|
509 | obj=other->obj; |
---|
510 | prop=other->prop; |
---|
511 | } |
---|
512 | } |
---|
513 | |
---|
514 | void ReferenceObj::get_toString(ExtValue *ret) |
---|
515 | { |
---|
516 | SString s="("; |
---|
517 | static SListTempl<ReferenceObj*> trace; |
---|
518 | if (trace.find(this)>=0) |
---|
519 | s+="..."; |
---|
520 | else |
---|
521 | { |
---|
522 | trace+=this; |
---|
523 | if (value) |
---|
524 | s+=value->getString(); |
---|
525 | else |
---|
526 | { |
---|
527 | ExtValue v; |
---|
528 | Param tmp_param; |
---|
529 | ParamInterface *pi=obj.getParamInterface(tmp_param); |
---|
530 | pi->get(prop,v); |
---|
531 | s+=v.getString(); |
---|
532 | } |
---|
533 | trace-=this; |
---|
534 | } |
---|
535 | s+=")"; |
---|
536 | ret->setString(s); |
---|
537 | } |
---|
538 | |
---|
539 | void ReferenceObj::get_value(ExtValue *ret) |
---|
540 | { |
---|
541 | if (value) |
---|
542 | *ret=*value; |
---|
543 | else |
---|
544 | { |
---|
545 | Param tmp_param; |
---|
546 | ParamInterface *pi=obj.getParamInterface(tmp_param); |
---|
547 | pi->get(prop,*ret); |
---|
548 | } |
---|
549 | } |
---|
550 | |
---|
551 | int ReferenceObj::set_value(const ExtValue *val) |
---|
552 | { |
---|
553 | if (value) |
---|
554 | *value=*val; |
---|
555 | else |
---|
556 | { |
---|
557 | Param tmp_param; |
---|
558 | ParamInterface *pi=obj.getParamInterface(tmp_param); |
---|
559 | pi->set(prop,*val); |
---|
560 | } |
---|
561 | return PSET_CHANGED; |
---|
562 | } |
---|
563 | |
---|
564 | ReferenceObj::ReferenceObj(const ExtObject &o,const SString &p) |
---|
565 | :value(0),obj(o) |
---|
566 | { |
---|
567 | Param tmp_param; |
---|
568 | ParamInterface *pi=obj.getParamInterface(tmp_param); |
---|
569 | prop=pi->findId(p); |
---|
570 | } |
---|
571 | |
---|
572 | ExtObject ReferenceObj::makeDynamicObject(ReferenceObj* r) |
---|
573 | {return ExtObject(&getStaticParam(),r);} |
---|
574 | |
---|
575 | ReferenceObj* ReferenceObj::fromObject(const ExtValue& v) |
---|
576 | { |
---|
577 | return (ReferenceObj*)v.getObjectTarget(getStaticParam().getName()); |
---|
578 | } |
---|
579 | |
---|
580 | ///////////// |
---|
581 | |
---|
582 | REGISTER_DESERIALIZABLE(Pt3D_Ext) |
---|
583 | REGISTER_DESERIALIZABLE(Orient_Ext) |
---|