///////////////////////////////////////////////////////////////////////////
//
// System: Simplygon
// File: CastingWithBlendingExample.cpp
// Language: C++
//
// Copyright (c) 2019 Microsoft. All rights reserved.
//
// This is private property, and it is illegal to copy or distribute in
// any form, without written authorization by the copyright owner(s).
//
///////////////////////////////////////////////////////////////////////////
//
// #Description#
//
// Run a reduction process on a geometry that has a multi layered material.
// The multi layered material has multiple textures and a blend type for
// how each should blend (add/multiply/subtract etc.).
// Then perform a material cast onto the LOD, where the multi layered
// material is baked into a single texture.
//
///////////////////////////////////////////////////////////////////////////
#include "../Common/Example.h"
void MultiLayeredTextureMapping( const std::string& readFrom, const std::string& writeTo );
int main( int argc, char* argv[] )
{
try
{
InitExample();
// Set global variable. Using Orthonormal method for calculating
// tangentspace.
sg->SetGlobalSetting("DefaultTBNType", SG_TANGENTSPACEMETHOD_ORTHONORMAL);
std::string assetPath = GetAssetPath();
// Run the example code
MultiLayeredTextureMapping(assetPath + "multi.obj", "multi_out");
DeinitExample();
}
catch (const std::exception& ex)
{
std::cerr << ex.what() << std::endl;
return -1;
}
return 0;
}
void MultiLayeredTextureMapping( const std::string& readFrom, const std::string& writeTo )
{
// Run a reduction process on a geometry that has a multi layered material.
// Then perform a material cast onto the LOD, where the multi layered
// material is baked into a single texture.
std::string assetPath = GetAssetPath();
std::string exePath = GetExecutablePath();
std::string output_geometry_filename = exePath + writeTo + ".obj";
std::string output_diffuse_filename = exePath + writeTo + "_diffuse.png";
std::string output_normals_filename = exePath + writeTo + "_normals.png";
// Load from file
spWavefrontImporter objReader = sg->CreateWavefrontImporter();
objReader->SetImportFilePath( readFrom.c_str() );
if( !objReader->RunImport() )
throw std::exception("Failed to load input file!");
spScene scene = objReader->GetScene();
spMaterialTable sceneMaterials = scene->GetMaterialTable();
spTextureTable sceneTextures = scene->GetTextureTable();
sceneMaterials->Clear();
sceneTextures->Clear();
spMaterial diffuseMaterial = sg->CreateMaterial();
//set the number of layers the diffuse channel will use
spShadingLayeredBlendNode diffuseExitNode = sg->CreateShadingLayeredBlendNode();
diffuseExitNode->SetInputCount( 4 );
diffuseMaterial->SetShadingNetwork( SG_MATERIAL_CHANNEL_DIFFUSE, diffuseExitNode );
if( true )
{
std::string diffuseBaseFile = assetPath + "base.jpg";
//import diffuse layer 0 texture (base)
spImageDataImporter imp = sg->CreateImageDataImporter();
imp->SetImportFilePath( diffuseBaseFile.c_str() );
if( !imp->RunImport() )
throw std::exception("Failed to load input file!");
spTexture tex = sg->CreateTexture();
tex->SetName( "base" );
tex->SetImageData( imp->GetImage() );
sceneTextures->AddTexture( tex );
spShadingTextureNode texNode = sg->CreateShadingTextureNode();
texNode->SetTextureName( "base" );
texNode->SetTextureWrapMode(SG_TEXTUREWRAPMODE_CLAMP);
texNode->SetTextureLevel( 0 );
//set the diffuse material layer 0 (base texture)
diffuseExitNode->SetInput( 0, texNode );
diffuseExitNode->SetPerInputBlendType( 0, SG_TEXTUREBLEND_REPLACE );
}
if( true )
{
std::string diffuseAddFile = assetPath + "add.jpg";
//import diffuse layer 1
spImageDataImporter imp = sg->CreateImageDataImporter();
imp->SetImportFilePath( diffuseAddFile.c_str() );
if( !imp->RunImport() )
throw std::exception("Failed to load input file!");
spTexture tex = sg->CreateTexture();
tex->SetName( "add" );
tex->SetImageData( imp->GetImage() );
sceneTextures->AddTexture( tex );
spShadingTextureNode texNode = sg->CreateShadingTextureNode();
texNode->SetTextureName( "add" );
texNode->SetTextureWrapMode(SG_TEXTUREWRAPMODE_CLAMP);
texNode->SetTextureLevel( 0 );
//set the diffuse material layer 1
diffuseExitNode->SetInput( 1, texNode );
diffuseExitNode->SetPerInputBlendType( 1, SG_TEXTUREBLEND_ADD );
}
if( true )
{
std::string diffuseSubtractFile = assetPath + "subtract.jpg";
//load layer 2 texture
spImageDataImporter imp = sg->CreateImageDataImporter();
imp->SetImportFilePath( diffuseSubtractFile.c_str() );
if( !imp->RunImport() )
throw std::exception("Failed to load input file!");
spTexture tex = sg->CreateTexture();
tex->SetName( "sub" );
tex->SetImageData( imp->GetImage() );
sceneTextures->AddTexture( tex );
spShadingTextureNode texNode = sg->CreateShadingTextureNode();
texNode->SetTextureName( "sub" );
texNode->SetTextureWrapMode(SG_TEXTUREWRAPMODE_CLAMP);
texNode->SetTextureLevel( 0 );
//set the diffuse material layer 1
diffuseExitNode->SetInput( 2, texNode );
diffuseExitNode->SetPerInputBlendType( 2, SG_TEXTUREBLEND_SUBTRACT );
}
if( true )
{
std::string diffuseMultiplyFile = assetPath + "multiply.jpg";
//load layer 3 texture
spImageDataImporter imp = sg->CreateImageDataImporter();
imp->SetImportFilePath( diffuseMultiplyFile.c_str() );
if( !imp->RunImport() )
throw std::exception("Failed to load input file!");
spTexture tex = sg->CreateTexture();
tex->SetName( "mult" );
tex->SetImageData( imp->GetImage() );
sceneTextures->AddTexture( tex );
spShadingTextureNode texNode = sg->CreateShadingTextureNode();
texNode->SetTextureName( "mult" );
texNode->SetTextureWrapMode(SG_TEXTUREWRAPMODE_CLAMP);
texNode->SetTextureLevel( 0 );
//set the diffuse material layer 1
diffuseExitNode->SetInput( 3, texNode );
diffuseExitNode->SetPerInputBlendType( 3, SG_TEXTUREBLEND_MULTIPLY );
}
sceneMaterials->AddMaterial( diffuseMaterial );
spReductionProcessor red = sg->CreateReductionProcessor();
red->SetScene( scene );
// Find length of the diagonal of the geometry.
scene->CalculateExtents();
float inf[3], sup[3];
scene->GetInf( inf );
scene->GetSup( sup );
float geom_diameter = 0.0f;
geom_diameter += (inf[0] - sup[0])*(inf[0] - sup[0]);
geom_diameter += (inf[1] - sup[1])*(inf[1] - sup[1]);
geom_diameter += (inf[2] - sup[2])*(inf[2] - sup[2]);
geom_diameter = sqrt( geom_diameter );
// Set the Repair Settings.
spRepairSettings repair_settings = red->GetRepairSettings();
// Will take care of holes that are of size 0.2 or less, so small gaps etc are removed.
repair_settings->SetWeldDist( 0.2f );
repair_settings->SetTjuncDist( 0.2f );
// Set the Reduction Settings.
spReductionSettings reduction_settings = red->GetReductionSettings();
// The geometry will be reduced to be optimally displayed when the diagonal on-screen-size is around 40 pixels
// or less. More in detail: the max error of the geometry will be one hundredth of the geometry's size.
reduction_settings->SetMaxDeviation( geom_diameter / 40.f );
// Set the Normal Calculation Settings.
spNormalCalculationSettings normal_settings = red->GetNormalCalculationSettings();
normal_settings->SetReplaceNormals( true );
normal_settings->SetHardEdgeAngleInRadians( 3.14159f * 90.f / 180.0f );
// Set the Image Mapping Settings.
spMappingImageSettings mapping_settings = red->GetMappingImageSettings();
// Without this we cannot fetch data from the original geometry, and thus not
// generate diffuse and normalmaps later on.
mapping_settings->SetGenerateMappingImage( true );
// Set to generate new texture coordinates.
mapping_settings->SetUseFullRetexturing( true );
mapping_settings->SetGenerateTexCoords( true );
// The higher the number, the fewer texture-borders.
mapping_settings->SetParameterizerMaxStretch( 0.6f );
// Buffer space for when texture is mip-mapped, so color values dont blend over.
mapping_settings->SetGutterSpace( 4 );
mapping_settings->SetWidth( 512 );
mapping_settings->SetHeight( 512 );
mapping_settings->SetMultisamplingLevel( 2 );
red->RunProcessing();
// Mapping image is needed later on for texture casting.
spMappingImage mapping_image = red->GetMappingImage();
// Cast diffuse texture and normal map data into a new material
// Create new material table.
spMaterialTable output_materials = sg->CreateMaterialTable();
spTextureTable output_textures = sg->CreateTextureTable();
// Create new material for the table.
spMaterial output_material = sg->CreateMaterial();
output_material->SetName( "example_material" );
output_materials->AddMaterial( output_material );
// Cast diffuse texture data
{
// Cast the data using a color caster
spColorCaster cast = sg->CreateColorCaster();
cast->SetColorType( SG_MATERIAL_CHANNEL_DIFFUSE );
cast->SetSourceMaterials( sceneMaterials );
cast->SetSourceTextures( sceneTextures );
cast->SetMappingImage( mapping_image ); // The mapping image we got from the remeshing process.
cast->SetOutputChannels( 3 ); // RGB, 3 channels! (1 would be for gray scale, and 4 would be for RGBA.)
cast->SetOutputChannelBitDepth( 8 ); // 8 bits per channel. So in this case we will have 24bit colors RGB.
cast->SetDilation( 10 ); // To avoid mip-map artifacts, the empty pixels on the map needs to be filled to a degree as well.
cast->SetOutputFilePath( output_diffuse_filename.c_str() ); // Where the texture map will be saved to file.
cast->RunProcessing(); // Fetch!
// Set material to point to created texture filename.
AddSimplygonTexture( output_material, output_textures, SG_MATERIAL_CHANNEL_DIFFUSE, output_diffuse_filename.c_str() );
}
//Copy the new material table to the reduced scene
scene->GetMaterialTable()->Copy( output_materials );
scene->GetTextureTable()->Copy( output_textures );
spWavefrontExporter objexp = sg->CreateWavefrontExporter();
objexp->SetExportFilePath( output_geometry_filename.c_str() );
objexp->SetScene( scene );
objexp->RunExport();
}