COVISE Core
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros
coDoData.h
Go to the documentation of this file.
1 /* This file is part of COVISE.
2 
3  You can use it under the terms of the GNU Lesser General Public License
4  version 2.1 or later, see lgpl-2.1.txt.
5 
6  * License: LGPL 2+ */
7 
8 #ifndef CO_DO_DATA_H
9 #define CO_DO_DATA_H
10 
11 #include "coDistributedObject.h"
12 
13 /***********************************************************************\
14  ** **
15  ** Unstructured data class Version: 1.0 **
16  ** **
17  ** **
18  ** Description : Classes for the handling of the data on **
19  ** a structured grid in a distributed manner. **
20  ** **
21  ** Classes : DO_Unstructured_S3d_data, DO_Unstructured_V3d_data **
22  ** **
23  ** Copyright (C) 1993 by University of Stuttgart **
24  ** Computer Center (RUS) **
25  ** Allmandring 30 **
26  ** 7000 Stuttgart 80 **
27  ** **
28  ** **
29  ** Author : A. Wierse (RUS) **
30  ** **
31  ** History : **
32  ** 23.06.93 Ver 1.0 **
33  ** **
34  ** **
35 \***********************************************************************/
36 
37 namespace covise
38 {
39 
40 inline int coIndex(const int i[3], const int dims[3])
41 {
42  return (i[0] * dims[1] + i[1]) * dims[2] + i[2];
43 }
44 
45 inline int coIndex(int i, int j, int k, int im, int jm, int km)
46 {
47  int index[3] = { i, j, k };
48  int sizes[3] = { im, jm, km };
49  return coIndex(index, sizes);
50 }
51 
52 inline int coIndex(int i, int j, int k, const int dims[3])
53 {
54  int index[3] = { i, j, k };
55  return coIndex(index, dims);
56 }
57 
59 {
60 public:
61  coDoAbstractData(const coObjInfo &info, const char *t)
62  : coDistributedObject(info, t)
63  {
64  }
65  virtual void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx) = 0;
66  virtual void setNullValue(int dstIdx) = 0;
67  virtual coDoAbstractData *cloneType(const coObjInfo &info, int numElements) const = 0;
68 
69  virtual int getNumPoints() const // returns gridsize
70  {
71  return no_of_points;
72  }
73 
74 protected:
75  coIntShm no_of_points; // number of points
76 };
77 
78 extern DOEXPORT const char USTSDT[];
79 extern DOEXPORT const char RGBADT[];
80 extern DOEXPORT const char INTDT[];
81 extern DOEXPORT const char BYTEDT[];
82 
83 template <typename ValueType, int typenum, const char *typetag>
85 {
86 protected:
88 
90  {
91  covise_data_list dl[2];
92 
93  if (shmarr == NULL)
94  {
95  cerr << "called rebuildFromShm without shmarray\n";
96  print_exit(__LINE__, __FILE__, 1);
97  }
98  dl[0].type = INTSHM;
99  dl[0].ptr = &no_of_points;
100  dl[1].type = typenum;
101  dl[1].ptr = &s_data;
102  return restore_shared_dl(2, dl);
103  }
104 
105  int getObjInfo(int no, coDoInfo **il) const
106  {
107  if (no == 2)
108  {
109  (*il)[0].description = "Number of Points";
110  (*il)[1].description = "Data Values";
111  return 2;
112  }
113  else
114  {
115  print_error(__LINE__, __FILE__, "number wrong for object info");
116  return 0;
117  }
118  }
119 
120  coDoScalarData *cloneObject(const coObjInfo &newinfo) const
121  {
122  return new coDoScalarData(newinfo, getNumPoints(), getAddress());
123  }
124 
125 public:
127  : coDoAbstractData(info, typetag)
128  {
129  if (name)
130  {
131  if (getShmArray() != 0)
132  {
133  if (rebuildFromShm() == 0)
134  {
135  print_comment(__LINE__, __FILE__, "rebuildFromShm == 0");
136  }
137  }
138  else
139  {
140  print_comment(__LINE__, __FILE__, "object %s doesn't exist", name);
141  new_ok = 0;
142  }
143  }
144  }
145 
147  : coDoAbstractData(info, typetag)
148  {
149  if (createFromShm(arr) == 0)
150  {
151  print_comment(__LINE__, __FILE__, "createFromShm == 0");
152  new_ok = 0;
153  }
154  }
155 
156  coDoScalarData(const coObjInfo &info, int no, ValueType *s)
157  : coDoAbstractData(info, typetag)
158  {
159  covise_data_list dl[2];
160  s_data.set_length(no);
161  dl[0].type = INTSHM;
162  dl[0].ptr = &no_of_points;
163  dl[1].type = typenum;
164  dl[1].ptr = &s_data;
165  new_ok = store_shared_dl(2, dl) != 0;
166  if (!new_ok)
167  return;
168  no_of_points = no;
169 
170  int n = no * sizeof(ValueType);
171  ValueType *tmps;
172  getAddress(&tmps);
173  memcpy(tmps, s, n);
174  }
175 
176  coDoScalarData(const coObjInfo &info, int no)
177  : coDoAbstractData(info, typetag)
178  {
179  covise_data_list dl[2];
180  s_data.set_length(no);
181  dl[0].type = INTSHM;
182  dl[0].ptr = &no_of_points;
183  dl[1].type = typenum;
184  dl[1].ptr = &s_data;
185 
186  new_ok = store_shared_dl(2, dl) != 0;
187  if (!new_ok)
188  return;
189  no_of_points = no;
190 // workaround for windows error (ShowUsg), method not found
191 // must be used inside the constructor
192 #ifdef _WIN32
193  setPointValue(0, s_data[0]);
194 #endif
195  }
196 
197  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
198  {
199  return new coDoScalarData(info, no);
200  }
201 
202  void getPointValue(int no, ValueType *s) const
203  {
204  *s = s_data[no];
205  }
206 
207  void setPointValue(int no, ValueType s)
208  {
209  s_data[no] = s;
210  }
211 
212  void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
213  {
214  s_data[dstIdx] = static_cast<const coDoScalarData *>(src)->s_data[srcIdx];
215  }
216 
217  void setNullValue(int dstIdx)
218  {
219  s_data[dstIdx] = 0;
220  }
221 
222  // data in linearized form:
223  void getAddress(ValueType **data) const
224  {
225  *data = static_cast<ValueType *>(s_data.getDataPtr());
226  }
227  ValueType *getAddress() const
228  {
229  return static_cast<ValueType *>(s_data.getDataPtr());
230  }
231 
238  int setSize(int numElem)
239  {
240  if (numElem > no_of_points)
241  return -1;
242 
243  no_of_points = numElem;
244  return 0;
245  }
246 
248  {
249  return new coDoScalarData(coObjInfo(), arr);
250  }
251 };
252 
253 INST_TEMPLATE3(template class DOEXPORT coDoScalarData<float, FLOATSHMARRAY, USTSDT>)
256 typedef coDoScalarData<int, INTSHMARRAY, INTDT> coDoInt;
258 typedef coDoScalarData<unsigned char, CHARSHMARRAY, BYTEDT> coDoByte;
259 
260 INST_TEMPLATE3(template class DOEXPORT coDoScalarData<int, INTSHMARRAY, RGBADT>)
261 class DOEXPORT coDoRGBA : public coDoScalarData<int, INTSHMARRAY, RGBADT>
262 {
263  friend class coDoInitializer;
264  static coDistributedObject *virtualCtor(coShmArray *arr);
265 
266 public:
267  coDoRGBA(const coObjInfo &info)
268  : coDoScalarData<int, INTSHMARRAY, RGBADT>(info)
269  {
270  }
271  coDoRGBA(const coObjInfo &info, coShmArray *arr)
272  : coDoScalarData<int, INTSHMARRAY, RGBADT>(info, arr)
273  {
274  }
275  coDoRGBA(const coObjInfo &info, int no, int *pc)
276  : coDoScalarData<int, INTSHMARRAY, RGBADT>(info, no, pc)
277  {
278  }
279  coDoRGBA(const coObjInfo &info, int no)
280  : coDoScalarData<int, INTSHMARRAY, RGBADT>(info, no)
281  {
282  }
283 
284  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
285  {
286  return new coDoRGBA(info, no);
287  }
288 
289  int setFloatRGBA(int pos, float r, float g, float b, float a = 1.0);
290  int setIntRGBA(int pos, int r, int g, int b, int a = 255);
291  int getFloatRGBA(int pos, float *r, float *g, float *b, float *a) const;
292  int getIntRGBA(int pos, int *r, int *g, int *b, int *a) const;
293 
294 protected:
295  coDoRGBA *cloneObject(const coObjInfo &newinfo) const;
296 };
297 
299 {
300  friend class coDoInitializer;
301  static coDistributedObject *virtualCtor(coShmArray *arr);
302  coFloatShmArray s_data; // scalar data
303  coFloatShmArray t_data; // scalar data
304 protected:
305  int rebuildFromShm();
306  int getObjInfo(int, coDoInfo **) const;
307  coDoVec2 *cloneObject(const coObjInfo &newinfo) const;
308 
309 public:
310  coDoVec2(const coObjInfo &info)
311  : coDoAbstractData(info, "USTSTD")
312  {
313  if (name)
314  {
315  if (getShmArray() != 0)
316  {
317  if (rebuildFromShm() == 0)
318  {
319  print_comment(__LINE__, __FILE__, "rebuildFromShm == 0");
320  }
321  }
322  else
323  {
324  print_comment(__LINE__, __FILE__, "object %s doesn't exist", name);
325  new_ok = 0;
326  }
327  }
328  };
329  coDoVec2(const coObjInfo &info, coShmArray *arr);
330  coDoVec2(const coObjInfo &info, int no, float *s, float *t);
331  coDoVec2(const coObjInfo &info, int no);
332  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
333  {
334  return new coDoVec2(info, no);
335  }
336  void getPointValue(int no, float *s, float *t) const
337  {
338  *s = s_data[no];
339  *t = t_data[no];
340  };
341  void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
342  {
343  s_data[dstIdx] = static_cast<const coDoVec2 *>(src)->s_data[srcIdx];
344  t_data[dstIdx] = static_cast<const coDoVec2 *>(src)->t_data[srcIdx];
345  }
346  void setNullValue(int dstIdx)
347  {
348  s_data[dstIdx] = 0;
349  t_data[dstIdx] = 0;
350  }
351  // data in linearized form:
352  void getAddresses(float **s_d, float **t_d) const
353  {
354  *s_d = (float *)(s_data.getDataPtr());
355  *t_d = (float *)(t_data.getDataPtr());
356  };
357 
364  int setSize(int numElem);
365 };
366 
368 {
369  friend class coDoInitializer;
370  static coDistributedObject *virtualCtor(coShmArray *arr);
371  coFloatShmArray u; // data for vector
372  coFloatShmArray v; // data for vector
373  coFloatShmArray w; // data for vector
374 protected:
375  int rebuildFromShm();
376  int getObjInfo(int, coDoInfo **) const;
377  coDoVec3 *cloneObject(const coObjInfo &newinfo) const;
378 
379 public:
380  coDoVec3(const coObjInfo &info)
381  : coDoAbstractData(info, "USTVDT")
382  {
383  if (name)
384  {
385  if (getShmArray() != 0)
386  {
387  if (rebuildFromShm() == 0)
388  {
389  print_comment(__LINE__, __FILE__, "rebuildFromShm == 0");
390  }
391  }
392  else
393  {
394  print_comment(__LINE__, __FILE__, "object %s doesn't exist", name);
395  new_ok = 0;
396  }
397  }
398  };
399  coDoVec3(const coObjInfo &info, coShmArray *arr);
400  coDoVec3(const coObjInfo &info, int no,
401  float *xc, float *yc, float *zc);
402  coDoVec3(const coObjInfo &info, int no);
403  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
404  {
405  return new coDoVec3(info, no);
406  }
407  void getPointValue(int no, float *s) const
408  {
409  s[0] = u[no];
410  s[1] = v[no];
411  s[2] = w[no];
412  };
413  void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
414  {
415  u[dstIdx] = static_cast<const coDoVec3 *>(src)->u[srcIdx];
416  v[dstIdx] = static_cast<const coDoVec3 *>(src)->v[srcIdx];
417  w[dstIdx] = static_cast<const coDoVec3 *>(src)->w[srcIdx];
418  }
419  void setNullValue(int dstIdx)
420  {
421  u[dstIdx] = v[dstIdx] = w[dstIdx] = 0;
422  }
423  void getAddresses(float **u_v, float **v_v, float **w_v) const
424  {
425  *u_v = (float *)u.getDataPtr();
426  *v_v = (float *)v.getDataPtr();
427  *w_v = (float *)w.getDataPtr();
428  };
429 
436  int setSize(int numElem);
437 };
438 
439 // storage order
440 // R3D: XX XY XZ YX YY YZ ZX ZY ZZ
442 {
443  friend class coDoInitializer;
444  static coDistributedObject *virtualCtor(coShmArray *arr);
445  // a single coFloatShmArray may make construction more efficient
446  // in many cases than having as many coFloatShmArrays as components
448 
449 protected:
450  int rebuildFromShm();
451  int getObjInfo(int, coDoInfo **) const;
452  coDoMat3 *cloneObject(const coObjInfo &newinfo) const;
453 
454 public:
455  enum
456  {
457  X = 0,
458  Y = 1,
459  Z = 2
460  };
461  coDoMat3(const coObjInfo &info)
462  : coDoAbstractData(info, "USTREF")
463  {
464  if (name)
465  {
466  if (getShmArray() != 0)
467  {
468  if (rebuildFromShm() == 0)
469  {
470  print_comment(__LINE__, __FILE__, "rebuildFromShm == 0");
471  }
472  }
473  else
474  {
475  print_comment(__LINE__, __FILE__, "object %s doesn't exist", name);
476  new_ok = 0;
477  }
478  }
479  };
480  coDoMat3(const coObjInfo &info, coShmArray *arr);
481  coDoMat3(const coObjInfo &info, int no, float *r_c);
482  coDoMat3(const coObjInfo &info, int no);
483  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
484  {
485  return new coDoMat3(info, no);
486  }
487  void getPointValue(int no, float *m) const
488  {
489  memcpy(m, &references[9 * no], 9 * sizeof(float));
490  };
491  void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
492  {
493  memcpy(&references[9 * dstIdx], &static_cast<const coDoMat3 *>(src)->references[9 * srcIdx], 9 * sizeof(float));
494  }
495  void setNullValue(int dstIdx)
496  {
497  memset(&references[9 * dstIdx], 0, 9 * sizeof(float));
498  }
499  void getAddress(float **ref) const
500  {
501  *ref = (float *)(references.getDataPtr());
502  };
503  float *getAddress() const
504  {
505  return static_cast<float *>(references.getDataPtr());
506  }
507 
514  int setSize(int numElem);
515 };
516 
517 // storage order
518 // S2D: XX YY XY
519 // F2D: XX XY YX YY
520 // S3D: XX YY ZZ XY YZ ZX
521 // F3D: XX XY XZ YX YY YZ ZX ZY ZZ
523 {
524  friend class coDoInitializer;
525  static coDistributedObject *virtualCtor(coShmArray *arr);
526 
527 public:
528  // new entries in enum TensorType require registration in
529  // in intTypes_ and strTypes_ leaving UNKNOWN as the last entry
530  // in these arrays
532  {
533  UNKNOWN = 0,
534  S2D = 3,
535  F2D = 4,
536  S3D = 6,
537  F3D = 9
538  };
539 
540 private:
541  static const TensorType listOfTypes_[];
542  static const char *strTypes_[];
544  // a single coFloatShmArray may make construction more efficient
545  // in many cases than having as many coFloatShmArrays as components
547 
548 protected:
549  int rebuildFromShm();
550  int getObjInfo(int, coDoInfo **) const;
551  coDoTensor *cloneObject(const coObjInfo &newinfo) const;
552 
553 public:
554  TensorType getTensorType() const; //{return TensorType_;}
555  int dimension() const
556  {
557  return TensorType_;
558  }
559  const char *getTensorCharType() const;
560  coDoTensor(const coObjInfo &info, TensorType ttype)
561  : coDoAbstractData(info, "USTTDT")
562  {
563  TensorType_ = ttype;
564  if (name)
565  {
566  if (getShmArray() != 0)
567  {
568  if (rebuildFromShm() == 0)
569  {
570  print_comment(__LINE__, __FILE__, "rebuildFromShm == 0");
571  }
572  }
573  else
574  {
575  print_comment(__LINE__, __FILE__, "object %s doesn't exist", name);
576  new_ok = 0;
577  }
578  }
579  };
580  coDoTensor(const coObjInfo &info, coShmArray *arr);
581  coDoTensor(const coObjInfo &info, int no, float *r_c, TensorType ttype);
582  coDoTensor(const coObjInfo &info, int no, TensorType ttype);
583  coDoAbstractData *cloneType(const coObjInfo &info, int no) const
584  {
585  return new coDoTensor(info, no, getTensorType());
586  }
587  void getPointValue(int no, float *m) const
588  {
589  memcpy(m, &t_data[TensorType_ * no], TensorType_ * sizeof(float));
590  };
591  void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
592  {
593  memcpy(&t_data[TensorType_ * dstIdx], &static_cast<const coDoTensor *>(src)->t_data[TensorType_ * srcIdx], TensorType_ * sizeof(float));
594  }
595  void setNullValue(int dstIdx)
596  {
597  memset(&t_data[TensorType_ * dstIdx], 0, TensorType_ * sizeof(float));
598  }
599  void getAddress(float **ref) const
600  {
601  *ref = (float *)(t_data.getDataPtr());
602  };
603  float *getAddress() const
604  {
605  return static_cast<float *>(t_data.getDataPtr());
606  }
607 
614  int setSize(int numElem);
615 };
616 }
617 #endif
coDoTensor(const coObjInfo &info, TensorType ttype)
Definition: coDoData.h:560
void getAddress(float **ref) const
Definition: coDoData.h:499
void getPointValue(int no, float *m) const
Definition: coDoData.h:487
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:197
GLuint const GLchar * name
Definition: khronos-glext.h:6722
void getPointValue(int no, ValueType *s) const
Definition: coDoData.h:202
void setNullValue(int dstIdx)
Definition: coDoData.h:346
coDoVec3(const coObjInfo &info)
Definition: coDoData.h:380
coDoVec2(const coObjInfo &info)
Definition: coDoData.h:310
void getPointValue(int no, float *s) const
Definition: coDoData.h:407
Definition: covise_shm.h:481
coDoScalarData * cloneObject(const coObjInfo &newinfo) const
Definition: coDoData.h:120
void setNullValue(int dstIdx)
Definition: coDoData.h:217
GLdouble n
Definition: khronos-glext.h:8447
GLboolean GLboolean GLboolean b
Definition: khronos-glext.h:6895
int coIndex(const int i[3], const int dims[3])
Definition: coDoData.h:40
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:403
void setNullValue(int dstIdx)
Definition: coDoData.h:595
void setNullValue(int dstIdx)
Definition: coDoData.h:419
coDoRGBA(const coObjInfo &info, int no, int *pc)
Definition: coDoData.h:275
GLdouble s
Definition: khronos-glext.h:6441
Definition: covise_statics.cpp:54
coFloatShmArray w
Definition: coDoData.h:373
void print_error(int line, const char *filename, const char *fmt,...)
Definition: coLog.cpp:132
coDoRGBA(const coObjInfo &info, int no)
Definition: coDoData.h:279
float * getAddress() const
Definition: coDoData.h:603
const int CHARSHMARRAY
Definition: covise_shm.h:107
const char USTSDT[]
Definition: coDoData.cpp:39
const char RGBADT[]
Definition: coDoData.cpp:41
#define NULL
Definition: covise_list.h:22
Definition: coDoData.h:441
void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
Definition: coDoData.h:413
coDoRGBA(const coObjInfo &info)
Definition: coDoData.h:267
void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
Definition: coDoData.h:212
coFloatShmArray u
Definition: coDoData.h:371
int dimension() const
Definition: coDoData.h:555
Definition: coObjID.h:230
const char INTDT[]
Definition: coDoData.cpp:40
coFloatShmArray t_data
Definition: coDoData.h:303
void getAddresses(float **u_v, float **v_v, float **w_v) const
Definition: coDoData.h:423
void setNullValue(int dstIdx)
Definition: coDoData.h:495
coDoRGBA(const coObjInfo &info, coShmArray *arr)
Definition: coDoData.h:271
coDoScalarData(const coObjInfo &info)
Definition: coDoData.h:126
coFloatShmArray t_data
Definition: coDoData.h:546
void getPointValue(int no, float *m) const
Definition: coDoData.h:587
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:483
const int INTSHM
Definition: covise_shm.h:125
Definition: coDistributedObject.h:266
Definition: coDoData.h:522
const char BYTEDT[]
Definition: coDoData.cpp:42
GLdouble GLdouble GLdouble r
Definition: khronos-glext.h:6457
coDoScalarData(const coObjInfo &info, int no)
Definition: coDoData.h:176
Definition: coDistributedObject.h:90
const GLdouble * v
Definition: khronos-glext.h:6442
const void * ptr
Definition: coDistributedObject.h:93
GLboolean GLboolean GLboolean GLboolean a
Definition: khronos-glext.h:6895
coDoMat3(const coObjInfo &info)
Definition: coDoData.h:461
void getAddress(float **ref) const
Definition: coDoData.h:599
TensorType
Definition: coDoData.h:531
Definition: coDoData.h:367
void getPointValue(int no, float *s, float *t) const
Definition: coDoData.h:336
coFloatShmArray references
Definition: coDoData.h:447
#define DOEXPORT
Definition: coExport.h:307
GLubyte GLubyte GLubyte GLubyte w
Definition: khronos-glext.h:6793
coDataShmArray< ValueType, typenum > s_data
Definition: coDoData.h:87
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:583
#define INST_TEMPLATE3(x, y, z)
Definition: coExport.h:38
static coDistributedObject * virtualCtor(coShmArray *arr)
Definition: coDoData.h:247
void print_comment(int line, const char *filename, const char *fmt,...)
Definition: coLog.cpp:25
virtual int getNumPoints() const
Definition: coDoData.h:69
void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
Definition: coDoData.h:591
const GLfloat * m
Definition: khronos-glext.h:12117
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:284
Definition: coDoData.h:58
GLboolean GLboolean g
Definition: khronos-glext.h:6895
const int INTSHMARRAY
Definition: covise_shm.h:109
void getAddresses(float **s_d, float **t_d) const
Definition: coDoData.h:352
coFloatShmArray v
Definition: coDoData.h:372
void getAddress(ValueType **data) const
Definition: coDoData.h:223
void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
Definition: coDoData.h:491
int setSize(int numElem)
Definition: coDoData.h:238
const int UNKNOWN
Definition: covise_shm.h:138
GLuint index
Definition: khronos-glext.h:6722
Definition: coDoData.h:84
const int FLOATSHMARRAY
Definition: covise_shm.h:114
float * getAddress() const
Definition: coDoData.h:503
int rebuildFromShm()
Definition: coDoData.h:89
Definition: coDistributedObject.h:295
coDoAbstractData * cloneType(const coObjInfo &info, int no) const
Definition: coDoData.h:332
coDoScalarData(const coObjInfo &info, coShmArray *arr)
Definition: coDoData.h:146
static coShmArray * getShmArray(const char *name)
Definition: coDistributedObject.cpp:60
void print_exit(int line, const char *filename, int how)
Definition: coLog.cpp:69
GLenum GLint ref
Definition: khronos-glext.h:6719
data_type type
Definition: coDistributedObject.h:92
GLdouble GLdouble t
Definition: khronos-glext.h:6449
ValueType * getAddress() const
Definition: coDoData.h:227
coIntShm no_of_points
Definition: coDoData.h:75
coDoAbstractData(const coObjInfo &info, const char *t)
Definition: coDoData.h:61
GLenum src
Definition: khronos-glext.h:7031
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: khronos-glext.h:6354
coIntShm TensorType_
Definition: coDoData.h:543
void cloneValue(int dstIdx, const coDoAbstractData *src, int srcIdx)
Definition: coDoData.h:341
coDoScalarData(const coObjInfo &info, int no, ValueType *s)
Definition: coDoData.h:156
int getObjInfo(int no, coDoInfo **il) const
Definition: coDoData.h:105
Definition: coDoData.h:298
coFloatShmArray s_data
Definition: coDoData.h:302
void setPointValue(int no, ValueType s)
Definition: coDoData.h:207
Definition: coDoData.h:261