maputil.cpp

使用stl技术,(还没看,是听说的)

    // 
    // Split Light Map in 2^n  part  
    // 
    if (PagingLandScapeOptions::getSingleton().LightMap)
        Splitter.saveAndSplitMap (pure_file_name + String("Light.") + ext_name,
        LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur));
    // 
    // Split Shadow Map in 2^n  part (shadow is light map inverted.)
    // 
    if (PagingLandScapeOptions::getSingleton().ShadowMap)
        Splitter.saveAndSplitMap (pure_file_name + String("Shadow.") + ext_name,
        LightMapper.getShadowMap (mSun, mAmb, mDiff, mBlur));

    // 
    // Generate a Color Map in 2^n  part 
    // 
    if (PagingLandScapeOptions::getSingleton().ColorMapGenerate)
        Splitter.saveAndSplitMap (pure_file_name + String("Color.") + ext_name,
                                SplatMapper.getColorMap ());
    // 
    // Lit Generated Color Map in 2^n  part 
    // 
    if (PagingLandScapeOptions::getSingleton().LitColorMapGenerate)
    { 
        // does modify colormap.
        MergeModulater.ModulateGrayAndRgbInRgb (LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur),
                                                SplatMapper.getColorMap (),
                                                2);
        Splitter.saveAndSplitMap (pure_file_name + String("LitColor.") + ext_name,
                                SplatMapper.getColorMap ());
    }


    // 
    // If user want to use its Own Color Map
    //
    if (PagingLandScapeOptions::getSingleton().ColorMapSplit || 
        PagingLandScapeOptions::getSingleton().LitColorMapSplit)
    {
        Image ExistingColorMap;
        String MapName = PagingLandScapeOptions::getSingleton().ColorMapName;
        ExistingColorMap.load (MapName);

        // Get codec according to filename extension
        size_t colorpos = MapName.find_last_of(".");
        String colorpure_file_name = MapName.substr(0, colorpos + 1);
        String colorext_name = MapName.substr(colorpos + 1);
        if (colorext_name.length() == 0)
            colorext_name = PagingLandScapeOptions::getSingleton().landscape_extension;

        // 
        // Split User Color Map in 2^n  part 
        // 
        if (PagingLandScapeOptions::getSingleton().ColorMapSplit)
        {
                Splitter.saveAndSplitMap (colorpure_file_name + colorext_name,
                                                    &ExistingColorMap);
        }
        // 
        // Lit User Color Map  in 2^n  part 
        // 
        if (PagingLandScapeOptions::getSingleton().LitColorMapSplit)
        { 
            // does modify colormap.
            MergeModulater.ModulateGrayAndRgbInRgb (LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur),
                                                    &ExistingColorMap,
                                                    2);
            Splitter.saveAndSplitMap (colorpure_file_name + String("Lit.") + colorext_name,
                                      &ExistingColorMap);
        }   
    }

    // 
    // Split Base Map in 2^n  part 
    // 
    if (PagingLandScapeOptions::getSingleton().BaseMap)
        Splitter.saveAndSplitMap (pure_file_name + String("Base.") + ext_name,
                                SplatMapper.getBaseMap ());

    // 
    // Split Lit Base Map in 2^n  part 
    // 
    if (PagingLandScapeOptions::getSingleton().LitBaseMap)
    { 
            // does modify Base Map.
            MergeModulater.ModulateGrayAndRgbaInRgba (LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur),
                                                SplatMapper.getBaseMap (),
                                                2);

            Splitter.saveAndSplitMap (pure_file_name + String("LitBase.") + ext_name,
                                        SplatMapper.getBaseMap ());
    }

    // 
    // Split Coverage Map in 2^n  part 
    // 
    if (PagingLandScapeOptions::getSingleton().CoverageMap)
    {
        //MapBlurrer Blurrer;

        // blur.
        //Blurrer.gaussianBlur (SplatMapper.getCoverageMap (), 2);

        Splitter.saveAndSplitMap (pure_file_name + String("Coverage.") + ext_name,
                                SplatMapper.getCoverageMap ());
    }

    // 
    // Split Alpha Map in 2^n  part 
    // (each alpha is a color channel of coverage Map)
    //
    if (PagingLandScapeOptions::getSingleton().AlphaMaps)
        for (uint i = 0; i < 4; i++)
    {
            String alphaname;

            alphaname =  pure_file_name + String("Alpha.") + 
                                        StringConverter::toString(i) + 
                                        String(".") + ext_name;
            Splitter.saveAndSplitMap (alphaname, 
                                    SplatMapper.getAlphaMap (i));
    }

    // 
    // Merge Alpha Map and an empty RGBA map
    // Split it in 2^n  part 
    //
    if (PagingLandScapeOptions::getSingleton().AlphaSplatRGBAMaps)
    {
        DataChunk dc;
        Image RgbImage;
        dc.allocate(getMapWidth () * getMapHeight () * 3);
        memset (dc.getPtr (), 0, dc.getSize ());
        RgbImage.loadRawData (dc, getMapWidth () - 1, getMapHeight () - 1, PF_R8G8B8); 
        dc.clear();
        for (uint i = 0; i < 4; i++)
        {
            String alphaname;

            alphaname =  pure_file_name + String("AlphaSplatRGBAMaps.") + StringConverter::toString(i) + 
                String(".") + ext_name;
            // does not modify AlphaMap, allocate a new image
            mAlphaMap[i] = MergeModulater.MergeGrayAndRgbInRgba (
                                            SplatMapper.getAlphaMap (i),
                                            &RgbImage);
            Splitter.saveAndSplitMap (alphaname, 
                                        mAlphaMap[i]);
            delete mAlphaMap[i];                
         }
    }

    // 
    // Merge Alpha Map and Light map
    // Split it in 2^n  part 
    //
     if (PagingLandScapeOptions::getSingleton().AlphaSplatLightMaps)
        {
            for (uint i = 0; i < 4; i++)
            {
                String alphaname;

                alphaname =  pure_file_name + String("AlphaSplatLightMaps.") + StringConverter::toString(i) + 
                    String(".") + ext_name;
                // does not modify AlphaMap, allocate a new image
                // does prepare a new AlphaMap for merging.
                if (!PagingLandScapeOptions::getSingleton().AlphaSplatRGBAMaps)
                    mAlphaMap[i] = MergeModulater.MergeAlphaAndRgbInRgba (LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur),
                                            SplatMapper.getAlphaMap (i));

                // does modify mAlphaMap[i]
                MergeModulater.MergeGrayAndRgbaInRgba (LightMapper.getLightMap (mSun, mAmb, mDiff, mBlur),
                                                        mAlphaMap[i]);

                Splitter.saveAndSplitMap (alphaname, 
                                            mAlphaMap[i]); 
                delete mAlphaMap[i];   
            }
        }

    // 
    // Split RGB Map in 2^n  part 
    //       
    if (PagingLandScapeOptions::getSingleton().RGBMaps)
        for (uint i = 0; i < 4; i++)
        {
            String RGBname;

            RGBname =  pure_file_name + String("RGB.") + StringConverter::toString(i) + 
                String(".") + ext_name;
            Splitter.saveAndSplitMap (RGBname, 
                SplatMapper.getRGBMap (i));
        }


    // 
    // create a Potential Visibility Set map 
    //    
    if (PagingLandScapeOptions::getSingleton().PVSMap)
    {
        MapVis PVSMapper;

        PVSMapper.calc (32, 20);
        PVSMapper.save (const_cast< char * > ((pure_file_name + String("vis")).c_str()));
    }

   
    // 
    // create a Horizon map 
    // That let us calculate mountains shadows
    //    
    MapHorizon HorizonMapper;
    //MapHorizon2 HorizonMapper;// maybe prettier

    if (PagingLandScapeOptions::getSingleton().HorizonMap)
    {

        uint horizon_samples = 128;
        uint vscale = 7;
        uint steps = 16;
        //vscale = 20; step = 16; horizon_samples = 16;
        //HorizonMapper.calcHorizon3DMap (vscale, horizon_samples, steps);

        //vscale = 7; step = 16; horizon_samples = 128;
        HorizonMapper.calcHorizon3DMap (vscale, horizon_samples, steps);//2
        for (uint k = 0; k < horizon_samples; k++) 
        {  
            String HCMname;

            HCMname =  pure_file_name + String("HCM_") + StringConverter::toString(k) + String(".")  + ext_name;

            MapBlurrer Blurrer;

            // blur.
            //Blurrer.gaussianBlur (HorizonMapper.getHorizon3DMap (k), 2);

            Splitter.saveAndSplitMap (HCMname, 
                                        HorizonMapper.getHorizon3DMap (k));
        }
    }

    // 
    // create an Elevation Map
    // Used as lookup table to get shadows position 
    //    
    if (PagingLandScapeOptions::getSingleton().ElevationMap)
    { 
        HorizonMapper.calcElevationCubeMap (256);

        const String cubename[6] = 
        {
            "rt", "lf", 
            "up", "dn", 
            "fr", "bk"
        };


        for (uint k = 0; k < 6; k++) 
        {
            String Elevname;

            //Elevname =  pure_file_name + "Elev_" + cubename[k] + "."  + "raw";
            Elevname  = pure_file_name + String("Elev_") + cubename[k] + String(".png");
            Splitter.saveAndSplitMap (Elevname, 
                                        HorizonMapper.getElevationCubeMap (k));

        }  
    }
}


}//namespace Ogre