void OgreMeshDeserializer::readGeometry()
{
    std::vector<char> vertexBuffer;
    std::vector<OgreMeshDeserializer::VertexElement> elements;

    unsigned int vertexCount = 0;
    readInts(m_stream, &vertexCount, 1);
    // Find optional geometry streams
    if (!m_stream.eof()) {

        unsigned short streamID = readChunk(m_stream);
        while (!m_stream.eof() &&
               (streamID == M_GEOMETRY_VERTEX_DECLARATION ||
                streamID == M_GEOMETRY_VERTEX_BUFFER)) {
            switch (streamID) {
                case M_GEOMETRY_VERTEX_DECLARATION:
                    elements = readGeometryVertexDeclaration();
                    break;
                case M_GEOMETRY_VERTEX_BUFFER:
                    vertexBuffer = readGeometryVertexBuffer(vertexCount);
                    break;
                default:
                    skipChunk(m_stream);
            }
            // Get next stream
            if (!m_stream.eof()) {
                streamID = readChunk(m_stream);
            }
        }

        if (!elements.empty()) {
            for (auto& element : elements) {
                if (element.vSemantic == VertexElementSemantic::VES_POSITION) {
                    size_t vertexSize = vertexBuffer.size() / vertexCount;

                    for (size_t i = 0; i < vertexCount; ++i) {
                        char* vertexStart = vertexBuffer.data() + (i * vertexSize);
                        char* positionStart = vertexStart + element.offset;
                        if (element.vType == VertexElementType::VET_FLOAT3) {
                            float* positions = reinterpret_cast<float*>(positionStart);
                            m_vertices.push_back(*positions);
                            positions++;
                            m_vertices.push_back(*positions);
                            positions++;
                            m_vertices.push_back(*positions);
                        }
                    }

                }
            }
        }

        if (!m_stream.eof()) {
            // Backpedal back to start of non-submesh stream
            backpedalChunkHeader(m_stream);
        }

    }

}
Esempio n. 2
0
void readGeometry(IOReadBase* pRead, CSubMesh& subMesh)
{
	unsigned int vertexCount = 0;
	pRead->Read(&vertexCount,sizeof(unsigned int));

	unsigned short streamID;
	unsigned int uLength;
	pRead->Read(&streamID,sizeof(unsigned short));
	pRead->Read(&uLength,sizeof(unsigned int));

	std::vector<GeometryVertexElement> setElement; 
	while(!pRead->IsEof() && (streamID == M_GEOMETRY_VERTEX_DECLARATION ||streamID == M_GEOMETRY_VERTEX_BUFFER ))
	{
		switch (streamID)
		{
		case M_GEOMETRY_VERTEX_DECLARATION:
			readGeometryVertexDeclaration(pRead, setElement);
			break;
		case M_GEOMETRY_VERTEX_BUFFER:
			readGeometryVertexBuffer(pRead, subMesh, setElement, vertexCount);
			break;
		}
		// Get next stream
		if (!pRead->IsEof())
		{
			pRead->Read(&streamID,sizeof(unsigned short));
			pRead->Read(&uLength,sizeof(unsigned int));
		}
	}
	if (!pRead->IsEof())
	{
		// Backpedal back to start of non-submesh stream
		pRead->Move(-STREAM_OVERHEAD_SIZE);
	}
}
void
OgreMeshReader::readGeometry(VertexElementStore &vertexElements)
{
    OSG_OGRE_LOG(("OgreMeshReader::readGeometry\n"));

    UInt32          vertCount = readUInt32(_is);
    BufferVertexMap bufferMap;

    OSG_OGRE_LOG(("OgreMeshReader::readGeometry: vertCount '%d'\n", vertCount));

    bool stop = false;

    while(_is)
    {
        readChunkHeader(_is);

        switch(_header.chunkId)
        {
        case CHUNK_GEOMETRY_VERTEX_DECLARATION:
            readGeometryVertexDeclaration(vertexElements, bufferMap);
            break;

        case CHUNK_GEOMETRY_VERTEX_BUFFER:
            readGeometryVertexBuffer(vertCount, vertexElements, bufferMap);
            break;

        default:
            OSG_OGRE_LOG(("OgreMeshReader::readGeometry: Unknown chunkId '0x%x'\n",
                          _header.chunkId));
            stop = true;
            break;
        };

        if(stop == true)
        {
            skip(_is, -_chunkHeaderSize);
            break;
        }
    }
}