[occt.git] / src / VrmlData / VrmlData_IndexedFaceSet.hxx

// Created on: 2006-05-26
// Created by: Alexander GRIGORIEV
// Copyright (c) 2006-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

#ifndef VrmlData_IndexedFaceSet_HeaderFile
#define VrmlData_IndexedFaceSet_HeaderFile

#include <VrmlData_Faceted.hxx>
#include <VrmlData_Coordinate.hxx>
#include <VrmlData_Normal.hxx>
#include <VrmlData_Color.hxx>
#include <VrmlData_TextureCoordinate.hxx>
#include <gp_XYZ.hxx>
#include <Quantity_Color.hxx>

/**
 *  Implementation of IndexedFaceSet node
 */
class VrmlData_IndexedFaceSet : public VrmlData_Faceted 
{
 public:
  // ---------- PUBLIC METHODS ----------

  /**
   * Empty constructor
   */
  inline VrmlData_IndexedFaceSet ()
    : myArrPolygons     (0L),
      myArrNormalInd    (0L),
      myArrColorInd     (0L),
      myArrTextureInd   (0L),
      myNbPolygons      (0),
      myNbNormals       (0),
      myNbColors        (0),
      myNbTextures      (0),
      myNormalPerVertex (Standard_True),
      myColorPerVertex  (Standard_True)
  {}

  /**
   * Constructor
   */
  inline VrmlData_IndexedFaceSet (const VrmlData_Scene&  theScene,
                                  const char             * theName,
                                  const Standard_Boolean isCCW   =Standard_True,
                                  const Standard_Boolean isSolid =Standard_True,
                                  const Standard_Boolean isConvex=Standard_True,
                                  const Standard_Real    theCreaseAngle = 0.)
    : VrmlData_Faceted (theScene, theName, isCCW, isSolid, isConvex,
                        theCreaseAngle),
      myArrPolygons     (0L),
      myArrNormalInd    (0L),
      myArrColorInd     (0L),
      myArrTextureInd   (0L),
      myNbPolygons      (0),
      myNbNormals       (0),
      myNbColors        (0),
      myNbTextures      (0),
      myNormalPerVertex (Standard_True),
      myColorPerVertex  (Standard_True)
  {}

  /**
   * Query the Normals.
   */
  inline const Handle(VrmlData_Normal)&
                Normals         () const        { return myNormals; }

  /**
   * Query the Colors.
   */
  inline const Handle(VrmlData_Color)&
                Colors          () const        { return myColors; }

  /**
   * Query the Texture Coordinates.
   */
  inline const Handle(VrmlData_TextureCoordinate)&
                TextureCoords   () const      { return myTxCoords; }

  // ========================================================================
  // =========================== TRIANGULATION GRID =========================
  /**
   * Query the Coordinates.
   */
  inline const Handle(VrmlData_Coordinate)&
                Coordinates     () const        { return myCoords; }

  /**
   * Query the array of polygons
   */
  inline size_t Polygons        (const Standard_Integer**& arrPolygons) const
  { arrPolygons = myArrPolygons; return myNbPolygons; }

  /**
   * Query one polygon.
   * @param iFace
   *   rank of the polygon [0 .. N-1]
   * @param outIndice
   *   <tt>[out]</tt> array of vertex indice
   * @return
   *   number of vertice in the polygon - the dimension of outIndice array
   */
  inline Standard_Integer
                Polygon         (const Standard_Integer         iFace,
                                 const Standard_Integer *&      outIndice)
  { return * (outIndice = myArrPolygons[iFace])++; }

  /**
   * Set the nodes
   */
  inline void   SetCoordinates  (const Handle(VrmlData_Coordinate)& theCoord)
  { myCoords = theCoord; }

  /**
   * Set the polygons
   */
  inline void   SetPolygons     (const Standard_Size       nPolygons,
                                 const Standard_Integer ** thePolygons)
  { myNbPolygons = nPolygons; myArrPolygons = thePolygons; }

  // ========================================================================
  // ================================ NORMALS ===============================

  /**
   * Query the array of normal indice
   * @param arrNormalInd
   *   <tt>[out]</tt> array of normalIndex as it is described in VRML2.0 spec
   * @return
   *   Number of integers in the array arrNormalInd.
   */
  inline size_t ArrayNormalInd  (const Standard_Integer**& arrNormalInd) const
  { arrNormalInd = myArrNormalInd; return myNbNormals; }

  /**
   * Query normals indice for one face. This method should be called after
   * checking myArrNormalInd != NULL, otherwise exception will be thrown.
   * @param iFace
   *   rank of the face [0 .. N-1]
   * @param outIndice
   *   <tt>[out]</tt> array of normals indice
   * @return
   *   number of indice in the array - the dimension of outIndice array
   */
  inline Standard_Integer
                IndiceNormals   (const Standard_Integer         iFace,
                                 const Standard_Integer *&      outIndice)
  { return * (outIndice = myArrNormalInd[iFace])++; }

  /**
   * Query a normal for one node in the given element. The normal is
   * interpreted according to fields myNormals, myArrNormalInd,
   * myNormalPerVertex, as defined in VRML 2.0.
   * @param iFace
   *   rank of the polygon [0 .. N-1]
   * @param iVertex
   *   rank of the vertex in the polygon [0 .. M-1].  This parameter is ignored
   *   if (myNormalPerVertex == False)
   * @return
   *   Normal vector; if the normal is indefinite then returns (0., 0., 0.)
   */
  Standard_EXPORT gp_XYZ
                GetNormal       (const Standard_Integer         iFace,
                                 const Standard_Integer         iVertex);

  /**
   * Set the normals array of indice
   */
  inline void   SetNormalInd    (const Standard_Size       nIndice,
                                 const Standard_Integer ** theIndice)
  { myNbNormals = nIndice; myArrNormalInd = theIndice; }

  /**
   * Set the normals node
   */
  inline void   SetNormals      (const Handle(VrmlData_Normal)& theNormals)
  { myNormals = theNormals; }

  /**
   * Set the boolean value "normalPerVertex"
   */
  inline void   SetNormalPerVertex (const Standard_Boolean isNormalPerVertex)
  { myNormalPerVertex = isNormalPerVertex; }

  // ========================================================================
  // ================================ COLORS ================================

  /**
   * Query the array of color indice
   * @param arrColorInd
   *   <tt>[out]</tt> array of colorIndex as it is described in VRML2.0 spec
   * @return
   *   Number of integers in the array arrColorInd.
   */
  inline size_t ArrayColorInd   (const Standard_Integer**& arrColorInd) const
  { arrColorInd = myArrColorInd; return myNbColors; }

  /**
   * Query a color for one node in the given element. The color is
   * interpreted according to fields myColors, myArrColorInd,
   * myColorPerVertex, as defined in VRML 2.0.
   * @param iFace
   *   rank of the polygon [0 .. N-1]
   * @param iVertex
   *   rank of the vertex in the polygon [0 .. M-1]. This parameter is ignored
   *   if (myColorPerVertex == False)
   * @return
   *   Color value (RGB); if the color is indefinite then returns (0., 0., 0.)
   */
  Standard_EXPORT Quantity_Color
                GetColor        (const Standard_Integer         iFace,
                                 const Standard_Integer         iVertex);

  /**
   * Set the colors array of indice
   */
  inline void   SetColorInd     (const Standard_Size       nIndice,
                                 const Standard_Integer ** theIndice)
  { myNbColors = nIndice; myArrColorInd = theIndice; }

  /**
   * Set the Color node
   */
  inline void   SetColors       (const Handle(VrmlData_Color)& theColors)
  { myColors = theColors; }

  /**
   * Set the boolean value "colorPerVertex"
   */
  inline void   SetColorPerVertex (const Standard_Boolean isColorPerVertex)
  { myColorPerVertex = isColorPerVertex; }

  // ========================================================================
  // ========================== TEXTURE COIRDINATES =========================

  /**
   * Query the array of texture coordinate indice
   * @param arrTextureCoordInd
   *   <tt>[out]</tt> array of texCoordIndex as it is described in VRML2.0 spec
   * @return
   *   Number of integers in the array texCoordIndex.
   */
  inline size_t ArrayTextureCoordInd
                            (const Standard_Integer**& arrTextureCoordInd) const
  { arrTextureCoordInd = myArrTextureInd; return myNbTextures; }

  /**
   * Set the TexCoordiante array of indice
   */
  inline void   SetTextureCoordInd (const Standard_Size       nIndice,
                                    const Standard_Integer ** theIndice)
  { myNbTextures = nIndice; myArrTextureInd = theIndice; }

  /**
   * Set the Texture Coordinate node
   */
  inline void   SetTextureCoords(const Handle(VrmlData_TextureCoordinate)& tc)
  { myTxCoords = tc; }

  /**
   * Query the shape. This method checks the flag myIsModified; if True it
   * should rebuild the shape presentation.
   */
  Standard_EXPORT virtual const Handle(TopoDS_TShape)&  TShape () Standard_OVERRIDE;

  /**
   * Create a copy of this node.
   * If the parameter is null, a new copied node is created. Otherwise new node
   * is not created, but rather the given one is modified.
   */
  Standard_EXPORT virtual Handle(VrmlData_Node)
                Clone              (const Handle(VrmlData_Node)& theOther)const Standard_OVERRIDE;

  /**
   * Read the Node from input stream.
   */
  Standard_EXPORT virtual VrmlData_ErrorStatus
                Read               (VrmlData_InBuffer& theBuffer) Standard_OVERRIDE;

  /**
   * Write the Node to output stream.
   */
  Standard_EXPORT virtual VrmlData_ErrorStatus
                Write              (const char * thePrefix) const Standard_OVERRIDE;

  /**
   * Returns True if the node is default, so that it should not be written.
   */
  Standard_EXPORT virtual Standard_Boolean
                IsDefault          () const Standard_OVERRIDE;

 protected:
  // ---------- PROTECTED METHODS ----------

//   /**
//    * If the normals are not defined, here we compute them from the polygons.
//    * @param theArray
//    *   Array of float values having length:<ul>
//    *   <li>if myNormalPerVertex==TRUE : 3 * myCoords->Length()</li>
//    *   <li>if myNormalPerVertex==FALSE: 9 * number_of_triangles </li>
//    *   </ul>
//    */
//   Standard_EXPORT void
//                 computeNormals     (Standard_ShortReal * theArray);

 private:
  // ---------- PRIVATE FIELDS ----------
  Handle(VrmlData_Coordinate)           myCoords;
  Handle(VrmlData_Normal)               myNormals;
  Handle(VrmlData_Color)                myColors;
  Handle(VrmlData_TextureCoordinate)    myTxCoords;
  const Standard_Integer                ** myArrPolygons;
  const Standard_Integer                ** myArrNormalInd;
  const Standard_Integer                ** myArrColorInd;
  const Standard_Integer                ** myArrTextureInd;
  Standard_Size                         myNbPolygons;
  Standard_Size                         myNbNormals;
  Standard_Size                         myNbColors;
  Standard_Size                         myNbTextures;
  Standard_Boolean                      myNormalPerVertex;
  Standard_Boolean                      myColorPerVertex;

 public:
// Declaration of CASCADE RTTI
DEFINE_STANDARD_RTTIEXT(VrmlData_IndexedFaceSet,VrmlData_Faceted)
};

// Definition of HANDLE object using Standard_DefineHandle.hxx
DEFINE_STANDARD_HANDLE (VrmlData_IndexedFaceSet, VrmlData_Faceted)


#endif
Commit	Line	Data
b311480e	1	// Created on: 2006-05-26
b311480e	2	// Created by: Alexander GRIGORIEV
973c2be1	3	// Copyright (c) 2006-2014 OPEN CASCADE SAS
b311480e	4	//
973c2be1	5	// This file is part of Open CASCADE Technology software library.
b311480e	6	//
d5f74e42	7	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	8	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	9	// by the Free Software Foundation, with special exception defined in the file
	10	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	11	// distribution for complete text of the license and disclaimer of any warranty.
b311480e	12	//
973c2be1	13	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	14	// commercial license or contractual agreement.
7fd59977	15
	16	#ifndef VrmlData_IndexedFaceSet_HeaderFile
	17	#define VrmlData_IndexedFaceSet_HeaderFile
	18
	19	#include <VrmlData_Faceted.hxx>
	20	#include <VrmlData_Coordinate.hxx>
	21	#include <VrmlData_Normal.hxx>
	22	#include <VrmlData_Color.hxx>
	23	#include <VrmlData_TextureCoordinate.hxx>
	24	#include <gp_XYZ.hxx>
	25	#include <Quantity_Color.hxx>
	26
	27	/**
	28	* Implementation of IndexedFaceSet node
	29	*/
	30	class VrmlData_IndexedFaceSet : public VrmlData_Faceted
	31	{
	32	public:
	33	// ---------- PUBLIC METHODS ----------
	34
	35	/**
	36	* Empty constructor
	37	*/
	38	inline VrmlData_IndexedFaceSet ()
	39	: myArrPolygons (0L),
	40	myArrNormalInd (0L),
	41	myArrColorInd (0L),
	42	myArrTextureInd (0L),
	43	myNbPolygons (0),
	44	myNbNormals (0),
	45	myNbColors (0),
	46	myNbTextures (0),
	47	myNormalPerVertex (Standard_True),
	48	myColorPerVertex (Standard_True)
	49	{}
	50
	51	/**
	52	* Constructor
	53	*/
	54	inline VrmlData_IndexedFaceSet (const VrmlData_Scene& theScene,
	55	const char * theName,
	56	const Standard_Boolean isCCW =Standard_True,
	57	const Standard_Boolean isSolid =Standard_True,
	58	const Standard_Boolean isConvex=Standard_True,
	59	const Standard_Real theCreaseAngle = 0.)
	60	: VrmlData_Faceted (theScene, theName, isCCW, isSolid, isConvex,
	61	theCreaseAngle),
	62	myArrPolygons (0L),
	63	myArrNormalInd (0L),
	64	myArrColorInd (0L),
	65	myArrTextureInd (0L),
	66	myNbPolygons (0),
	67	myNbNormals (0),
	68	myNbColors (0),
	69	myNbTextures (0),
	70	myNormalPerVertex (Standard_True),
	71	myColorPerVertex (Standard_True)
	72	{}
	73
	74	/**
	75	* Query the Normals.
	76	*/
	77	inline const Handle(VrmlData_Normal)&
	78	Normals () const { return myNormals; }
79
80	/**
81	* Query the Colors.
82	*/
83	inline const Handle(VrmlData_Color)&
84	Colors () const { return myColors; }
85
86	/**
87	* Query the Texture Coordinates.
88	*/
89	inline const Handle(VrmlData_TextureCoordinate)&
90	TextureCoords () const { return myTxCoords; }
91
92	// ========================================================================
93	// =========================== TRIANGULATION GRID =========================
94	/**
95	* Query the Coordinates.
96	*/
97	inline const Handle(VrmlData_Coordinate)&
98	Coordinates () const { return myCoords; }
99
100	/**
101	* Query the array of polygons
102	*/
103	inline size_t Polygons (const Standard_Integer**& arrPolygons) const
104	{ arrPolygons = myArrPolygons; return myNbPolygons; }
105
106	/**
107	* Query one polygon.
108	* @param iFace
109	* rank of the polygon [0 .. N-1]
110	* @param outIndice
111	* <tt>[out]</tt> array of vertex indice
112	* @return
113	* number of vertice in the polygon - the dimension of outIndice array
114	*/
115	inline Standard_Integer
116	Polygon (const Standard_Integer iFace,
117	const Standard_Integer *& outIndice)
118	{ return * (outIndice = myArrPolygons[iFace])++; }
119
120	/**
121	* Set the nodes
122	*/
123	inline void SetCoordinates (const Handle(VrmlData_Coordinate)& theCoord)
124	{ myCoords = theCoord; }
125
126	/**
127	* Set the polygons
128	*/
7dc9e047	129	inline void SetPolygons (const Standard_Size nPolygons,
7fd59977	130	const Standard_Integer ** thePolygons)
	131	{ myNbPolygons = nPolygons; myArrPolygons = thePolygons; }
	132
	133	// ========================================================================
	134	// ================================ NORMALS ===============================
	135
	136	/**
	137	* Query the array of normal indice
	138	* @param arrNormalInd
	139	* <tt>[out]</tt> array of normalIndex as it is described in VRML2.0 spec
	140	* @return
	141	* Number of integers in the array arrNormalInd.
	142	*/
	143	inline size_t ArrayNormalInd (const Standard_Integer**& arrNormalInd) const
	144	{ arrNormalInd = myArrNormalInd; return myNbNormals; }
	145
	146	/**
	147	* Query normals indice for one face. This method should be called after
	148	* checking myArrNormalInd != NULL, otherwise exception will be thrown.
	149	* @param iFace
	150	* rank of the face [0 .. N-1]
	151	* @param outIndice
	152	* <tt>[out]</tt> array of normals indice
	153	* @return
	154	* number of indice in the array - the dimension of outIndice array
	155	*/
	156	inline Standard_Integer
	157	IndiceNormals (const Standard_Integer iFace,
	158	const Standard_Integer *& outIndice)
	159	{ return * (outIndice = myArrNormalInd[iFace])++; }
	160
	161	/**
	162	* Query a normal for one node in the given element. The normal is
	163	* interpreted according to fields myNormals, myArrNormalInd,
	164	* myNormalPerVertex, as defined in VRML 2.0.
	165	* @param iFace
	166	* rank of the polygon [0 .. N-1]
	167	* @param iVertex
	168	* rank of the vertex in the polygon [0 .. M-1]. This parameter is ignored
	169	* if (myNormalPerVertex == False)
	170	* @return
	171	* Normal vector; if the normal is indefinite then returns (0., 0., 0.)
	172	*/
	173	Standard_EXPORT gp_XYZ
	174	GetNormal (const Standard_Integer iFace,
	175	const Standard_Integer iVertex);
	176
	177	/**
	178	* Set the normals array of indice
	179	*/
7dc9e047	180	inline void SetNormalInd (const Standard_Size nIndice,
7fd59977	181	const Standard_Integer ** theIndice)
	182	{ myNbNormals = nIndice; myArrNormalInd = theIndice; }
	183
	184	/**
	185	* Set the normals node
	186	*/
	187	inline void SetNormals (const Handle(VrmlData_Normal)& theNormals)
	188	{ myNormals = theNormals; }
	189
	190	/**
	191	* Set the boolean value "normalPerVertex"
	192	*/
	193	inline void SetNormalPerVertex (const Standard_Boolean isNormalPerVertex)
	194	{ myNormalPerVertex = isNormalPerVertex; }
	195
	196	// ========================================================================
	197	// ================================ COLORS ================================
	198
	199	/**
	200	* Query the array of color indice
	201	* @param arrColorInd
	202	* <tt>[out]</tt> array of colorIndex as it is described in VRML2.0 spec
	203	* @return
	204	* Number of integers in the array arrColorInd.
	205	*/
	206	inline size_t ArrayColorInd (const Standard_Integer**& arrColorInd) const
	207	{ arrColorInd = myArrColorInd; return myNbColors; }
	208
	209	/**
	210	* Query a color for one node in the given element. The color is
	211	* interpreted according to fields myColors, myArrColorInd,
	212	* myColorPerVertex, as defined in VRML 2.0.
	213	* @param iFace
	214	* rank of the polygon [0 .. N-1]
	215	* @param iVertex
	216	* rank of the vertex in the polygon [0 .. M-1]. This parameter is ignored
	217	* if (myColorPerVertex == False)
	218	* @return
	219	* Color value (RGB); if the color is indefinite then returns (0., 0., 0.)
	220	*/
	221	Standard_EXPORT Quantity_Color
	222	GetColor (const Standard_Integer iFace,
	223	const Standard_Integer iVertex);
	224
	225	/**
	226	* Set the colors array of indice
	227	*/
7dc9e047	228	inline void SetColorInd (const Standard_Size nIndice,
7fd59977	229	const Standard_Integer ** theIndice)
	230	{ myNbColors = nIndice; myArrColorInd = theIndice; }
	231
	232	/**
	233	* Set the Color node
	234	*/
	235	inline void SetColors (const Handle(VrmlData_Color)& theColors)
	236	{ myColors = theColors; }
	237
	238	/**
	239	* Set the boolean value "colorPerVertex"
	240	*/
	241	inline void SetColorPerVertex (const Standard_Boolean isColorPerVertex)
	242	{ myColorPerVertex = isColorPerVertex; }
	243
	244	// ========================================================================
	245	// ========================== TEXTURE COIRDINATES =========================
	246
	247	/**
	248	* Query the array of texture coordinate indice
	249	* @param arrTextureCoordInd
	250	* <tt>[out]</tt> array of texCoordIndex as it is described in VRML2.0 spec
	251	* @return
	252	* Number of integers in the array texCoordIndex.
	253	*/
	254	inline size_t ArrayTextureCoordInd
	255	(const Standard_Integer**& arrTextureCoordInd) const
	256	{ arrTextureCoordInd = myArrTextureInd; return myNbTextures; }
	257
	258	/**
	259	* Set the TexCoordiante array of indice
	260	*/
7dc9e047	261	inline void SetTextureCoordInd (const Standard_Size nIndice,
7fd59977	262	const Standard_Integer ** theIndice)
	263	{ myNbTextures = nIndice; myArrTextureInd = theIndice; }
	264
	265	/**
	266	* Set the Texture Coordinate node
	267	*/
	268	inline void SetTextureCoords(const Handle(VrmlData_TextureCoordinate)& tc)
	269	{ myTxCoords = tc; }
	270
	271	/**
	272	* Query the shape. This method checks the flag myIsModified; if True it
	273	* should rebuild the shape presentation.
	274	*/
79104795	275	Standard_EXPORT virtual const Handle(TopoDS_TShape)& TShape () Standard_OVERRIDE;
7fd59977	276
	277	/**
	278	* Create a copy of this node.
	279	* If the parameter is null, a new copied node is created. Otherwise new node
	280	* is not created, but rather the given one is modified.
	281	*/
	282	Standard_EXPORT virtual Handle(VrmlData_Node)
79104795	283	Clone (const Handle(VrmlData_Node)& theOther)const Standard_OVERRIDE;
7fd59977	284
	285	/**
	286	* Read the Node from input stream.
	287	*/
	288	Standard_EXPORT virtual VrmlData_ErrorStatus
79104795	289	Read (VrmlData_InBuffer& theBuffer) Standard_OVERRIDE;
7fd59977	290
	291	/**
	292	* Write the Node to output stream.
	293	*/
	294	Standard_EXPORT virtual VrmlData_ErrorStatus
79104795	295	Write (const char * thePrefix) const Standard_OVERRIDE;
7fd59977	296
	297	/**
	298	* Returns True if the node is default, so that it should not be written.
	299	*/
	300	Standard_EXPORT virtual Standard_Boolean
79104795	301	IsDefault () const Standard_OVERRIDE;
7fd59977	302
	303	protected:
	304	// ---------- PROTECTED METHODS ----------
	305
	306	// /**
	307	// * If the normals are not defined, here we compute them from the polygons.
	308	// * @param theArray
	309	// * Array of float values having length:<ul>
	310	// * <li>if myNormalPerVertex==TRUE : 3 * myCoords->Length()</li>
	311	// * <li>if myNormalPerVertex==FALSE: 9 * number_of_triangles </li>
	312	// * </ul>
	313	// */
	314	// Standard_EXPORT void
	315	// computeNormals (Standard_ShortReal * theArray);
	316
	317	private:
	318	// ---------- PRIVATE FIELDS ----------
	319	Handle(VrmlData_Coordinate) myCoords;
	320	Handle(VrmlData_Normal) myNormals;
	321	Handle(VrmlData_Color) myColors;
	322	Handle(VrmlData_TextureCoordinate) myTxCoords;
	323	const Standard_Integer ** myArrPolygons;
	324	const Standard_Integer ** myArrNormalInd;
	325	const Standard_Integer ** myArrColorInd;
	326	const Standard_Integer ** myArrTextureInd;
	327	Standard_Size myNbPolygons;
	328	Standard_Size myNbNormals;
	329	Standard_Size myNbColors;
	330	Standard_Size myNbTextures;
	331	Standard_Boolean myNormalPerVertex;
	332	Standard_Boolean myColorPerVertex;
	333
	334	public:
	335	// Declaration of CASCADE RTTI
92efcf78	336	DEFINE_STANDARD_RTTIEXT(VrmlData_IndexedFaceSet,VrmlData_Faceted)
7fd59977	337	};
	338
	339	// Definition of HANDLE object using Standard_DefineHandle.hxx
	340	DEFINE_STANDARD_HANDLE (VrmlData_IndexedFaceSet, VrmlData_Faceted)
	341
	342
	343	#endif