集成阶段 6：使用 NavData 生成 API

#include "gwnavgeneration.h"

class MyProducer : public Kaim::GeneratorInputProducer
{
 
public:
    virtual KyResult Produce(
            const Kaim::GeneratorSector& sector, 
            Kaim::ClientInputConsumer& inputConsumer);
};

KyResult MyProducer::Produce(
            const Kaim::GeneratorSector& /* sector */, 
            Kaim::ClientInputConsumer& inputConsumer )

{
    // A sector can contain your whole level, or a part of a level that you plan
    // to stream in and out at runtime. You can set up as many sectors as you need.
    // See the section on running a generation below.
    
    // A NavTag is an array of blind data that you can add on each triangle.
    // You can use this data to distinguish different materials that you want to
    // take into account during your runtime path finding and path following.
    Kaim::DynamicNavTag aNavTag;
    aNavTag.m_blindDataArray.PushBack(42);


    // Set up a CoordSystem object to match the system used in your editor.
    KyFloat32 oneMeterInClientUnits = 1.0f; 
    Kaim::CoordSystem::ClientAxis clientRightAxis = Kaim::CLIENT_X;
    Kaim::CoordSystem::ClientAxis clienFrontAxis = Kaim::CLIENT_Y;
    Kaim::CoordSystem::ClientAxis clientUpAxis = Kaim::CLIENT_Z;

    Kaim::CoordSystem myCoordSystem;
    myCoordSystem.Setup( 
        oneMeterInClientUnits, 
        clientRightAxis, 
        clienFrontAxis, 
        clientUpAxis ); 

    // For each triangle in the sector, feed it to the input consumer.
    // How you retrieve the triangles is specific to your system.
    // If you have set up a CoordSystem as shown above, you can send your
    // triangles in your own coordinate system. The conversion is done internally
    // by the generation system.
    for(KyUInt32 index=0; index < myTriangleCount; index++)
    {
        inputConsumer.ConsumeTriangle(
                        myTriangle.Vertex[0], 
                        myTriangle.Vertex[1], 
                        myTriangle.Vertex[2], 
                        aNavTag,
                        myCoordSystem);
    }
    return KY_SUCCESS;
}

#include "gwnavgenerationglue/defaultgeneratorglue.h"

bool Generate()
{
    // Create an instance of your GeneratorInputProducer class.
    Kaim::Ptr<MyProducer> producer = *KY_NEW MyProducer;
 
    // Create an instance of the DefaultGeneratorGlue.
    KyGlue::DefaultGeneratorGlue glue;
 
    // Set up a Generator to use your producer.
    Kaim::Generator generator(producer, &glue);
 
    // Set the output directory within which the .NavData and other output files
    // are created. You must use the same absolute root directory every time
    // you create a Generator, but you might set up a different relative directory for
    // each different level. This keeps all of your NavData easily accessible during
    // visual debugging.
    generator.SetOutputDirectory("c:/MyGame/NavData", "MyTestLevel");
 
    // Create a GeneratorInputOutput
    Kaim::GeneratorInputOutput generatorInputOutput;

    // Alternatively, you can create a GeneratorInputOutput by loading it from a
    // .GenIO file created during a previous generation run. This retains all
    // settings from the last run. You can also explicitly save your GeneratorInputOutput
    // object at any time by calling Kaim::GeneratorInputOutput::Save().


    // Use the Kaim::GeneratorParameters and Kaim::GeneratorAdvancedParameters
    // classes that are accessible through generatorInputOutput.m_params and
    // generatorInputOutput.m_params.m_advancedParameters to configure settings
    // such as, the dimensions and movemement capabilities of your characters.
    generatorInputOutput.m_params.m_entityRadius = 0.8f;
    generatorInputOutput.m_params.m_advancedParameters.m_navTagMinPixelArea = 4;

    // Use the Kaim::GeneratorRunOptions class that is accessible through
    // generatorInputOutput.m_runOptions to configure the operation of the
    // generation process itself.
    generatorInputOutput.m_runOptions. m_doMultiCore = true;

    // Add a sector.
    // It is recommended to create a unique GUID for each sector and 
    // even to save it along with your own level definition. This ensures that you
    // always generate with the same GUID for a given level or block of terrain.
    // If you want to generate a random GUID, you can use the
    // KyGlue::DefaultGuidGeneratorInterface class.
    Kaim::Ptr<Kaim::GeneratorSector> sector = *KY_NEW Kaim::GeneratorSector(
            Kaim::KyGuid("AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA"), 
            "MyGameLevel");
 
    generatorInputOutput.AddSector(sector);

 
    // Run a generation using the configuration we have set up.
    if (Kaim::Result::Fail(generator.Generate(generatorInputOutput)))
    {
        return false;
    }
    return true;
}