HDK: HOM/HOM_Prim.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Side Effects Software Inc
00008  *      123 Front Street West, Suite 1401
00009  *      Toronto, Ontario
00010  *      Canada   M5J 2M2
00011  *      416-504-9876
00012  *
00013  * COMMENTS:
00014  */
00015 
00016 #ifndef __HOM_Prim_h__
00017 #define __HOM_Prim_h__
00018 
00019 #include "HOM_API.h"
00020 #include "HOM_Defines.h"
00021 #include "HOM_Errors.h"
00022 #include "HOM_Vertex.h"
00023 #include "HOM_IterableList.h"
00024 #include <vector>
00025 #include <boost/tuple/tuple.hpp>
00026 class HOM_EnumValue;
00027 class HOM_Geometry;
00028 
00029 SWIGOUT(%rename(Prim) HOM_Prim;)
00030 
00031 class HOM_API HOM_Prim
00032 {
00033 public:
00034     HOM_Prim()
00035     { HOM_CONSTRUCT_OBJECT(this) }
00036     HOM_Prim(const HOM_Prim &)
00037     { HOM_CONSTRUCT_OBJECT(this) }
00038     virtual ~HOM_Prim()
00039     { HOM_DESTRUCT_OBJECT(this) }
00040 
00041     virtual bool operator==(HOM_Prim &prim)
00042         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00043     virtual bool operator!=(HOM_Prim &prim)
00044         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00045 
00046     virtual int __hash__() throw(HOM_Error) = 0;
00047     virtual std::string __repr__() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00048 
00049     SWIGOUT(%newobject geometry;)
00050     virtual HOM_Geometry *geometry() throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00051 
00052     virtual int number() throw(HOM_Error) = 0;
00053 
00054     SWIGPYTHONOUT(%feature("autodoc",
00055         "type(self) -> hou.primType enum value") type;)
00056     virtual HOM_EnumValue &type() throw(HOM_Error) = 0;
00057 
00058     SWIGPYTHONOUT(%feature("autodoc",
00059         "attribType(self) -> hou.attribType enum value") attribType;)
00060     virtual HOM_EnumValue &attribType() throw(HOM_Error) = 0;
00061 
00062 
00063     SWIGPYTHONOUT(%feature("autodoc",
00064         "vertices(self) -> tuple of Vertex") vertices;)
00065     SWIGOUT(%newobject vertices;)
00066     virtual HOM_IterableList<HOM_Vertex> *vertices()
00067         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00068 
00069     virtual int numVertices()
00070         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00071     SWIGOUT(%newobject vertex;)
00072     virtual HOM_Vertex *vertex(int index)
00073         throw(std::out_of_range, HOM_ObjectWasDeleted, HOM_Error) = 0;
00074 
00075 
00076     virtual float floatAttribValue(const char *name)
00077         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00078 
00079     virtual float floatAttribValue(HOM_Attrib &attrib)
00080         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00081 
00082     SWIGPYTHONOUT(%feature("autodoc",
00083         "floatListAttribValue(self, name) -> tuple of floats")
00084         floatListAttribValue(const char *);)
00085     virtual std::vector<float> floatListAttribValue(const char *name)
00086         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00087 
00088     SWIGPYTHONOUT(%feature("autodoc",
00089         "floatListAttribValue(self, attrib) -> tuple of floats")
00090         floatListAttribValue(HOM_Attrib &);)
00091     virtual std::vector<float> floatListAttribValue(HOM_Attrib &attrib)
00092         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00093 
00094     virtual int intAttribValue(const char *name)
00095         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00096 
00097     virtual int intAttribValue(HOM_Attrib &attrib)
00098         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00099 
00100     SWIGPYTHONOUT(%feature("autodoc",
00101         "intListAttribValue(self, name) -> tuple of ints")
00102         intListAttribValue(const char *);)
00103     virtual std::vector<int> intListAttribValue(const char *name)
00104         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00105 
00106     SWIGPYTHONOUT(%feature("autodoc",
00107         "intListAttribValue(self, attrib) -> tuple of ints")
00108         intListAttribValue(HOM_Attrib &);)
00109     virtual std::vector<int> intListAttribValue(HOM_Attrib &attrib)
00110         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00111 
00112     virtual std::string stringAttribValue(const char *name)
00113         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00114 
00115     virtual std::string stringAttribValue(HOM_Attrib &attrib)
00116         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error) = 0;
00117 
00118 
00119     virtual void setAttribValue(
00120             HOM_Attrib &attrib, int attrib_value)
00121         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00122             HOM_ObjectWasDeleted, HOM_Error) = 0;
00123     virtual void setAttribValue(
00124             HOM_Attrib &attrib, float attrib_value)
00125         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00126             HOM_ObjectWasDeleted, HOM_Error) = 0;
00127     virtual void setAttribValue(
00128             HOM_Attrib &attrib, const char *attrib_value)
00129         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00130             HOM_ObjectWasDeleted, HOM_Error) = 0;
00131     virtual void setAttribValue(
00132             HOM_Attrib &attrib, const std::vector<int> &attrib_value)
00133         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00134             HOM_ObjectWasDeleted, HOM_Error) = 0;
00135     virtual void setAttribValue(
00136             HOM_Attrib &attrib, const std::vector<float> &attrib_value)
00137         throw(HOM_OperationFailed, HOM_GeometryPermissionError,
00138             HOM_ObjectWasDeleted, HOM_Error) = 0;
00139 
00140     virtual void setAttribValue(
00141             const char *attrib_name, int attrib_value)
00142         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00143             HOM_ObjectWasDeleted, HOM_Error) = 0;
00144     virtual void setAttribValue(
00145             const char *attrib_name, float attrib_value)
00146         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00147             HOM_ObjectWasDeleted, HOM_Error) = 0;
00148     virtual void setAttribValue(
00149             const char *attrib_name, const char *attrib_value)
00150         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00151             HOM_ObjectWasDeleted, HOM_Error) = 0;
00152     // Note that, because of strangess the with way swig works when deciding
00153     // which overloaded method to call, it's very important that we list the
00154     // vector of ints before the vector of floats.  Otherwise, swig will call
00155     // the float version when you pass in a vector of ints.
00156     virtual void setAttribValue(
00157             const char *attrib_name, const std::vector<int> &attrib_value)
00158         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00159             HOM_ObjectWasDeleted, HOM_Error) = 0;
00160     virtual void setAttribValue(
00161             const char *attrib_name, const std::vector<float> &attrib_value)
00162         throw(HOM_TypeError, HOM_OperationFailed, HOM_GeometryPermissionError,
00163             HOM_ObjectWasDeleted, HOM_Error) = 0;
00164 
00165 #ifdef SWIG
00166 %extend
00167 {
00168     SWIGPYTHONOUT(%feature("autodoc",
00169         "attribValue(self, name) -> int, float, string or tuple")
00170         attribValue(const char *);)
00171     InterpreterObject attribValue(const char *name)
00172         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00173     { return HOMattribValue(*self, name); }
00174 
00175     SWIGPYTHONOUT(%feature("autodoc",
00176         "attribValue(self, attrib) -> int, float, string or tuple")
00177         attribValue(HOM_Attrib &);)
00178     InterpreterObject attribValue(HOM_Attrib &attrib)
00179         throw(HOM_OperationFailed, HOM_ObjectWasDeleted, HOM_Error)
00180     { return HOMattribValue(*self, attrib); }
00181 }
00182 #endif
00183 
00184     virtual boost::tuple<float, float, float> nearestToPosition(
00185             const std::vector<float> &position)
00186         throw(HOM_InvalidSize, HOM_ObjectWasDeleted, HOM_Error) = 0;
00187 };
00188 
00189 #endif