#include <StdMeshLoaderBinaryChunks.h>

Inheritance diagram for Ogre::Mesh::ChunkSubmesh:

Collaboration diagram for Ogre::Mesh::ChunkSubmesh:

Public Types
enum	SubmeshOperation { SO_PointList = 1 , SO_LineList = 2 , SO_LineStrip = 3 , SO_TriList = 4 , SO_TriStrip = 5 , SO_TriFan = 6 , SO_MIN = SO_PointList , SO_MAX = SO_TriFan }

Public Member Functions
	ChunkSubmesh ()=default

Type	GetType () const

size_t	GetSize () const

Static Public Member Functions
static std::unique_ptr< Chunk >	Read (DataStream *stream)

static Type	Peek (const DataStream *stream)

Public Attributes
std::string	material

bool	hasSharedVertices

std::vector< size_t >	faceVertices

std::unique_ptr< ChunkGeometry >	geometry

enum Ogre::Mesh::ChunkSubmesh::SubmeshOperation	SO_TriList

std::vector< BoneAssignment >	boneAssignments

Static Public Attributes
static const size_t	ChunkHeaderLength

Protected Types
typedef ChunkID	Type

Protected Member Functions
void	ReadImpl (DataStream *stream) override

Protected Attributes
Type	type

size_t	size

Detailed Description

Definition at line 405 of file StdMeshLoaderBinaryChunks.h.

Member Typedef Documentation

◆ Type

typedef ChunkID Ogre::ChunkBase< ChunkID >::Type

protectedinherited

Definition at line 286 of file StdMeshLoaderBinaryChunks.h.

Member Enumeration Documentation

◆ SubmeshOperation

enum Ogre::Mesh::ChunkSubmesh::SubmeshOperation

Enumerator
SO_PointList
SO_LineList
SO_LineStrip
SO_TriList
SO_TriStrip
SO_TriFan
SO_MIN
SO_MAX

Definition at line 413 of file StdMeshLoaderBinaryChunks.h.

             {
                 SO_PointList = 1,
                 SO_LineList = 2,
                 SO_LineStrip = 3,
                 SO_TriList = 4,
                 SO_TriStrip = 5,
                 SO_TriFan = 6,
                 SO_MIN = SO_PointList,
                 SO_MAX = SO_TriFan
             } operation{SO_TriList};

Constructor & Destructor Documentation

◆ ChunkSubmesh()

Ogre::Mesh::ChunkSubmesh::ChunkSubmesh ( )

default

Member Function Documentation

◆ GetSize()

size_t Ogre::ChunkBase< ChunkID >::GetSize ( ) const

inlineinherited

Definition at line 292 of file StdMeshLoaderBinaryChunks.h.

292 { return size; }

Ogre::ChunkBase< ChunkID >::size

size_t size

Definition: StdMeshLoaderBinaryChunks.h:288

◆ GetType()

Type Ogre::ChunkBase< ChunkID >::GetType ( ) const

inlineinherited

Definition at line 291 of file StdMeshLoaderBinaryChunks.h.

291 { return type; }

Ogre::ChunkBase< ChunkID >::type

Type type

Definition: StdMeshLoaderBinaryChunks.h:287

◆ Peek()

static Type Ogre::ChunkBase< ChunkID >::Peek ( const DataStream * stream )

inlinestaticinherited

Definition at line 295 of file StdMeshLoaderBinaryChunks.h.

         {
             return static_cast<Type>(stream->Peek<uint16_t>());
         }

◆ Read()

std::unique_ptr< Chunk > Ogre::Mesh::Chunk::Read ( DataStream * stream )

staticinherited

Definition at line 42 of file StdMeshLoaderBinaryChunks.cpp.

         {
             assert(stream->GetRemainingBytes() >= ChunkHeaderLength);
  
             // Read metadata
             ChunkID id = CID_Invalid;
             id = static_cast<ChunkID>(stream->Read<uint16_t>());
             size_t size = 0;
             // Special case: CID_Header doesn't have any size info.
             if (id != CID_Header)
             {
                 // All others are proper chunks.
                 size = stream->Read<uint32_t>();
                 size -= ChunkHeaderLength;
             }
  
             // Create chunk
             std::unique_ptr<Chunk> chunk;
             switch (id)
             {
             case CID_Header: chunk = std::make_unique<Ogre::Mesh::ChunkFileHeader>(); break;
             case CID_Mesh: chunk = std::make_unique<Ogre::Mesh::ChunkMesh>(); break;
             case CID_Mesh_Bone_Assignment:
             case CID_Submesh_Bone_Assignment:
                 chunk = std::make_unique<Ogre::Mesh::ChunkMeshBoneAssignments>(); break;
             case CID_Mesh_Skeleton_Link: chunk = std::make_unique<Ogre::Mesh::ChunkMeshSkeletonLink>(); break;
             case CID_Mesh_Bounds: chunk = std::make_unique<Ogre::Mesh::ChunkMeshBounds>(); break;
             case CID_Submesh: chunk = std::make_unique<Ogre::Mesh::ChunkSubmesh>(); break;
             case CID_Submesh_Op: chunk = std::make_unique<Ogre::Mesh::ChunkSubmeshOp>(); break;
             case CID_Geometry: chunk = std::make_unique<Ogre::Mesh::ChunkGeometry>(); break;
             case CID_Geometry_Vertex_Buffer: chunk = std::make_unique<Ogre::Mesh::ChunkGeometryVertexBuffer>(); break;
             case CID_Geometry_Vertex_Data: chunk = std::make_unique<Ogre::Mesh::ChunkGeometryVertexData>(); break;
             case CID_Geometry_Vertex_Decl: chunk = std::make_unique<Ogre::Mesh::ChunkGeometryVertexDecl>(); break;
             case CID_Geometry_Vertex_Decl_Element: chunk = std::make_unique<Ogre::Mesh::ChunkGeometryVertexDeclElement>(); break;
             default:
                 LogF("StdMeshLoader: I don't know what to do with a chunk of type 0x%xu", id);
                 // Fall through
             case CID_Edge_List: case CID_Submesh_Name_Table:
                 // We don't care about these
                 chunk = std::make_unique<Ogre::Mesh::ChunkUnknown>(); break;
             };
             chunk->type = id;
             chunk->size = size;
             chunk->ReadImpl(stream);
             return chunk;
         }

References Ogre::ChunkBase< ChunkID >::ChunkHeaderLength, Ogre::Mesh::CID_Edge_List, Ogre::Mesh::CID_Geometry, Ogre::Mesh::CID_Geometry_Vertex_Buffer, Ogre::Mesh::CID_Geometry_Vertex_Data, Ogre::Mesh::CID_Geometry_Vertex_Decl, Ogre::Mesh::CID_Geometry_Vertex_Decl_Element, Ogre::Mesh::CID_Header, Ogre::Mesh::CID_Invalid, Ogre::Mesh::CID_Mesh, Ogre::Mesh::CID_Mesh_Bone_Assignment, Ogre::Mesh::CID_Mesh_Bounds, Ogre::Mesh::CID_Mesh_Skeleton_Link, Ogre::Mesh::CID_Submesh, Ogre::Mesh::CID_Submesh_Bone_Assignment, Ogre::Mesh::CID_Submesh_Name_Table, Ogre::Mesh::CID_Submesh_Op, Ogre::DataStream::GetRemainingBytes(), LogF(), Ogre::DataStream::Read(), and Ogre::ChunkBase< ChunkID >::size.

Referenced by StdMeshLoader::LoadMeshBinary(), Ogre::Mesh::ChunkMesh::ReadImpl(), ReadImpl(), Ogre::Mesh::ChunkGeometry::ReadImpl(), Ogre::Mesh::ChunkGeometryVertexDecl::ReadImpl(), and Ogre::Mesh::ChunkGeometryVertexBuffer::ReadImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ReadImpl()

void Ogre::Mesh::ChunkSubmesh::ReadImpl ( DataStream * stream )

overrideprotectedvirtual

Implements Ogre::ChunkBase< ChunkID >.

Definition at line 151 of file StdMeshLoaderBinaryChunks.cpp.

         {
             operation = SO_TriList; // default if no CID_Submesh_Op chunk exists
             material = stream->Read<std::string>();
             hasSharedVertices = stream->Read<bool>();
             size_t index_count = stream->Read<uint32_t>();
             bool indexes_are_32bit = stream->Read<bool>();
             faceVertices.reserve(index_count);
             while (index_count--)
             {
                 size_t index;
                 if (indexes_are_32bit)
                     index = stream->Read<uint32_t>();
                 else
                     index = stream->Read<uint16_t>();
                 faceVertices.push_back(index);
             }
             for (ChunkID id = Chunk::Peek(stream);
                  id == CID_Geometry || id == CID_Submesh_Op || id == CID_Submesh_Bone_Assignment;
                  id = Chunk::Peek(stream)
                 )
             {
                 std::unique_ptr<Chunk> chunk = Chunk::Read(stream);
  
                 switch (chunk->GetType())
                 {
                 case CID_Geometry:
                     if (hasSharedVertices)
                         // Can't have own vertices and at the same time use those of the parent
                         throw SharedVertexGeometryForbidden();
                     if (geometry)
                         throw MultipleSingletonChunks("There's only one CID_Geometry chunk allowed within a CID_Submesh chunk");
                     geometry = static_unique_cast<ChunkGeometry>(move(chunk));
                     break;
                 case CID_Submesh_Op:
                     operation = static_cast<ChunkSubmeshOp*>(chunk.get())->operation;
                     break;
                 case CID_Submesh_Bone_Assignment:
                 {
                     // Collect bone assignments
                     ChunkMeshBoneAssignments *assignments = static_cast<ChunkMeshBoneAssignments*>(chunk.get());
                     boneAssignments.insert(boneAssignments.end(), assignments->assignments.begin(), assignments->assignments.end());
                 }
                 break;
                 default:
                     LogF("StdMeshLoader: I don't know what to do with a chunk of type 0x%xu inside a CID_Submesh chunk", chunk->GetType());
                     break;
                 }
                 if (stream->AtEof()) break;
             }
         }