source: cpp/frams/model/modelparts.h

Last change on this file was 1280, checked in by Maciej Komosinski, 7 months ago

Added explicit type casts (size_t vs. int etc.)

  • Property svn:eol-style set to native
File size: 19.4 KB
Line 
1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
2// Copyright (C) 1999-2021  Maciej Komosinski and Szymon Ulatowski.
3// See LICENSE.txt for details.
4
5#ifndef _MODELPARTS_H_
6#define _MODELPARTS_H_
7
8#include <frams/util/3d.h>
9#include <frams/genetics/genoconv.h>
10
11#include <frams/util/extvalue.h>
12#include <frams/util/list.h>
13#include <frams/util/sstring.h>
14#include <frams/util/sstringutils.h>
15#include <frams/param/param.h>
16#include <frams/param/syntparam.h>
17#include <frams/util/usertags.h>
18#include <frams/param/paramtabobj.h>
19
20#include <stdio.h>
21
22class Model;
23class IRange;
24class MultiRange;
25
26typedef UserTags<Model, void *, 5> ModelUserTags;
27
28
29/// Introduced only because we can't have a forward declaration of enum in the Model class,
30/// and we would need a forward declaration because of mutual (cyclic) dependence of declarations of Model and NeuroClass.
31/// https://stackoverflow.com/questions/27019292/is-in-class-enum-forward-declaration-possible
32/// Use Model::... instead of ModelEnum::...
33class ModelEnum
34{
35public:
36        enum ShapeType {
37                SHAPETYPE_BALL_AND_STICK = 0, SHAPETYPE_SOLIDS = 1, SHAPETYPE_UNKNOWN, SHAPETYPE_ILLEGAL, ///< 0 and 1 have special significance - these values allow for bit operations.
38                SHAPETYPE_FIRST = SHAPETYPE_BALL_AND_STICK, SHAPETYPE_LAST = SHAPETYPE_SOLIDS // for iteration
39        };
40};
41
42/** Common base for model elements. */
43class PartBase
44{
45public:
46        SString vis_style;
47        PartBase(const SString &s) :vis_style(s), mapped(0) {}
48        ~PartBase();
49        static SString getDefaultStyle() { return SString("none"); }
50        MultiRange *mapped;
51        enum PartBaseFlags { Selected = 1 };
52        int flags;
53        Model *owner;   ///< backlink to the model
54
55        SString info;
56
57        Model &getModel() const { return *owner; }
58
59        ModelUserTags userdata;
60
61        void notifyMappingChange();
62
63        void clearMapping();
64        MultiRange *getMapping() { return mapped; }
65        void setMapping(const IRange &mr);
66        void addMapping(const IRange &mr);
67        void setMapping(const MultiRange &mr);
68        void addMapping(const MultiRange &mr);
69
70        void setInfo(const SString &name, const SString &value);
71        void setInfo(const SString &name, int value);
72        void setInfo(const SString &name, double value);
73        SString getInfo(const SString &name);
74};
75
76/// Part is the only real physical object in creatures in Framsticks.
77/// You can use this class for querying and adjusting constructed
78/// model properties.
79class Part : public PartBase
80{
81        friend class Model;
82        static SString getDefaultStyle();
83        Part(double _mass, double _size, double _density, double _friction, double _ingest, double _assim)
84                :PartBase(getDefaultStyle()), mass(_mass), size(_size), density(_density), friction(_friction), ingest(_ingest), assim(_assim)
85        {}
86        void defassign();
87public:
88        // base properties - have special meaning and therefore are often accessed directly for convenience
89        Pt3D p;    ///< 3d coordinates of the part
90        Orient o;  ///< orientation in 3d space (rotation matrix)
91        /// ParamInterface object is preferred way to get/set other properties.
92        Param extraProperties();
93        Param properties();
94        paInt refno;
95        Pt3D rot;///< rotation angles
96
97        ///
98        paInt shape;///default=old Framsticks compatible, do not mix with shapes>0
99        enum Shape {
100                SHAPE_BALL = 0, ///<  for "ball and stick" shape type model only.
101                SHAPE_ELLIPSOID = 1, SHAPE_CUBOID = 2, SHAPE_CYLINDER = 3,
102                SHAPE_FIRST = SHAPE_BALL, SHAPE_LAST = SHAPE_CYLINDER // for iteration
103        };
104        static const char* getShapeName(Shape sh);
105        static constexpr double DEFAULT_STICK_RADIUS = 0.2; //used in SHAPETYPE_BALL_AND_STICK to SHAPETYPE_SOLIDS Model conversion
106
107        double mass, size, density, friction, ingest, assim, hollow;
108        Pt3D scale;
109        Pt3D food;
110        //SList points; // collistion points
111        //Slist neurons; // "select * from owner->neurons where part=this" ;-)
112
113        Pt3D vcolor;
114
115        Part(enum Shape s = SHAPE_BALL);
116        Part(const Part &src) :PartBase(getDefaultStyle()) { operator=(src); }
117        void operator=(const Part &src);
118
119        void setPositionAndRotationFromAxis(const Pt3D &p1, const Pt3D &p2);
120        void setOrient(const Orient &o);///< set part.o and calculates part.rot (rotation angles)
121        void setRot(const Pt3D &r);///< set part.rot (rotation angles) and calculate part.o
122
123        static Param &getStaticParam();
124};
125
126class Part_MinMaxDef : public Part //contains additional information for Model::getMinPart()/getMaxPart()/getDefPart()
127{
128public:
129        double volume; ///< Introduced to limit the range of volumes (~mass) in simulation of solids. Genetic operators should observe this min,max volume by calculating and limiting the volume of Parts based on their type and sx,sy,sz.
130
131        void defassign();
132        Part_MinMaxDef() { defassign(); }
133};
134
135/// Imaginary connection between two parts.
136/// Joint has no mass nor intertia but can transfer forces.
137class Joint : public PartBase
138{
139        friend class Model;
140        SString getDefaultStyle();
141        Joint(double _stamina, double _stif, double _rotstif, double _d)
142                :PartBase(getDefaultStyle()), stamina(_stamina), stif(_stif), rotstif(_rotstif)
143        {
144                d = Pt3D(_d, 0, 0);
145        }
146        void defassign();
147        void resetDeltaMarkers();
148public:
149        // base properties:
150        paInt p1_refno, p2_refno; ///< parts' reference numbers
151
152        Part *part1, *part2;    ///< references to parts
153        class Pt3D d;           ///< position delta between parts
154        class Pt3D rot; ///< orientation delta between parts expressed as 3 angles
155        enum Shape {
156                SHAPE_STICK = 0, ///<  for "ball and stick" shape type model, creates a physical (cylinder or cuboid) rod between parts. Do not mix with part.shape>0.
157                SHAPE_FIXED = 1, ///< merge parts into one physical entity
158                SHAPE_HINGE_X = 2, ///< hinge connection, revolving around X axis defined by hinge_pos and hinge_rot
159                SHAPE_HINGE_XY = 3, ///< double hinge connection, revolving around X and Y axes defined by hinge_pos and hinge_rot
160                SHAPE_FIRST = SHAPE_STICK, SHAPE_LAST = SHAPE_HINGE_XY // for iteration
161        };
162        paInt shape;///< values of type Shape (paInt for integration with Param)
163        static const char* getShapeName(Shape sh);
164        class Pt3D hinge_pos; ///< hinge position (relative to part1) for HINGE_X and HINGE_XY
165        class Pt3D hinge_rot; ///< hinge orientation (relative to part1) for HINGE_X and HINGE_XY
166        double hinge_limit_x[2], hinge_limit_y[2]; ///< hinge movement range - i.e., extreme allowed values of a state. A state can be an angle or other physical property. limit[0] <= 0 <= limit[1]. Relative Part position and orientation as set in the Model define the initial state 0.
167
168        Joint();
169        Joint(const Joint &src) :PartBase(getDefaultStyle()) { operator=(src); }
170        void operator=(const Joint &src);
171
172        /** connect two parts with this joint.
173                p2 position will be adjusted if delta option is in effect.
174                @see isDelta()
175                */
176        void attachToParts(Part *p1, Part *p2);
177        /// @see attachToParts(Part*,Part*)
178        void attachToParts(int p1, int p2);
179
180        /** discard delta information but don't disable delta flag.
181                delta will be calculated from parts positions during final consistency check.
182                */
183        void resetDelta();
184
185        /** enable or disable delta option.
186                delta value is not changed.
187                */
188        void useDelta(bool use);
189
190        /** @return true if delta option is in effect.
191                @see useDelta(), resetDelta(), useDelta()
192                */
193        bool isDelta();
194
195        /// ParamInterface object is preferred way to get/set other properties.
196        Param extraProperties();
197        Param properties();
198
199        // do not touch these:
200        paInt refno; ///< this joint's reference number
201        double stamina;
202        double stif, rotstif;   ///< stiffness for moving and bending forces
203        class Orient o; ///< orientation delta between parts as rotation matrix
204        /** flag: generated f0 should include delta data.
205                set by 'singlestep' if j: attributes use delta option */
206        bool usedelta;
207        Pt3D vcolor;
208
209        static Param &getStaticParam();
210};
211
212#define JOINT_DELTA_MARKER 99999.0
213
214
215
216////////////////// Neural Network /////////////////
217
218class NeuroClass;
219
220typedef UserTags<NeuroClass, void *, 5> NeuroClassUserTags;
221
222/** Information about neuron class.
223 */
224class NeuroClass
225{
226        bool ownedvectordata;
227        void operator=(const NeuroClass &nosuchthich) {}
228public:
229        SString name, longname, description;
230        ParamEntry *props;
231        bool ownedprops; //< destructor will free props using ParamObject::freeParamTab
232        paInt prefinputs, prefoutput;
233        paInt preflocation;
234
235        enum PrefLocation { PREFER_UNATTACHED = 0, PREFER_PART = 1, PREFER_JOINT = 2 };
236
237        static constexpr int SUPPORTED_SHAPETYPE_BALL_AND_STICK = 1;
238        static constexpr int SUPPORTED_SHAPETYPE_SOLIDS = 2;
239        static constexpr int SUPPORTED_SHAPETYPE_ALL = SUPPORTED_SHAPETYPE_BALL_AND_STICK | SUPPORTED_SHAPETYPE_SOLIDS;
240        paInt supported_shape_types; //< bitfield of 'Model::shape' values: NeuroClass::SUPPORTED_SHAPE_xxx = 1 << Model::SHAPE_xxx
241
242        static constexpr int SUPPORTED_JOINT_STICK = 1;
243        static constexpr int SUPPORTED_JOINT_FIXED = 2;
244        static constexpr int SUPPORTED_JOINT_HINGE_X = 4;
245        static constexpr int SUPPORTED_JOINT_HINGE_XY = 8;
246        static constexpr int SUPPORTED_JOINTSHAPE_ALL = SUPPORTED_JOINT_STICK + SUPPORTED_JOINT_FIXED + SUPPORTED_JOINT_HINGE_X + SUPPORTED_JOINT_HINGE_XY;
247        paInt supported_joint_shapes; //< bitfield of 'Joint::shape' values: NeuroClass::SUPPORTED_JOINT_xxx = 1 << JOINT::SHAPE_xxx
248
249        int *vectordata;
250        paInt visualhints;
251
252        //void *impl;
253        int impl_count;
254        bool active;
255        bool genactive;
256        NeuroClassUserTags userdata;
257
258        //////////////////////
259        ~NeuroClass();
260        NeuroClass();
261        NeuroClass(ParamEntry *_props, SString _description,
262                int _prefinputs, int _prefoutput, int _preflocation, int *_vectordata, bool own_vd = 1, int vhints = 0, int sup_shapes = NeuroClass::SUPPORTED_SHAPETYPE_ALL, int sup_joints = NeuroClass::SUPPORTED_JOINTSHAPE_ALL);
263        /** class name for use in Neuro::setClassName(), Neuro::setDetails() (former 'moredata' field),
264                eg. "N","-",G" */
265        const SString &getName() { return name; }
266        /** human friendly name, eg. "Neuron","Link","Gyroscope"  */
267        const SString &getLongName() { return longname; }
268        /** long description */
269        const SString &getDescription() { return description; }
270        ParamEntry *getParamTab() { return props; }
271
272        /** NeuroClass specific properties, recognized by all neurons of this class */
273        Param getProperties() { return Param(props); }
274
275        /** preferred number of inputs, -1 = no preference (any number will go).
276                extra inputs may be ignored by the object (depends on the class).
277                */
278        int getPreferredInputs() { return (int)prefinputs; }
279
280        /** @return 0 if this object doesn't provide useful output signal. */
281        int getPreferredOutput() { return (int)prefoutput; }
282
283        /** @return 0 (PREFER_UNATTACHED) if the neuron doesn't need any assignment to a body element.
284                @return 1 (PREFER_PART) if the neuron likes to be attached to a Part ( @see Neuro::attachToPart() )
285                @return 2 (PREFER_JOINT) if the neuron prefers to be attached to a Joint ( @see Neuro::attachToJoint() )
286                */
287        PrefLocation getPreferredLocation() { return (PrefLocation)preflocation; }
288        /** vector drawing to be used in neuro net diagram.
289                interpretation:
290                {
291                LEN = datalength (excluding this number)
292                NL = number_of_lines
293                line#1 ->  NS = number_of_segments, x1,y1, x2,y2, ... xNS-1,yNS-1,
294                ...
295                line#NL -> NS = number_of_segments, x1,y1, x2,y2, ... xNS-1,yNS-1,
296                }
297                */
298        int getSupportedShapeTypes() { return (int)supported_shape_types; }
299        bool isShapeTypeSupported(ModelEnum::ShapeType t) { return (1 << (int)t) & supported_shape_types; }
300        int getSupportedJointShapes() { return (int)supported_joint_shapes; }
301        bool isJointShapeSupported(Joint::Shape t) { return (1 << (int)t) & supported_joint_shapes; }
302        int *getSymbolGlyph()
303        {
304                return vectordata;
305        }
306        void setSymbolGlyph(int *data, bool owned = true)
307        {
308                if (vectordata && ownedvectordata) delete[]vectordata;
309                vectordata = data;
310                ownedvectordata = owned;
311        }
312        /** additional information about how the neuron should be drawn
313                used by structure view (and maybe some other components).
314                return value is defined by the enum Hint
315                @see enum Hint
316                */
317        int getVisualHints()
318        {
319                return (int)visualhints;
320        }
321
322        enum Hint
323        {
324                /** don't draw neurons of this class */
325                Invisible = 1,
326                /** don't draw classname label below the neuron */
327                DontShowClass = 2,
328                /** draw the neuron at the first part when attached to joint (default is in the middle) */
329                AtFirstPart = 4,
330                /** draw the neuron at the second part when attached to joint (default is in the middle) */
331                AtSecondPart = 8,
332                /** use effector colour for this neuro unit */
333                EffectorClass = 16,
334                /** use receptor colour for this neuro unit */
335                ReceptorClass = 32,
336                IsV1BendMuscle = 64,
337                IsV1RotMuscle = 128,
338                IsLinearMuscle = 256,
339                IsSolidMuscle = 512
340        };
341
342        /** textual summary, automatically generated from other properties (like the neuro class tooltip) */
343        SString getSummary();
344
345        static void resetActive(); ///< set default values of active and genactive for all classes
346        static void setGenActive(const char *classes[]); ///< set genactive for specified classes
347};
348
349
350
351
352
353
354/** Single processing unit in Framsticks neural network.  */
355class Neuro : public PartBase
356{
357        friend class Model;
358        static SString getDefaultStyle();
359
360        struct NInput {
361                Neuro *n; double weight; SString *info;
362                NInput(Neuro *_n, double w, SString *i = 0) :n(_n), weight(w), info(i) {}
363        };
364
365        SListTempl<NInput> inputs;
366
367        NeuroClass *myclass;
368        bool knownclass;
369        SString myclassname, myclassparams;
370        /** set myclass and make knownclass=true */
371        void checkClass();
372        SString **inputInfo(int i);
373        void defassign();
374
375public:
376        enum NeuroFlags { HoldState = 2 };
377        Param properties();
378        Param extraProperties();
379
380        void setInputInfo(int i, const SString &name, const SString &value);
381        void setInputInfo(int i, const SString &name, int value);
382        void setInputInfo(int i, const SString &name, double value);
383        SString getInputInfo(int i);
384        SString getInputInfo(int i, const SString &name);
385
386        NeuroClass *getClass();
387        void setClass(NeuroClass *);
388
389        SString getClassParams() { return myclassparams; }
390        void setClassParams(const SString &cp) { myclassparams = cp; }
391
392        SString getClassName();
393        void setClassName(const SString &clazz);
394
395        /** return neuro unit details encoded as <CLASS> ":" <PROPERTIES>
396
397                new Neuro can be created as root object (without parent) or can be
398                the child of existing Neuro. Children of the Neuro are its inputs.
399                Standard Framsticks neuron calculates the sum of all input units - other processing
400                units don't have to treat them equally and can even ignore some of them.
401                There are hints about expected inputs in the class database, @see getClass
402
403                Application should not assume anything about classes and its properties
404                except for two standard classes: (information about all current classes
405                can be retrieved with getClass/getClassProperties methods)
406                - getClassName()="N" is the standard Framsticks neuron, accepts any number of inputs,
407                compatible with old Neuro object
408                - getClassName()="-" is the neuron link, compatible with old Neuro-Neuro link
409                (NeuroItem with empty details)
410                Empty details defaults to "-" if the parent unit is specified,
411                and "N" if the unit has no parent.
412                */
413        SString getDetails();
414
415        /** details = classname + ":" + classparams
416                @see getDetails()
417                */
418        void setDetails(const SString &);
419
420#define STATRICKCLASS Neuro
421        PARAMGETDEF(details) { arg1->setString(getDetails()); }
422        PARAMSETDEF(details) { setDetails(arg1->getString()); return PSET_CHANGED; }
423        PARAMGETDEF(inputCount);
424        PARAMPROCDEF(p_getInputNeuroDef);
425        PARAMPROCDEF(p_getInputNeuroIndex);
426        PARAMPROCDEF(p_getInputWeight);
427        PARAMGETDEF(classObject);
428#undef STATRICKCLASS
429
430        ///@param handle_defaults_when_saving see SyntParam
431        SyntParam classProperties(bool handle_defaults_when_saving = true);
432        // base properties:
433        paInt refno; ///< unique reference number (former 'neuro' refno)
434
435        paInt part_refno; ///< can be used by some items as the part ref#
436        paInt joint_refno; ///< can be used by some items as the joint ref#
437
438        Pt3D pos, rot;  ///< default = zero
439
440        ModelUserTags userdata;
441
442        Neuro();
443        Neuro(double _state, double _inertia, double _force, double _sigmo);
444        Neuro(const Neuro &src) :PartBase(getDefaultStyle()) { operator=(src); }
445
446        ~Neuro();
447
448        void operator=(const Neuro &src);
449
450        /** Attach this Neuro to the specified Part or detach it from the body if p==NULL.
451                Neuro can be attached to either Part or Joint, but not both.
452                @see getPart()
453                */
454        void attachToPart(Part *p) { part = p; joint = 0; }
455
456        /** Attach this Neuro to the specified Joint or detach it from the body if p==NULL.
457                Neuro can be attached to either Part or Joint, but not both.
458                @see getJoint()
459                */
460        void attachToJoint(Joint *j) { joint = j; part = 0; }
461
462        void attachToPart(int i);
463        void attachToJoint(int i);
464
465        /** @return Part the Neuro is attached to, or NULL if it has no defined location on the body.
466                @see attachToPart()
467                */
468        Part *getPart() { return part; }
469
470        /** @return Joint the Neuro is attached to, or NULL if it has no defined location on the body.
471                @see attachToJoint()
472                */
473        Joint *getJoint() { return joint; }
474
475        int isOldEffector();
476        int isOldReceptor();
477        int isOldNeuron();
478        int isNNConnection();
479
480        /** @return the number of inputs connected to this Neuro.
481                Functions like getInput(), getInputWeight() will accept connection number [0..InputCount-1]
482                */
483        int getInputCount() const { return inputs.size(); }
484
485        /// @return the number of output connections (including possible self-connections)
486        int getOutputsCount() const;
487
488        /** @return the Neuro connected as i-th input */
489        Neuro *getInput(int i) const { return (i >= inputs.size()) ? 0 : inputs(i).n; }
490        /** @return the Neuro connected as i-th input.
491                @param weight
492                */
493        Neuro *getInput(int i, double &weight) const;
494        /** @return connectin weight for i-th input */
495        double getInputWeight(int i) const;
496        /** change connection weight for i-th input */
497        void setInputWeight(int i, double weight);
498        /** connect i-th input with another neuron */
499        void setInput(int i, Neuro *n);
500        /** connect i-th input with another neuron */
501        void setInput(int i, Neuro *n, double weight);
502        /** add new input. @return its reference number */
503        int addInput(Neuro *child, double weight = 1.0, const SString *info = 0);
504        /** @return reference number [0..InputCount-1] of the input
505           or -1 if 'child' is not connected with this Neuro.*/
506        int findInput(Neuro *child) const;
507        void removeInput(paInt refno);
508        /**    @return reference number of the child connection, like findInput() */
509        int removeInput(Neuro *child);
510
511        int findInputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
512        int findOutputs(SList &result, const char *classname = 0, const Part *part = 0, const Joint *joint = 0) const;
513
514        /* class database retrieval */
515        static int getClassCount();
516        /** @return Neuro class name.
517                @param classindex 0 .. getClassCount()
518                */
519        static SString getClassName(int classindex);
520        static NeuroClass *getClass(int classindex);
521        static NeuroClass *getClass(const SString &classname);
522        static int getClassIndex(const NeuroClass *nc);
523
524        // not really private, but you should not access those directly
525        double state;
526
527        /** may reference parent neuron if parentcount is exacty 1. parent is invalid otherwise. @sa parentcount */
528        Neuro *parent;
529        int parentcount; ///< @sa parent
530
531        Part *part;     ///< link to the Part
532        Joint *joint;   ///< link to the Joint - required by some objects (eg.muscles)
533        Orient o;       ///< rotation matrix calculated from "rot"
534        static ParamEntry emptyParamTab[];
535        static Param &getStaticParam();
536};
537
538class NeuroExt : public Neuro
539{
540public:
541#define STATRICKCLASS NeuroExt
542        PARAMGETDEF(neuroclass);
543        PARAMSETDEF(neuroclass);
544        PARAMGETDEF(liveNeuro);
545#undef STATRICKCLASS
546        static ParamEntry *getParamTab();
547};
548
549class NeuroConn
550{
551        void defassign();
552public:
553        int n1_refno, n2_refno;
554        double weight;
555        SString info;
556        NeuroConn();
557};
558
559extern ParamEntry f0_part_paramtab[], f0_part_minmaxdef_paramtab[], f0_joint_paramtab[], f0_nodeltajoint_paramtab[], f0_neuro_paramtab[], f0_neuroconn_paramtab[], f0_neuroitem_paramtab[];
560
561#endif
Note: See TracBrowser for help on using the repository browser.