source: cpp/frams/vm/classes/3dobject.cpp @ 240

Last change on this file since 240 was 240, checked in by Maciej Komosinski, 10 years ago

Used | instead of + when adding binary flags

  • Property svn:eol-style set to native
File size: 16.3 KB
Line 
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
10ParamEntry* Pt3D_Ext::getStaticParamtab()
11{
12#define FIELDSTRUCT Pt3D_Ext
13static 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
38return paramtab;
39}
40
41void 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
46static double doubleFromVec(VectorObject *vec,int i)
47{
48if (i>=vec->data.size()) return 0;
49ExtValue *v=(ExtValue*)vec->data.get(i);
50if (v)
51        return v->getDouble();
52return 0;
53}
54
55static Pt3D pt3DFromVec(VectorObject* v,int offset=0)
56{
57return Pt3D(doubleFromVec(v,offset),doubleFromVec(v,offset+1),doubleFromVec(v,offset+2));
58}
59
60void Pt3D_Ext::p_newFromVector(ExtValue *args,ExtValue *ret)
61{
62VectorObject *vec=VectorObject::fromObject(args->getObject());
63if (vec)
64        *ret=makeDynamicObject(new Pt3D_Ext(pt3DFromVec(vec)));
65else
66        ret->setEmpty();
67}
68
69void Pt3D_Ext::p_clone(ExtValue *args,ExtValue *ret)
70{
71*ret=makeDynamicObject(new Pt3D_Ext(p.x,p.y,p.z));
72}
73
74void Pt3D_Ext::p_set3(ExtValue *args,ExtValue *ret)
75{
76p.x=args[2].getDouble();
77p.y=args[1].getDouble();
78p.z=args[0].getDouble();
79ret->setEmpty();
80}
81
82void Pt3D_Ext::p_set(ExtValue *args,ExtValue *ret)
83{
84Pt3D_Ext *other=fromObject(args[0]);
85if (other)
86        p=other->p;
87ret->setEmpty();
88}
89
90void Pt3D_Ext::get_length(ExtValue *ret)
91{
92ret->setDouble(p.length());
93}
94
95void Pt3D_Ext::get_toString(ExtValue *ret)
96{
97SString s="(";
98ExtValue v;
99v.setDouble(p.x); s+=v.getString();
100s+=",";
101v.setDouble(p.y); s+=v.getString();
102s+=",";
103v.setDouble(p.z); s+=v.getString();
104s+=")";
105ret->setString(s);
106}
107
108static void add3Coords(VectorObject* vec,const Pt3D& p)
109{
110vec->data+=new ExtValue(p.x);
111vec->data+=new ExtValue(p.y);
112vec->data+=new ExtValue(p.z);
113}
114
115void Pt3D_Ext::get_toVector(ExtValue *ret)
116{
117VectorObject *vec=new VectorObject;
118add3Coords(vec,p);
119ret->setObject(ExtObject(&VectorObject::par,vec));
120}
121
122void Pt3D_Ext::p_addvec(ExtValue *args,ExtValue *ret)
123{
124Pt3D_Ext *other=fromObject(args[0]);
125if (other)
126        p+=other->p;
127ret->setEmpty();
128}
129
130void Pt3D_Ext::p_subvec(ExtValue *args,ExtValue *ret)
131{
132Pt3D_Ext *other=fromObject(args[0]);
133if (other)
134        p-=other->p;
135ret->setEmpty();
136}
137
138void Pt3D_Ext::p_scale(ExtValue *args,ExtValue *ret)
139{
140double d=args[0].getDouble();
141p.x*=d; p.y*=d; p.z*=d;
142ret->setEmpty();
143}
144
145void Pt3D_Ext::p_normalize(ExtValue *args,ExtValue *ret)
146{
147p.normalize();
148ret->setEmpty();
149}
150
151void Pt3D_Ext::p_rotate(ExtValue *args,ExtValue *ret)
152{
153Orient_Ext *o=Orient_Ext::fromObject(args[0]);
154if (o)
155        {
156        Pt3D tmp=p;
157        o->o.transform(p,tmp);
158        }
159ret->setEmpty();
160}
161
162void Pt3D_Ext::p_revrotate(ExtValue *args,ExtValue *ret)
163{
164Orient_Ext *o=Orient_Ext::fromObject(args[0]);
165if (o)
166        {
167        Pt3D tmp=p;
168        o->o.revTransform(p,tmp);
169        }
170ret->setEmpty();
171}
172
173void Pt3D_Ext::p_get(ExtValue *args,ExtValue *ret)
174{
175int index=args->getInt();
176if ((index<0)||(index>2))
177        ret->setEmpty();
178else
179        ret->setDouble((&p.x)[index]);
180}
181
182Param& Pt3D_Ext::getStaticParam()
183{
184#ifdef __CODEGUARD__
185static Pt3D_Ext static_pt3dobj;
186static Param static_pt3dparam(getStaticParamtab(),&static_pt3dobj);
187#else
188static Param static_pt3dparam(getStaticParamtab());
189#endif
190return static_pt3dparam;
191}
192
193Pt3D_Ext* Pt3D_Ext::fromObject(const ExtValue& v,bool warn)
194{
195return (Pt3D_Ext*)v.getObjectTarget(getStaticParam().getName(), warn);
196}
197
198ParamInterface* Pt3D_Ext::getInterface() {return &getStaticParam();}
199
200ExtObject Pt3D_Ext::makeStaticObject(Pt3D* p)
201{return ExtObject(&getStaticParam(),((char*)p)+(((char*)&p->x)-((char*)&((Pt3D_Ext*)p)->p.x)));}
202
203ExtObject Pt3D_Ext::makeDynamicObject(Pt3D_Ext* p)
204{return ExtObject(&getStaticParam(),p);}
205
206ExtObject Pt3D_Ext::makeDynamicObject(const Pt3D& p)
207{
208Pt3D_Ext *pe=new Pt3D_Ext(p);
209return ExtObject(&getStaticParam(),pe);
210}
211
212//////////////////////////////////////
213
214ParamEntry* Orient_Ext::getStaticParamtab()
215{
216#define FIELDSTRUCT Orient_Ext
217static 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
264return paramtab;
265}
266
267void Orient_Ext::p_new(ExtValue *args,ExtValue *ret)
268{
269*ret=makeDynamicObject(new Orient_Ext());
270}
271
272void Orient_Ext::p_newFromVector(ExtValue *args,ExtValue *ret)
273{
274VectorObject *vec=VectorObject::fromObject(args->getObject());
275if (vec)
276        *ret=makeDynamicObject(new Orient_Ext(Orient(pt3DFromVec(vec,0),pt3DFromVec(vec,3),pt3DFromVec(vec,6))));
277else
278        ret->setEmpty();
279}
280
281void Orient_Ext::get_toVector(ExtValue *ret)
282{
283VectorObject *vec=new VectorObject;
284add3Coords(vec,o.x);
285add3Coords(vec,o.y);
286add3Coords(vec,o.z);
287ret->setObject(ExtObject(&VectorObject::par,vec));
288}
289
290void Orient_Ext::p_clone(ExtValue *args,ExtValue *ret)
291{
292*ret=makeDynamicObject(new Orient_Ext(o));
293}
294
295void Orient_Ext::p_set(ExtValue *args,ExtValue *ret)
296{
297Orient_Ext *other=fromObject(args[0]);
298if (other)
299        o=other->o;
300ret->setEmpty();
301}
302
303void Orient_Ext::p_reset(ExtValue *args,ExtValue *ret)
304{
305o=Orient_1;
306ret->setEmpty();
307}
308
309void Orient_Ext::get_x(PARAMGETARGS)
310{
311*ret=Pt3D_Ext::makeStaticObject(&o.x);
312}
313
314void Orient_Ext::get_y(PARAMGETARGS)
315{
316*ret=Pt3D_Ext::makeStaticObject(&o.y);
317}
318
319void Orient_Ext::get_z(PARAMGETARGS)
320{
321*ret=Pt3D_Ext::makeStaticObject(&o.z);
322}
323
324void Orient_Ext::p_lookat(ExtValue *args,ExtValue *ret)
325{
326Pt3D_Ext *dir=Pt3D_Ext::fromObject(args[1]),*up=Pt3D_Ext::fromObject(args[0]);
327if (dir&&up)
328        o.lookAt(dir->p,up->p);
329ret->setEmpty();
330}
331
332void Orient_Ext::p_rotate3(ExtValue *args,ExtValue *ret)
333{
334Pt3D p(args[2].getDouble(),args[1].getDouble(),args[0].getDouble());
335o.rotate(p);
336ret->setEmpty();
337}
338
339void Orient_Ext::p_rotate(ExtValue *args,ExtValue *ret)
340{
341Orient_Ext *obj=Orient_Ext::fromObject(args[0]);
342if (!obj)
343        {
344        Orient tmp=o;
345        obj->o.transform(o,tmp);
346        }
347ret->setEmpty();
348}
349
350void Orient_Ext::p_revrotate(ExtValue *args,ExtValue *ret)
351{
352Orient_Ext *obj=Orient_Ext::fromObject(args[0]);
353if (obj)
354        {
355        Orient tmp=o;
356        obj->o.revTransform(o,tmp);
357        }
358ret->setEmpty();
359}
360
361void Orient_Ext::p_normalize(ExtValue *args,ExtValue *ret)
362{
363o.normalize();
364ret->setEmpty();
365}
366
367void Orient_Ext::p_between2(ExtValue *args,ExtValue *ret)
368{
369Orient_Ext *o1=Orient_Ext::fromObject(args[2]);
370Orient_Ext *o2=Orient_Ext::fromObject(args[1]);
371if (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        }
385ret->setEmpty();
386}
387
388void Orient_Ext::p_betweenOV(ExtValue *args,ExtValue *ret)
389{
390Orient_Ext *o1=Orient_Ext::fromObject(args[2]);
391Pt3D_Ext *p2=Pt3D_Ext::fromObject(args[1]);
392if (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        }
400ret->setEmpty();
401}
402
403void Orient_Ext::p_localToWorld(ExtValue *args,ExtValue *ret)
404{
405Pt3D_Ext *center,*point;
406point=Pt3D_Ext::fromObject(args[1]);
407center=Pt3D_Ext::fromObject(args[0]);
408if (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        }
416else
417        ret->setEmpty();
418}
419
420void Orient_Ext::p_worldToLocal(ExtValue *args,ExtValue *ret)
421{
422Pt3D_Ext *center,*point;
423point=Pt3D_Ext::fromObject(args[1]);
424center=Pt3D_Ext::fromObject(args[0]);
425if (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        }
433else
434        ret->setEmpty();
435}
436
437Param& Orient_Ext::getStaticParam()
438{
439#ifdef __CODEGUARD__
440static Orient_Ext static_orientobj;
441static Param static_orientparam(getStaticParamtab(),&static_orientobj);
442#else
443static Param static_orientparam(getStaticParamtab());
444#endif
445return static_orientparam;
446}
447
448Orient_Ext* Orient_Ext::fromObject(const ExtValue& v)
449{
450return (Orient_Ext*)v.getObjectTarget(getStaticParam().getName());
451}
452
453ParamInterface* Orient_Ext::getInterface() {return &getStaticParam();}
454
455ExtObject Orient_Ext::makeStaticObject(Orient* o)
456{return ExtObject(&getStaticParam(),((char*)o)+(((char*)&o->x)-((char*)&((Orient_Ext*)o)->o.x)));}
457
458ExtObject Orient_Ext::makeDynamicObject(Orient_Ext* p)
459{return ExtObject(&getStaticParam(),p);}
460
461ParamEntry* ReferenceObj::getStaticParamtab()
462{
463#define FIELDSTRUCT ReferenceObj
464static 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
476return paramtab;
477}
478
479Param& ReferenceObj::getStaticParam()
480{
481#ifdef __CODEGUARD__
482static ReferenceObj static_referenceobj;
483static Param static_refobjectparam(getStaticParamtab(),&static_referenceobj);
484#else
485static Param static_refobjectparam(getStaticParamtab());
486#endif
487return static_refobjectparam;
488}
489
490void ReferenceObj::p_newS(ExtValue *args,ExtValue *ret)
491{
492*ret=makeDynamicObject(new ReferenceObj((ExtValue*)args->getInt()));
493}
494
495void ReferenceObj::p_newO(ExtValue *args,ExtValue *ret)
496{
497if (args[0].type==TInt)
498        *ret=makeDynamicObject(new ReferenceObj(args[1].getObject(),args[0].getInt()));
499else
500        *ret=makeDynamicObject(new ReferenceObj(args[1].getObject(),args[0].getString()));
501}
502
503void ReferenceObj::p_copyFrom(ExtValue *args,ExtValue *ret)
504{
505ReferenceObj* other=fromObject(args[0]);
506if (other)
507        {
508        value=other->value;
509        obj=other->obj;
510        prop=other->prop;
511        }
512}
513
514void ReferenceObj::get_toString(ExtValue *ret)
515{
516SString s="(";
517static SListTempl<ReferenceObj*> trace;
518if (trace.find(this)>=0)
519        s+="...";
520else
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        }
535s+=")";
536ret->setString(s);
537}
538
539void ReferenceObj::get_value(ExtValue *ret)
540{
541if (value)
542        *ret=*value;
543else
544        {
545        Param tmp_param;
546        ParamInterface *pi=obj.getParamInterface(tmp_param);
547        pi->get(prop,*ret);
548        }
549}
550
551int ReferenceObj::set_value(const ExtValue *val)
552{
553if (value)
554        *value=*val;
555else
556        {
557        Param tmp_param;
558        ParamInterface *pi=obj.getParamInterface(tmp_param);
559        pi->set(prop,*val);
560        }
561return PSET_CHANGED;
562}
563
564ReferenceObj::ReferenceObj(const ExtObject &o,const SString &p)
565        :value(0),obj(o)
566{
567Param tmp_param;
568ParamInterface *pi=obj.getParamInterface(tmp_param);
569prop=pi->findId(p);
570}
571
572ExtObject ReferenceObj::makeDynamicObject(ReferenceObj* r)
573{return ExtObject(&getStaticParam(),r);}
574
575ReferenceObj* ReferenceObj::fromObject(const ExtValue& v)
576{
577return (ReferenceObj*)v.getObjectTarget(getStaticParam().getName());
578}
579
580/////////////
581
582REGISTER_DESERIALIZABLE(Pt3D_Ext)
583REGISTER_DESERIALIZABLE(Orient_Ext)
Note: See TracBrowser for help on using the repository browser.