C++ (Cpp) clearMeshes Examples

Example #1

File: command_buffer.cpp Project: Benau/stk-code

// ----------------------------------------------------------------------------
void ShadowCommandBuffer::fill(OtherMeshMap *mesh_map)
{
    clearMeshes();
    
    if(!CVS->supportsAsyncInstanceUpload())
        mapIndirectBuffer();
    
    std::vector<int> shadow_tex_material_list;
    for(int cascade=0; cascade<4; cascade++)
    {
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_SOLID);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_ALPHA_TEST);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_SOLID_UNLIT);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_NORMAL_MAP);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_SPHERE_MAP);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_DETAIL_MAP);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_VEGETATION);
        shadow_tex_material_list.push_back(cascade * Material::SHADERTYPE_COUNT
                                           + Material::SHADERTYPE_SPLATTING);
    }
    
    fillInstanceData<InstanceDataSingleTex, OtherMeshMap>
        (mesh_map, shadow_tex_material_list, InstanceTypeShadow);
    
    if (!CVS->supportsAsyncInstanceUpload())
        glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
    
} //ShadowCommandBuffer::fill

Example #2

File: model.cpp Project: whztt07/Magic3D-2

bool Magic3D::Model::load(ModelInfo* modelInfo)
{
    bool result = false;
    if (modelInfo)
    {
        clearMeshes();
        std::vector<MeshInfo*>::const_iterator it_m = modelInfo->getMeshes()->begin();
        std::vector<MeshInfo*>::const_iterator it_end = modelInfo->getMeshes()->end();
        while (it_m != it_end)
        {
            MeshInfo* meshInfo = *it_m++;

            Mesh* mesh = new Mesh(meshInfo->getData(), meshInfo->isDoubleSide());

            addMesh(mesh);

            Magic3D::Material* material = meshInfo->getMaterial();
            if (!material)
            {
                material = ResourceManager::getMaterials()->get(M3D_DEFAULT_MATERIAL);
            }
            mesh->addMaterial(material);
        }

        if (modelInfo->getSkeleton())
        {
            skeleton->copyFrom(modelInfo->getSkeleton());
        }

        updateBoundingBox();
    }

    return result;
}

Example #3

File: command_buffer.cpp Project: Benau/stk-code

// ----------------------------------------------------------------------------
void SolidCommandBuffer::fill(SolidPassMeshMap *mesh_map)
{
    clearMeshes();
    
    if(!CVS->supportsAsyncInstanceUpload())
        mapIndirectBuffer();

    std::vector<int> three_tex_material_list =
        createVector<int>(Material::SHADERTYPE_SOLID,
                          Material::SHADERTYPE_ALPHA_TEST,
                          Material::SHADERTYPE_SOLID_UNLIT,
                          Material::SHADERTYPE_SPHERE_MAP,
                          Material::SHADERTYPE_VEGETATION);

    fillInstanceData<InstanceDataThreeTex, SolidPassMeshMap>
        (mesh_map, three_tex_material_list, InstanceTypeThreeTex);

    std::vector<int> four_tex_material_list =
        createVector<int>(Material::SHADERTYPE_DETAIL_MAP,
                          Material::SHADERTYPE_NORMAL_MAP);

    fillInstanceData<InstanceDataFourTex, SolidPassMeshMap>
        (mesh_map, four_tex_material_list, InstanceTypeFourTex);

    if (!CVS->supportsAsyncInstanceUpload())
        glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
} //SolidCommandBuffer::fill

Example #4

File: command_buffer.cpp Project: Benau/stk-code

// ----------------------------------------------------------------------------
void GlowCommandBuffer::fill(OtherMeshMap *mesh_map)
{
    clearMeshes();
    
    if(!CVS->supportsAsyncInstanceUpload())
        mapIndirectBuffer();
    
    fillInstanceData<GlowInstanceData, OtherMeshMap>
        (mesh_map, createVector<int>(0), InstanceTypeGlow);
    if (!CVS->supportsAsyncInstanceUpload())
        glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
    
} //GlowCommandBuffer::fill

Example #5

File: command_buffer.cpp Project: Benau/stk-code

// ----------------------------------------------------------------------------
void ReflectiveShadowMapCommandBuffer::fill(OtherMeshMap *mesh_map)
{
    clearMeshes();
    
    if(!CVS->supportsAsyncInstanceUpload())
        mapIndirectBuffer();
    
    std::vector<int> rsm_material_list =
        createVector<int>(Material::SHADERTYPE_SOLID,
                          Material::SHADERTYPE_ALPHA_TEST,
                          Material::SHADERTYPE_SOLID_UNLIT,
                          Material::SHADERTYPE_DETAIL_MAP,
                          Material::SHADERTYPE_NORMAL_MAP);
                          
    fillInstanceData<InstanceDataSingleTex, OtherMeshMap>
        (mesh_map, rsm_material_list, InstanceTypeRSM);

    if (!CVS->supportsAsyncInstanceUpload())
        glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER);
        
} //ReflectiveShadowMapCommandBuffer::fill

Example #6

File: object.cpp Project: whztt07/Magic3D-2

Magic3D::Object::~Object()
{
    std::vector<Object*>::const_iterator it_o = children.begin();
    while (it_o != children.end())
    {
        (*it_o++)->setParent(NULL, false);
    }
    children.clear();

    std::vector<ObjectInstance*>::const_iterator it_i = instances.begin();
    while (it_i != instances.end())
    {
        (*it_i++)->setInstance(NULL, false);
    }
    instances.clear();

    if (getParent())
    {
        setParent(NULL);
    }

    if (Script::getInstance())
    {
        if (isScripted())
        {
            setScripted(false);
        }
    }

    if (AI)
    {
        delete AI;
        AI = NULL;
    }

    clearMeshes();
}

Example #7

File: extendMesh.cpp Project: 1062054548/extend-mesh

ExtendMesh::~ExtendMesh()
{
    clearMeshes();
}