EIC code displayed by LXR master/​include/​opencascade/​Graphic3d_Buffer.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 10:03:47

 // Copyright (c) 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 _Graphic3d_Buffer_HeaderFile
 #define _Graphic3d_Buffer_HeaderFile
 
 #include <Graphic3d_BufferRange.hxx>
 #include <Graphic3d_Vec.hxx>
 #include <NCollection_Array1.hxx>
 #include <NCollection_Buffer.hxx>
 #include <Standard_NotImplemented.hxx>
 
 //! Type of attribute in Vertex Buffer
 enum Graphic3d_TypeOfAttribute
 {
   Graphic3d_TOA_POS   =  0,   //!< vertex position
   Graphic3d_TOA_NORM,         //!< normal
   Graphic3d_TOA_UV,           //!< texture coordinates
   Graphic3d_TOA_COLOR,        //!< per-vertex color
   Graphic3d_TOA_CUSTOM,       //!< custom attributes
 };
 
 //! Type of the element in Vertex or Index Buffer
 enum Graphic3d_TypeOfData
 {
   Graphic3d_TOD_USHORT,  //!< unsigned 16-bit integer
   Graphic3d_TOD_UINT,    //!< unsigned 32-bit integer
   Graphic3d_TOD_VEC2,    //!< 2-components float vector
   Graphic3d_TOD_VEC3,    //!< 3-components float vector
   Graphic3d_TOD_VEC4,    //!< 4-components float vector
   Graphic3d_TOD_VEC4UB,  //!< 4-components unsigned byte vector
   Graphic3d_TOD_FLOAT,   //!< float value
 };
 
 //! Vertex attribute definition.
 struct Graphic3d_Attribute
 {
   Graphic3d_TypeOfAttribute Id;       //!< attribute identifier in vertex shader, 0 is reserved for vertex position
   Graphic3d_TypeOfData      DataType; //!< vec2,vec3,vec4,vec4ub
 
   Standard_Integer Stride() const { return Stride (DataType); }
 
   //! @return size of attribute of specified data type
   static Standard_Integer Stride (const Graphic3d_TypeOfData theType)
   {
     switch (theType)
     {
       case Graphic3d_TOD_USHORT: return sizeof(unsigned short);
       case Graphic3d_TOD_UINT:   return sizeof(unsigned int);
       case Graphic3d_TOD_VEC2:   return sizeof(Graphic3d_Vec2);
       case Graphic3d_TOD_VEC3:   return sizeof(Graphic3d_Vec3);
       case Graphic3d_TOD_VEC4:   return sizeof(Graphic3d_Vec4);
       case Graphic3d_TOD_VEC4UB: return sizeof(Graphic3d_Vec4ub);
       case Graphic3d_TOD_FLOAT:  return sizeof(float);
     }
     return 0;
   }
 
 };
 
 typedef NCollection_Array1<Graphic3d_Attribute> Graphic3d_Array1OfAttribute;
 
 //! Buffer of vertex attributes.
 class Graphic3d_Buffer : public NCollection_Buffer
 {
   DEFINE_STANDARD_RTTIEXT(Graphic3d_Buffer, NCollection_Buffer)
 public:
 
   //! Return default vertex data allocator.
   Standard_EXPORT static const Handle(NCollection_BaseAllocator)& DefaultAllocator();
 
 public:
 
   //! Empty constructor.
   Graphic3d_Buffer (const Handle(NCollection_BaseAllocator)& theAlloc)
   : NCollection_Buffer (theAlloc),
     Stride       (0),
     NbElements   (0),
     NbAttributes (0)
   {
     //
   }
 
   //! Return number of initially allocated elements which can fit into this buffer,
   //! while NbElements can be overwritten to smaller value.
   Standard_Integer NbMaxElements() const { return Stride != 0 ? Standard_Integer(mySize / size_t(Stride)) : 0; }
 
   //! @return array of attributes definitions
   const Graphic3d_Attribute* AttributesArray() const
   {
     return (Graphic3d_Attribute* )(myData + mySize);
   }
 
   //! @return attribute definition
   const Graphic3d_Attribute& Attribute (const Standard_Integer theAttribIndex) const
   {
     return AttributesArray()[theAttribIndex];
   }
 
   //! @return attribute definition
   Graphic3d_Attribute& ChangeAttribute (const Standard_Integer theAttribIndex)
   {
     return *((Graphic3d_Attribute* )(myData + mySize) + theAttribIndex);
   }
 
   //! Find attribute index.
   //! @param theAttrib attribute to find
   //! @return attribute index or -1 if not found
   Standard_Integer FindAttribute (Graphic3d_TypeOfAttribute theAttrib) const
   {
     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
     {
       const Graphic3d_Attribute& anAttrib = Attribute (anAttribIter);
       if (anAttrib.Id == theAttrib)
       {
         return anAttribIter;
       }
     }
     return -1;
   }
 
 //! @name data accessors for interleaved array
 public:
 
   //! @return data offset to specified attribute
   Standard_Integer AttributeOffset (const Standard_Integer theAttribIndex) const
   {
     Standard_Integer anOffset = 0;
     for (Standard_Integer anAttribIter = 0; anAttribIter < theAttribIndex; ++anAttribIter)
     {
       anOffset += Graphic3d_Attribute::Stride (Attribute (anAttribIter).DataType);
     }
     return anOffset;
   }
 
   //! @return data for specified attribute
   const Standard_Byte* Data (const Standard_Integer theAttribIndex) const
   {
     return myData + AttributeOffset (theAttribIndex);
   }
 
   //! @return data for specified attribute
   Standard_Byte* ChangeData (const Standard_Integer theAttribIndex)
   {
     return myData + AttributeOffset (theAttribIndex);
   }
 
   //! Access specified element.
   inline const Standard_Byte* value (const Standard_Integer theElem) const
   {
     return myData + Stride * size_t(theElem);
   }
 
   //! Access specified element.
   inline Standard_Byte* changeValue (const Standard_Integer theElem)
   {
     return myData + Stride * size_t(theElem);
   }
 
   //! Access element with specified position and type.
   template <typename Type_t>
   inline const Type_t& Value (const Standard_Integer theElem) const
   {
     return *reinterpret_cast<const Type_t*>(value (theElem));
   }
 
   //! Access element with specified position and type.
   template <typename Type_t>
   inline Type_t& ChangeValue (const Standard_Integer theElem)
   {
     return *reinterpret_cast<Type_t* >(changeValue (theElem));
   }
 
 //! @name general accessors
 public:
 
   using NCollection_Buffer::Data;
   using NCollection_Buffer::ChangeData;
 
   //! Return the attribute data with stride size specific to this attribute.
   //! @param theAttrib       attribute to find
   //! @param theAttribIndex  index of found attribute
   //! @param theAttribStride stride in bytes between values of this attribute within returned data pointer
   Standard_Byte* ChangeAttributeData (Graphic3d_TypeOfAttribute theAttrib,
                                       Standard_Integer& theAttribIndex,
                                       Standard_Size& theAttribStride)
   {
     return (Standard_Byte* )AttributeData (theAttrib, theAttribIndex, theAttribStride);
   }
 
   //! Return the attribute data with stride size specific to this attribute.
   //! @param theAttrib       attribute to find
   //! @param theAttribIndex  index of found attribute
   //! @param theAttribStride stride in bytes between values of this attribute within returned data pointer
   const Standard_Byte* AttributeData (Graphic3d_TypeOfAttribute theAttrib,
                                       Standard_Integer& theAttribIndex,
                                       Standard_Size& theAttribStride) const
   {
     const Standard_Byte* aDataPtr = Data();
     if (IsInterleaved())
     {
       for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
       {
         const Graphic3d_Attribute& anAttrib = Attribute (anAttribIter);
         const Standard_Size anAttribStride = Graphic3d_Attribute::Stride (anAttrib.DataType);
         if (anAttrib.Id == theAttrib)
         {
           theAttribIndex  = anAttribIter;
           theAttribStride = Stride;
           return aDataPtr;
         }
 
         aDataPtr += anAttribStride;
       }
     }
     else
     {
       const Standard_Integer aNbMaxVerts = NbMaxElements();
       for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
       {
         const Graphic3d_Attribute& anAttrib = Attribute (anAttribIter);
         const Standard_Size anAttribStride = Graphic3d_Attribute::Stride (anAttrib.DataType);
         if (anAttrib.Id == theAttrib)
         {
           theAttribIndex  = anAttribIter;
           theAttribStride = anAttribStride;
           return aDataPtr;
         }
 
         aDataPtr += anAttribStride * aNbMaxVerts;
       }
     }
     return NULL;
   }
 
 public:
 
   //! Release buffer.
   void release()
   {
     Free();
     Stride       = 0;
     NbElements   = 0;
     NbAttributes = 0;
   }
 
   //! Allocates new empty array
   bool Init (const Standard_Integer     theNbElems,
              const Graphic3d_Attribute* theAttribs,
              const Standard_Integer     theNbAttribs)
   {
     release();
     Standard_Integer aStride = 0;
     for (Standard_Integer anAttribIter = 0; anAttribIter < theNbAttribs; ++anAttribIter)
     {
       const Graphic3d_Attribute& anAttrib = theAttribs[anAttribIter];
       aStride += anAttrib.Stride();
     }
     if (aStride == 0)
     {
       return false;
     }
 
     Stride       = aStride;
     NbElements   = theNbElems;
     NbAttributes = theNbAttribs;
     if (NbElements != 0)
     {
       const size_t aDataSize = size_t(Stride) * size_t(NbElements);
       if (!Allocate (aDataSize + sizeof(Graphic3d_Attribute) * NbAttributes))
       {
         release();
         return false;
       }
 
       mySize = aDataSize;
       for (Standard_Integer anAttribIter = 0; anAttribIter < theNbAttribs; ++anAttribIter)
       {
         ChangeAttribute (anAttribIter) = theAttribs[anAttribIter];
       }
     }
     return true;
   }
 
   //! Allocates new empty array
   bool Init (const Standard_Integer             theNbElems,
              const Graphic3d_Array1OfAttribute& theAttribs)
   {
     return Init (theNbElems, &theAttribs.First(), theAttribs.Size());
   }
 
 public:
 
   //! Flag indicating that attributes in the buffer are interleaved; TRUE by default.
   //! Requires sub-classing for creating a non-interleaved buffer (advanced usage).
   virtual Standard_Boolean IsInterleaved() const { return Standard_True; }
 
   //! Return TRUE if data can be invalidated; FALSE by default.
   //! Requires sub-classing for creating a mutable buffer (advanced usage).
   virtual Standard_Boolean IsMutable() const { return Standard_False; }
 
   //! Return invalidated range; EMPTY by default.
   //! Requires sub-classing for creating a mutable buffer (advanced usage).
   virtual Graphic3d_BufferRange InvalidatedRange() const { return Graphic3d_BufferRange(); }
 
   //! Reset invalidated range.
   //! Requires sub-classing for creating a mutable buffer (advanced usage).
   virtual void Validate() {}
 
   //! Invalidate entire buffer.
   virtual void Invalidate() {}
 
   //! Dumps the content of me into the stream
   Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
 
 public:
 
   Standard_Integer Stride;       //!< the distance to the attributes of the next vertex within interleaved array
   Standard_Integer NbElements;   //!< number of the elements (@sa NbMaxElements() specifying the number of initially allocated number of elements)
   Standard_Integer NbAttributes; //!< number of vertex attributes
 
 };
 
 DEFINE_STANDARD_HANDLE(Graphic3d_Buffer, NCollection_Buffer)
 
 #endif // _Graphic3d_Buffer_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team