Open Inventor Reference
SoSubEngine.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (C) 2000 Silicon Graphics, Inc. All Rights Reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Lesser General Public License for more details.
14  *
15  * Further, this software is distributed without any warranty that it is
16  * free of the rightful claim of any third person regarding infringement
17  * or the like. Any license provided herein, whether implied or
18  * otherwise, applies only to this software file. Patent licenses, if
19  * any, provided herein do not apply to combinations of this program with
20  * other software, or any other product whatsoever.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with this library; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25  *
26  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
27  * Mountain View, CA 94043, or:
28  *
29  * http://www.sgi.com
30  *
31  * For further information regarding this notice, see:
32  *
33  * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
34  *
35  */
36 
37 
38 /*
39  * Copyright (C) 1990,91 Silicon Graphics, Inc.
40  *
41  _______________________________________________________________________
42  ______________ S I L I C O N G R A P H I C S I N C . ____________
43  |
44  | $Revision: 1.1.1.1 $
45  |
46  | Description:
47  | This file defines some macros that implement things common to
48  | subclasses of SoEngine. They may be used to make SoEngine
49  | subclassing easier. In all of the macros, the "className"
50  | parameter refers to the name of the engine subclass.
51  |
52  | Defined macros:
53  |
54  | Within class header:
55  |
56  | SO_ENGINE_HEADER(className)
57  | SO_ENGINE_ABSTRACT_HEADER(className)
58  |
59  | Within class source:
60  |
61  | At file scope:
62  |
63  | SO_ENGINE_SOURCE(className)
64  | SO_ENGINE_ABSTRACT_SOURCE(className)
65  |
66  | Inside the initClass method:
67  |
68  | SO_ENGINE_INIT_CLASS()
69  | SO_ENGINE_INIT_ABSTRACT_CLASS()
70  |
71  | Inside the constructor:
72  |
73  | SO_ENGINE_CONSTRUCTOR(className)
74  | SO_ENGINE_ADD_INPUT(inputName, (defaultValue))
75  | SO_ENGINE_ADD_OUTPUT(outputName, outputType)
76  | SO_ENGINE_DEFINE_ENUM_VALUE(enumType, enumValue)
77  | SO_ENGINE_IS_FIRST_INSTANCE() //!< a boolean value
78  |
79  | //!< the following are defined in <fields/So[SM]fEnum.h>:
80  | SO_ENGINE_SET_SF_ENUM_TYPE(fieldName,enumType)
81  | SO_ENGINE_SET_MF_ENUM_TYPE(fieldName,enumType)
82  |
83  | Inside the evaluate method:
84  |
85  | SO_ENGINE_OUTPUT(outputName, outputType, method)
86  |
87  | Author(s) : Paul S. Strauss, Gavin Bell
88  |
89  ______________ S I L I C O N G R A P H I C S I N C . ____________
90  _______________________________________________________________________
91  */
92 
93 #ifndef _SO_SUB_ENGINE_
94 #define _SO_SUB_ENGINE_
95 
96 #include <Inventor/engines/SoEngine.h>
97 #include <Inventor/engines/SoOutputData.h>
98 #include <Inventor/errors/SoDebugError.h>
99 #include <Inventor/fields/SoFieldData.h>
100 
101 
106 #ifdef DEBUG
107 #define SO__ENGINE_CHECK_INIT(className) \
108  if (classTypeId == SoType::badType()) { \
109  SoDebugError::post("SO_ENGINE_CONSTRUCTOR", \
110  "Can't construct an engine of type " \
111  SO__QUOTE(className), \
112  "until initClass() has been called"); \
113  return; \
114  }
115 
116 #define SO__ENGINE_CHECK_CONSTRUCT(where) { \
117  if (inputData == NULL) { \
118  SoDebugError::post(where, \
119  "Instance not properly constructed.\n" \
120  "Did you forget to put " \
121  "SO_ENGINE_CONSTRUCTOR()" \
122  " in the constructor?"); \
123  inputData = new SoFieldData(parentInputData ? \
124  *parentInputData : NULL); \
125  outputData = new SoEngineOutputData(parentOutputData ? \
126  *parentOutputData : NULL); \
127  } \
128  }
129 
130 #else
131 #define SO__ENGINE_CHECK_INIT(className)
132 #define SO__ENGINE_CHECK_CONSTRUCT(where)
133 #endif
134 
139 
145 
146 #define SO_ENGINE_ABSTRACT_HEADER(className) \
147  public: \
148  static SoType getClassTypeId() { return classTypeId; } \
149  virtual SoType getTypeId() const; /* Returns type id */ \
150  public: \
151  virtual const SoFieldData * getFieldData() const; \
152  virtual const SoEngineOutputData * getOutputData() const; \
153  protected: \
154  static const SoFieldData ** getInputDataPtr() \
155  { return (const SoFieldData **)&inputData; } \
156  static const SoEngineOutputData ** getOutputDataPtr() \
157  { return (const SoEngineOutputData **)&outputData; } \
158  private: \
159  static SoType classTypeId; /* Type id */ \
160  static bool firstInstance; /* True for first ctor call */ \
161  static SoFieldData *inputData; /* Info on input fields */ \
162  static SoEngineOutputData *outputData; /* Info on outputs */ \
163  static const SoFieldData **parentInputData; /* parent's fields */ \
164  static const SoEngineOutputData **parentOutputData
165 
166 #define SO_ENGINE_HEADER(className) \
167  \
168  SO_ENGINE_ABSTRACT_HEADER(className); \
169  \
170  private: \
171  static void *createInstance() /* Creates and returns instance */
172 
177 
178 #define SO__ENGINE_ABSTRACT_VARS(className) \
179  SoType className::classTypeId; \
180  bool className::firstInstance=TRUE; \
181  SoEngineOutputData *className::outputData; \
182  SoFieldData * className::inputData; \
183  const SoEngineOutputData **className::parentOutputData; \
184  const SoFieldData ** className::parentInputData
185 
186 #define SO__ENGINE_VARS(className) \
187  SO__ENGINE_ABSTRACT_VARS(className)
188 
193 
194 #define SO__ENGINE_ABSTRACT_METHODS(className) \
195  \
196  SoType \
197  className::getTypeId() const \
198  { \
199  return classTypeId; \
200  } \
201  \
202  const SoFieldData * \
203  className::getFieldData() const \
204  { \
205  return inputData; \
206  } \
207  \
208  const SoEngineOutputData * \
209  className::getOutputData() const \
210  { \
211  return outputData; \
212  }
213 
214 #define SO__ENGINE_METHODS(className) \
215  \
216  SO__ENGINE_ABSTRACT_METHODS(className) \
217  \
218  void * \
219  className::createInstance() \
220  { \
221  return (void *)(new className); \
222  }
223 
228 
229 #define SO_ENGINE_SOURCE(className) \
230  SO__ENGINE_VARS(className); \
231  SO__ENGINE_METHODS(className)
232 
233 #define SO_ENGINE_ABSTRACT_SOURCE(className) \
234  SO__ENGINE_ABSTRACT_VARS(className); \
235  SO__ENGINE_ABSTRACT_METHODS(className)
236 
241 
242 #define SO__ENGINE_INIT_CLASS(className, classPrintName, parentClass) { \
243  classTypeId = \
244  SoType::createType(parentClass::getClassTypeId(), \
245  classPrintName, \
246  &className::createInstance); \
247  parentInputData = parentClass::getInputDataPtr(); \
248  parentOutputData = parentClass::getOutputDataPtr(); \
249  }
250 
251 #define SO__ENGINE_INIT_ABSTRACT_CLASS(className,classPrintName,parent) { \
252  classTypeId = SoType::createType(parent::getClassTypeId(), \
253  classPrintName); \
254  parentInputData = parent::getInputDataPtr(); \
255  parentOutputData = parent::getOutputDataPtr(); \
256  }
257 
264 
265 #define SO_ENGINE_INIT_CLASS(className,parentClass,parentPrintClass) { \
266  classTypeId = \
267  SoType::createType(SoType::fromName(parentPrintClass), \
268  SO__QUOTE(className), \
269  &className::createInstance); \
270  parentInputData = parentClass::getInputDataPtr(); \
271  parentOutputData = parentClass::getOutputDataPtr(); \
272  }
273 
274 #define SO_ENGINE_INIT_ABSTRACT_CLASS(className,parent,parentPrintClass) { \
275  classTypeId = SoType::createType(SoType::fromName(parentPrintClass), \
276  SO__QUOTE(className)); \
277  parentInputData = parent::getInputDataPtr(); \
278  parentOutputData = parent::getOutputDataPtr(); \
279  }
280 
285 
286 #define SO_ENGINE_CONSTRUCTOR(className) { \
287  SO__ENGINE_CHECK_INIT(className); \
288  if (inputData == NULL) { \
289  inputData = new SoFieldData(parentInputData ? \
290  *parentInputData : NULL); \
291  outputData = new SoEngineOutputData(parentOutputData ? \
292  *parentOutputData : NULL); \
293  } \
294  else \
295  firstInstance = FALSE; \
296  isBuiltIn = FALSE; \
297  }
298 
304 
305 #define SO_ENGINE_IS_FIRST_INSTANCE() (firstInstance == TRUE)
306 
323 
324 #define SO_ENGINE_ADD_INPUT(inputName, defValue) { \
325  SO__ENGINE_CHECK_CONSTRUCT(__FILE__); \
326  if (firstInstance) \
327  inputData->addField(this, SO__QUOTE(inputName), \
328  &this->inputName); \
329  this->inputName.setValue defValue; \
330  this->inputName.setContainer(this); \
331  }
332 
349 
350 #define SO_ENGINE_ADD_OUTPUT(outputName, type) { \
351  SO__ENGINE_CHECK_CONSTRUCT(__FILE__); \
352  if (firstInstance) \
353  outputData->addOutput(this, SO__QUOTE(outputName), \
354  &this->outputName, \
355  type::getClassTypeId()); \
356  this->outputName.setContainer(this); \
357  }
358 
380 
381 #define SO_ENGINE_DEFINE_ENUM_VALUE(enumType,enumValue) { \
382  SO__ENGINE_CHECK_CONSTRUCT(__FILE__); \
383  if (firstInstance) \
384  inputData->addEnumValue(SO__QUOTE(enumType), \
385  SO__QUOTE(enumValue), enumValue); \
386  }
387 
393 
394 #define SO_ENGINE_OUTPUT(outputName,type,code) { \
395  if (outputName.isEnabled()) { \
396  for (int _eng_out_i = 0; \
397  _eng_out_i < outputName.getNumConnections(); \
398  _eng_out_i++) { \
399  type *_eng_out_temp = (type *) outputName[_eng_out_i]; \
400  if (!_eng_out_temp->isReadOnly()) { \
401  _eng_out_temp->code; \
402  } \
403  } \
404  } \
405  }
406 
407 
408 #endif /* _SO_SUB_ENGINE_ */