Materials Sample

For documentation on the materials API, see Materials.

The example below gives an illustration of extracting both the diffuse texture map from the spaceship asset (available from www.orbolt.com), as well as extracting the Mantra rendered image planes of C (diffuse color), A (alpha), and N (normal) in the UV space of the asset.

#include <HAPI/HAPI.h>
#include <stdlib.h>
#include <iostream>
#include <string>

#define ENSURE_SUCCESS( result ) \
    if ( (result) != HAPI_RESULT_SUCCESS ) \
    { \
        std::cout << "failure at " << __FILE__ << ":" \
            << __LINE__ << std::endl; \
        std::cout << get_last_error() << std::endl; \
        exit( 1 ); \
    }

#define ENSURE_COOK_SUCCESS( result ) \
    if ( (result) != HAPI_STATE_READY ) \
    { \
        std::cout << "failure at " << __FILE__ << ":" \
            << __LINE__ << std::endl; \
        std::cout << get_last_cook_error() << std::endl; \
        exit( 1 ); \
    }

static void dump_asset_materials(
    int asset_id, const HAPI_AssetInfo &asset_info );
static void dump_part_diffuse_texturemap(
    int asset_id, int object_id, int geo_id, int part_id );

static void dump_part_mantra_render(
     int asset_id, int object_id, int geo_id, int part_id );

static void extract_image_planes(
    int asset_id,
    const HAPI_MaterialInfo & material_info,
    const char * base_file_name );

static std::string get_string( HAPI_StringHandle string_handle );
static std::string get_last_error();
static std::string get_last_cook_error();
static void wait_for_cook();

int main( int argc, char **argv )
{
    const char *otl_file = argc == 2 ? argv[ 1 ] : "test_asset.otl";

    HAPI_CookOptions cook_options = HAPI_CookOptions_Create();

    ENSURE_SUCCESS( HAPI_Initialize(
        nullptr, // session
        &cook_options,
        true, // use_cooking_thread
        -1, // cooking_thread_stack_size
        nullptr, // otl_search_path
        nullptr, // dso_search_path
        nullptr, // image_dso_search_path
        nullptr // audio_dso_search_path
    ) );

    int library_id;
    int asset_id;
    if ( HAPI_LoadAssetLibraryFromFile(
        nullptr,
        otl_file,
        true,
        &library_id ) != HAPI_RESULT_SUCCESS )
    {
        std::cout << "Could not load " << otl_file << std::endl;
        exit( 1 );
    }

    HAPI_StringHandle asset_name_sh;
    ENSURE_SUCCESS( HAPI_GetAvailableAssets(
        nullptr, library_id, &asset_name_sh, 1 ) );
    std::string asset_name = get_string( asset_name_sh );

    if ( HAPI_InstantiateAsset(
        nullptr,
        asset_name.c_str(),
        true,
        &asset_id ) != HAPI_RESULT_SUCCESS )
    {
        std::cout << "Could not instantiate asset " << asset_name << std::endl;
        exit( 1 );
    }

    wait_for_cook();

    // Retrieve information about the asset.
    HAPI_AssetInfo asset_info;
    ENSURE_SUCCESS( HAPI_GetAssetInfo( nullptr, asset_id, &asset_info ) );

    // Print information about the geometry contained inside the asset.
    dump_asset_materials( asset_id, asset_info );

    ENSURE_SUCCESS( HAPI_Cleanup( nullptr ) );
    return 0;
}

static void wait_for_cook()
{
    int status;
    do
    {
        HAPI_GetStatus( nullptr, HAPI_STATUS_COOK_STATE, &status );
    }
    while ( status > HAPI_STATE_MAX_READY_STATE );

    ENSURE_COOK_SUCCESS( status );
}

static void dump_asset_materials(
    int asset_id, const HAPI_AssetInfo & asset_info )
{
    HAPI_ObjectInfo * object_infos =
        new HAPI_ObjectInfo[ asset_info.objectCount ];

    ENSURE_SUCCESS( HAPI_GetObjects(
        nullptr,
        asset_id, object_infos, 0, asset_info.objectCount ) );

    for ( int object_index = 0; object_index < asset_info.objectCount;
          ++object_index )
    {
        HAPI_ObjectInfo & object_info = object_infos[ object_index ];

        for ( int geo_index = 0; geo_index < object_info.geoCount;
              ++geo_index )
        {
            HAPI_GeoInfo geo_info;
            ENSURE_SUCCESS( HAPI_GetGeoInfo(
                nullptr,
                asset_id, object_info.id, geo_index, &geo_info ) );

            for ( int part_index = 0; part_index < geo_info.partCount;
                  ++part_index )
            {
                dump_part_diffuse_texturemap(
                    asset_id, object_info.id, geo_info.id, part_index );
            }
        }
    }

    delete [] object_infos;
}

static int find_parm_index(
    HAPI_NodeInfo & node_info,
    HAPI_ParmInfo * parm_infos,
    const char * parm_name_in )
{    
    int parm_index = -1;
    for ( int i = 0; i < node_info.parmCount; ++i )
    {
        std::string parm_name = get_string( parm_infos[ i ].nameSH );
        if ( parm_name == parm_name_in )
        {
            parm_index = i;
            break;
        }
    }
    return parm_index;
}

static void extract_image_planes(
    int asset_id,
    const HAPI_MaterialInfo & material_info )
{
    HAPI_ImageInfo image_info;
    ENSURE_SUCCESS( HAPI_GetImageInfo(
        nullptr, asset_id, material_info.id, & image_info ) );

    std::string image_format_name =
        get_string( image_info.imageFileFormatNameSH );

    std::cout << "Image width=" << image_info.xRes << " height="
        << image_info.yRes << " Format:"
        << image_format_name << std::endl;

    int num_image_planes;
    ENSURE_SUCCESS( HAPI_GetImagePlaneCount(
        nullptr, asset_id, material_info.id, &num_image_planes ) );

    std::cout << "Number of image planes" << num_image_planes << std::endl;

    int * image_planes = new int[ num_image_planes ];
    ENSURE_SUCCESS( HAPI_GetImagePlanes(
        nullptr, asset_id, material_info.id,
        image_planes, num_image_planes ) );

    for ( int ii = 0; ii < num_image_planes; ii++ )
    {
        std::string image_plane_name = get_string( image_planes[ ii ] );
        std::cout
            << "Imange plane [" << ii << "] = "
            << image_plane_name << std::endl;

        int destination_file_path;
        HAPI_ExtractImageToFile(
            nullptr,
            asset_id, material_info.id,
            HAPI_PNG_FORMAT_NAME,
            image_plane_name.c_str(),
            "C:/test",
            nullptr,
            &destination_file_path );

        std::string destination_file_path_str =
            get_string( destination_file_path );
        std::cout
            << "File written to "
            << destination_file_path_str << std::endl;
    }

    delete[] image_planes;
}

static void dump_part_diffuse_texturemap(
    int asset_id, int object_id, int geo_id, int part_id )
{
    std::cout
        << "object " << object_id << ", geo " << geo_id
        << ", part " << part_id << std::endl;

    HAPI_PartInfo part_info;
    ENSURE_SUCCESS( HAPI_GetPartInfo(
        nullptr,
        asset_id, object_id, geo_id, part_id, &part_info ) );

    HAPI_MaterialId material_id = -1;
    HAPI_MaterialInfo material_info;
    ENSURE_SUCCESS( HAPI_GetMaterialIdsOnFaces(
        nullptr,
        asset_id, object_id, geo_id, part_id, NULL, &material_id, 0, 1 ) );

    ENSURE_SUCCESS( HAPI_GetMaterialInfo(
        nullptr, asset_id, material_id, &material_info ) );

    if ( !material_info.exists )
    {
        std::cout
            << "No material found:" << "object " << object_id
            << ", geo " << geo_id
            << ", part " << part_id << std::endl;
        return;
    }

    HAPI_NodeInfo node_info;
    ENSURE_SUCCESS( HAPI_GetNodeInfo(
        nullptr, material_info.nodeId, &node_info ) );

    // Get information about all the parameters.
    HAPI_ParmInfo *parm_infos = new HAPI_ParmInfo[ node_info.parmCount ];
    ENSURE_SUCCESS( HAPI_GetParameters(
        nullptr,
        material_info.nodeId, parm_infos, 0, node_info.parmCount ) );

    int base_color_map_parm_index = find_parm_index(
        node_info, parm_infos, "baseColorMap" );
    if ( base_color_map_parm_index < 0 )
    {
        std::cout
            << "Could not find parameter for diffuse texture map."
            << std::endl;
        return;
    }

    ENSURE_SUCCESS( HAPI_RenderTextureToImage(
        nullptr,
        asset_id, material_info.id, 
        parm_infos[ base_color_map_parm_index ].id ) );

    extract_image_planes( asset_id, material_info );
}

static std::string get_string( HAPI_StringHandle string_handle )
{
    // A string handle of 0 means an invalid string handle -- similar to
    // a null pointer.  Since we can't return NULL, though, return an empty
    // string.
    if ( string_handle == 0 )
        return "";

    int buffer_length;
    ENSURE_SUCCESS( HAPI_GetStringBufLength(
        nullptr, string_handle, &buffer_length ) );

    char * buf = new char[ buffer_length ];

    ENSURE_SUCCESS( HAPI_GetString(
        nullptr, string_handle, buf, buffer_length ) );

    std::string result( buf );
    delete[] buf;
    return result;
}

static std::string get_last_error()
{
    int buffer_length;
    HAPI_GetStatusStringBufLength(
        nullptr,
        HAPI_STATUS_CALL_RESULT, HAPI_STATUSVERBOSITY_ERRORS, &buffer_length );

    char * buf = new char[ buffer_length ];

    HAPI_GetStatusString(
        nullptr, HAPI_STATUS_CALL_RESULT, buf, buffer_length );

    std::string result( buf );
    delete[] buf;

    return result;
}

static std::string get_last_cook_error()
{
    int buffer_length;
    HAPI_GetStatusStringBufLength(
        nullptr,
        HAPI_STATUS_COOK_RESULT, HAPI_STATUSVERBOSITY_ERRORS, &buffer_length );

    char * buf = new char[ buffer_length ];

    HAPI_GetStatusString(
        nullptr, HAPI_STATUS_CALL_RESULT, buf, buffer_length );

    std::string result( buf );
    delete[] buf;

    return result;
}