Exemplo n.º 1
0
void
OgreMeshReader::readMeshLODUsage(void)
{
    OSG_OGRE_LOG(("OgreMeshReader::readMeshLODUsage\n"));

    //Real32 lodValue
    readReal32(_is);

    bool stop = false;

    while(_is)
    {
        readChunkHeader(_is);

        switch(_header.chunkId)
        {
        case CHUNK_MESH_LOD_MANUAL:
            readMeshLODManual();
            break;

        case CHUNK_MESH_LOD_GENERATED:
            readMeshLODGenerated();
            break;

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

        if(stop == true)
        {
            skip(_is, -_chunkHeaderSize);
            break;
        }
    }
}
void
OgreMeshReader::readMeshBounds(void)
{
    OSG_OGRE_LOG(("OgreMeshReader::readMeshBounds\n"));

    Pnt3f  bbMin;
    bbMin[0] = readReal32(_is);
    bbMin[1] = readReal32(_is);
    bbMin[2] = readReal32(_is);

    Pnt3f  bbMax;
    bbMax[0] = readReal32(_is);
    bbMax[1] = readReal32(_is);
    bbMax[2] = readReal32(_is);

    //Real32 radius
    readReal32(_is);

    OSG_OGRE_LOG(("OgreMeshReader::readMeshBounds: bbMin '(%f %f %f)' bbMax '(%f %f %f)'\n",
                  bbMin[0], bbMin[1], bbMin[2], bbMax[0], bbMax[1], bbMax[2]));

    _rootN->editVolume().setBounds(bbMin, bbMax);
    _rootN->editVolume().setStatic(true);
}
void
OgreMeshReader::readBoneAssignment(VertexElementStore &vertexElements,
                                   Int16              &boneIdxVE,
                                   Int16              &boneWeightVE   )
{
    // OSG_OGRE_LOG(("OgreMeshReader::readBoneAssignment\n");

    UInt32 vertIdx    = readUInt32(_is);
    UInt16 boneIdx    = readUInt16(_is);
    Real32 boneWeight = readReal32(_is);

    GeoVec4fPropertyUnrecPtr boneIdxProp;
    GeoVec4fPropertyUnrecPtr boneWeightProp;

    if(boneIdxVE < 0)
    {
        boneIdxProp = GeoVec4fProperty::create();

        VertexElement vElem;

        vElem.bufferIdx = 0;
        vElem.type      = VET_FLOAT4;
        vElem.semantic  = VES_BLEND_INDICES;
        vElem.offset    = 0;
        vElem.index     = 0;
        vElem.prop      = boneIdxProp;

        boneIdxVE       = UInt32(vertexElements.size());

        vertexElements.push_back(vElem);
    }

    if(boneWeightVE < 0)
    {
        boneWeightProp = GeoVec4fProperty::create();

        VertexElement vElem;

        vElem.bufferIdx = 0;
        vElem.type      = VET_FLOAT4;
        vElem.semantic  = VES_BLEND_WEIGHTS;
        vElem.offset    = 0;
        vElem.index     = 0;
        vElem.prop      = boneWeightProp;

        boneWeightVE    = UInt32(vertexElements.size());

        vertexElements.push_back(vElem);
    }

    boneIdxProp    = dynamic_pointer_cast<GeoVec4fProperty>(vertexElements[boneIdxVE   ].prop);
    boneWeightProp = dynamic_pointer_cast<GeoVec4fProperty>(vertexElements[boneWeightVE].prop);

    GeoVec4fProperty::StoredFieldType* boneIdxF    = boneIdxProp   ->editFieldPtr();
    GeoVec4fProperty::StoredFieldType* boneWeightF = boneWeightProp->editFieldPtr();

    if(vertIdx >= boneIdxF->size())
        boneIdxF->resize(vertIdx + 1, Vec4f(-1.f, -1.f, -1.f, -1.f));

    if(vertIdx >= boneWeightF->size())
        boneWeightF->resize(vertIdx + 1, Vec4f(0.f, 0.f, 0.f, 0.f));

    bool found = false;

    for(UInt16 i = 0; i < 4; ++i)
    {
        if((*boneIdxF)[vertIdx][i] < 0.f)
        {
            if((*boneIdxF)[vertIdx][i] != -1.f)
            {
                SINFO << "OgreMeshReader::readBoneAssignment: "
                      << "vertex '" << vertIdx
                      << "' has negative influence from ("
                      << (*boneIdxF   )[vertIdx][i] << ", "
                      << (*boneWeightF)[vertIdx][i]
                      << ")" << std::endl;
            }

            (*boneIdxF   )[vertIdx][i] = boneIdx;
            (*boneWeightF)[vertIdx][i] = boneWeight;

            found = true;
            break;
        }
        else if((*boneIdxF)[vertIdx][i] == boneIdx)
        {
            if((*boneWeightF)[vertIdx][i] < boneWeight)
            {
                OSG_OGRE_LOG(("OgreMeshReader::readBoneAssignment: "
                              "vertex '%u' changing bone influence from "
                              "(%f, %f) to (%f %f).\n",
                              vertIdx,
                              (*boneIdxF   )[vertIdx][i],
                              (*boneWeightF)[vertIdx][i],
                              boneIdx, boneWeight));

                (*boneWeightF)[vertIdx][i] = boneWeight;
            }
            else
            {
                OSG_OGRE_LOG(("OgreMeshReader::readBoneAssignment: "
                              "vertex '%u' already influenced by bone "
                              "(%u, %f) ignoring new weight %f.\n",
                              vertIdx, boneIdx,
                              (*boneWeightF)[vertIdx][i], boneWeight));
            }

            found = true;
            break;
        }
    }

    if(found == false)
    {
        SWARNING << "OgreMeshReader::readBoneAssignment: "
                 << "vertex '" << vertIdx
                 << "' has more than 4 bones assigned." << std::endl;

        UInt16 smallestWeightIdx = 0;
        Real32 smallestWeight    = TypeTraits<Real32>::getMax();

        for(UInt16 i = 0; i < 4; ++i)
        {
            if((*boneWeightF)[vertIdx][i] < smallestWeight)
            {
                smallestWeightIdx = i;
                smallestWeight    = (*boneWeightF)[vertIdx][i];
            }
        }

        if((*boneWeightF)[vertIdx][smallestWeightIdx] < boneWeight)
        {
            OSG_OGRE_LOG(("OgreMeshReader::readBoneAssignment: "
                          "vertex '%u' replacing smallest influence "
                          "(%f, %f) with (%f, %f).\n",
                          vertIdx,
                          (*boneIdxF   )[vertIdx][smallestWeightIdx],
                          (*boneWeightF)[vertIdx][smallestWeightIdx],
                          boneIdx, boneWeight));

            (*boneIdxF   )[vertIdx][smallestWeightIdx] = boneIdx;
            (*boneWeightF)[vertIdx][smallestWeightIdx] = boneWeight;
        }
        else
        {
            OSG_OGRE_LOG(("OgreMeshReader::readBoneAssignment: "
                          "vertex '%u' smallest existing influence "
                          "(%f, %f) is larger than (%f, %f).\n",
                          (*boneIdxF   )[vertIdx][smallestWeightIdx],
                          (*boneWeightF)[vertIdx][smallestWeightIdx],
                          boneIdx, boneWeight));
        }
    }
}
void
OgreMeshReader::readGeometryVertexBufferData(UInt32              vertCount,
                                             UInt16              bindIdx,
                                             VertexElementStore &vertexElements,
                                             BufferVertexMap    &bufferMap      )
{
    OSG_OGRE_LOG(("OgreMeshReader::readGeometryVertexBufferData\n"));

    for(UInt32 i = 0; i < vertCount; ++i)
    {
        for(UInt32 j = 0; j < bufferMap[bindIdx].size(); ++j)
        {
            UInt32 veIdx = bufferMap[bindIdx][j];

            switch(vertexElements[veIdx].type)
            {
            case VET_FLOAT1:
            {
                Vec1f v(readReal32(_is));
                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_FLOAT2:
            {
                Vec2f v;
                v[0] = readReal32(_is);
                v[1] = readReal32(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_FLOAT3:
            {
                Vec3f v;
                v[0] = readReal32(_is);
                v[1] = readReal32(_is);
                v[2] = readReal32(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_FLOAT4:
            {
                Vec4f v;
                v[0] = readReal32(_is);
                v[1] = readReal32(_is);
                v[2] = readReal32(_is);
                v[3] = readReal32(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_COLOUR:
                break;

            case VET_SHORT1:
            {
                Vec1s v(readInt16(_is));
                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_SHORT2:
            {
                Vec2s v;
                v[0] = readInt16(_is);
                v[1] = readInt16(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_SHORT3:
            {
                Vec3s v;
                v[0] = readInt16(_is);
                v[1] = readInt16(_is);
                v[2] = readInt16(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_SHORT4:
            {
                Vec4s v;
                v[0] = readInt16(_is);
                v[1] = readInt16(_is);
                v[2] = readInt16(_is);
                v[3] = readInt16(_is);

                vertexElements[veIdx].prop->addValue(v);
            }
            break;

            case VET_UBYTE4:
                readUInt32(_is);
                SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
                         << "type VET_UBYTE4 NIY" << std::endl;
                break;

            case VET_COLOUR_ARGB:
                SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
                         << "type VET_COLOUR_ARGB NIY" << std::endl;
                break;

            case VET_COLOUR_ABGR:
                SWARNING << "OgreMeshReader::readGeometryVertexBufferData: "
                         << "type VET_COLOUR_ABGR NIY" << std::endl;
                break;
            }
        }
    }
}