Esempio n. 1
0
void LodNodePropertyControl::ReadFrom(Entity * sceneNode)
{
	NodesPropertyControl::ReadFrom(sceneNode);

    LodComponent *lodComponent = GetLodComponent(sceneNode);
	DVASSERT(lodComponent);

    propertyList->AddSection("property.lodnode", GetHeaderState("property.lodnode", true));
    
    propertyList->AddBoolProperty("property.lodnode.forcedistance");
    propertyList->SetBoolPropertyValue("property.lodnode.forcedistance", false);
    propertyList->AddSliderProperty("property.lodnode.distanceslider", false);
    propertyList->SetSliderPropertyValue("property.lodnode.distanceslider", 0, LodComponent::MAX_LOD_DISTANCE, LodComponent::MIN_LOD_DISTANCE);

    int32 lodCount = lodComponent->GetLodLayersCount();
    if(1 < lodCount)
    {
        propertyList->AddDistanceProperty("property.lodnode.distances");
        float32 *distances = new float32[lodComponent->GetLodLayersCount()];
        int32 *triangles = new int32[lodComponent->GetLodLayersCount()];
        
        
        Vector<LodComponent::LodData*> lodLayers;
        lodComponent->GetLodData(lodLayers);
        
        Vector<LodComponent::LodData*>::const_iterator lodLayerIt = lodLayers.begin();
        for(int32 i = 0; i < lodComponent->GetLodLayersCount(); ++i)
        {
            distances[i] = lodComponent->GetLodLayerDistance(i);
            
            LodComponent::LodData *layer = *lodLayerIt;
            triangles[i] = GetTrianglesForLodLayer(layer);

            ++lodLayerIt;
        }
        
        propertyList->SetDistancePropertyValue("property.lodnode.distances", distances, triangles, lodComponent->GetLodLayersCount());
        
        
        SafeDeleteArray(distances);
        SafeDeleteArray(triangles);
    }
}
void NodesPropertyControl::AddChildLodSection()
{
    DVASSERT(0 == childLodComponents.size());
    DVASSERT(0 == childDistances.size());
    
    Vector<Entity *>nodes;
    currentSceneNode->GetChildNodes(nodes);
    nodes.push_back(currentSceneNode);
    for(int32 i = 0; i < (int32)nodes.size(); ++i)
    {
        LodComponent *lodComponent = GetLodComponent(nodes[i]);
        if(lodComponent)
        {
            childLodComponents.push_back(lodComponent);
        }
    }
    
    if(0 < childLodComponents.size())
    {
        propertyList->AddSection("LODs at hierarchy", GetHeaderState("LODs at hierarchy", true));
        
        propertyList->AddBoolProperty("property.lodnode.forcedistance");
        propertyList->SetBoolPropertyValue("property.lodnode.forcedistance", false);
        propertyList->AddSliderProperty("property.lodnode.distanceslider", false);
        propertyList->SetSliderPropertyValue("property.lodnode.distanceslider", 0, 
                                             LodComponent::MAX_LOD_DISTANCE, LodComponent::MIN_LOD_DISTANCE);
        
        
        
        struct LodInfo
        {
            float32 distance;
            int32 triangles;
            int32 count;
            
            LodInfo()
            {
                count = 0;
                distance = 0.0f;
                triangles = 0;
            }
            
        }lodInfo[LodComponent::MAX_LOD_LAYERS];
        
        for(int32 i = 0; i < (int32)childLodComponents.size(); ++i)
        {
            float32 *distances = new float32[LodComponent::MAX_LOD_LAYERS];
            
            
            Vector<LodComponent::LodData*> lodLayers;
            childLodComponents[i]->GetLodData(lodLayers);
            Vector<LodComponent::LodData*>::const_iterator lodLayerIt = lodLayers.begin();
            
            int32 iLod = 0;
            for(; iLod < childLodComponents[i]->GetLodLayersCount(); ++iLod)
            {
                //TODO: calculate triangles
                LodComponent::LodData *layer = *lodLayerIt;
                lodInfo[iLod].triangles += GetTrianglesForLodLayer(layer);
                ++lodLayerIt;

                distances[iLod] = childLodComponents[i]->GetLodLayerDistance(iLod);
                
                lodInfo[iLod].distance += childLodComponents[i]->GetLodLayerDistance(iLod);
                lodInfo[iLod].count++;
            }
            
            for(; iLod < LodComponent::MAX_LOD_LAYERS; ++iLod)
            {
                distances[iLod] = 0.0f;
            }
            
            childDistances.push_back(distances);
        }
        
        propertyList->AddDistanceProperty("property.lodnode.distances");
        float32 *distances = new float32[LodComponent::MAX_LOD_LAYERS];
        int32 *triangles = new int32[LodComponent::MAX_LOD_LAYERS];
        int32 count = 0;
        for(int32 iLod = 0; iLod < LodComponent::MAX_LOD_LAYERS; ++iLod)
        {
            if(lodInfo[iLod].count)
            {
                triangles[iLod] = lodInfo[iLod].triangles;
                distances[iLod] = lodInfo[iLod].distance / lodInfo[iLod].count;
                count = iLod + 1;
            }
            else 
            {
                distances[iLod] = 0.0f;
                triangles[iLod] = 0;
            }
            
        }
        
        propertyList->SetDistancePropertyValue("property.lodnode.distances", distances, triangles, count);
        SafeDeleteArray(distances);
        SafeDeleteArray(triangles);
        
        propertyList->AddMessageProperty("Set Distances", 
                                         Message(this, &NodesPropertyControl::OnSetDistancesForLodNodes));
    }
}