AModelLoader Class Reference

#include <AModelLoader.h>

Inheritance diagram for AModelLoader:

Classes
struct	AlphaRefMaterial
struct	ClampedMaterial
struct	MaterialNode

Public Member Functions
	TDECLARE_CLASS (AModelLoader, Toshi::TObject)
	AModelLoader ()
	~AModelLoader ()

Static Public Member Functions
static Toshi::TMaterial *	CreateMaterial (Toshi::TShader *a_pShader, const TCHAR *a_szMaterialName)
static void	DestroyMaterial (Toshi::TMaterial *a_pMaterial)
static void	InitialiseStatic ()

Static Public Attributes
static constexpr TUINT	MAX_NUM_ALLOCATED_MATERIALS = 512
static constexpr TUINT	MAX_NUM_MODEL_MATERIALS = 150

Friends
class	AModelInstance

Detailed Description

Definition at line 18 of file AModelLoader.h.

Constructor & Destructor Documentation

AModelLoader()

AModelLoader::AModelLoader

(

)

Definition at line 26 of file AModelLoader.cpp.

{
    for ( TUINT i = 0; i < TARRAYSIZE( ms_oNodesAlloc ); i++ )
    {
        ms_oFreeMaterials.PushBack( &ms_oNodesAlloc[ i ] );
        ms_oNodesAlloc[ i ].iId = TUINT16( i );
    }
 
    // Load material properties
    const TBOOL bAssetPackLoaded = AAssetLoader::GetAssetTRB( AAssetType_AssetPack ) != TNULL;
 
    if ( bAssetPackLoaded )
    {
        // Use asset pack
        ms_pWorldEndRender       = AAssetLoader::GetSymbolAddress( "materialproperties", "WorldEndRender", AAssetType_AssetPack );
        ms_pWorldStartRender     = AAssetLoader::GetSymbolAddress( "materialproperties", "WorldStartRender", AAssetType_AssetPack );
        ms_pWorldUVOffsetsPerSec = AAssetLoader::GetSymbolAddress( "materialproperties", "WorldUVOffsetsPerSec", AAssetType_AssetPack );
        ms_pAlphaRefMaterials    = AAssetLoader::CastSymbol<AlphaRefMaterial>( "materialproperties", "AlphaRefMaterials", AAssetType_AssetPack );
        ms_pClampedMaterials     = AAssetLoader::CastSymbol<ClampedMaterial>( "materialproperties", "ClampedMaterials", AAssetType_AssetPack );
        ms_pGlowMaterials        = AAssetLoader::CastSymbol<const TCHAR*>( "materialproperties", "GlowMaterials", AAssetType_AssetPack );
    }
    else
    {
        // Load from file
        m_oTRB.Load( "Data\\MiscTextures\\MaterialProperties.trb" );
        ms_pWorldEndRender       = m_oTRB.GetSymbolAddress( "WorldEndRender" );
        ms_pWorldStartRender     = m_oTRB.GetSymbolAddress( "WorldStartRender" );
        ms_pWorldUVOffsetsPerSec = m_oTRB.GetSymbolAddress( "WorldUVOffsetsPerSec" );
        ms_pAlphaRefMaterials    = m_oTRB.CastSymbol<AlphaRefMaterial>( "AlphaRefMaterials" );
        ms_pClampedMaterials     = m_oTRB.CastSymbol<ClampedMaterial>( "ClampedMaterials" );
        ms_pGlowMaterials        = m_oTRB.CastSymbol<const TCHAR*>( "GlowMaterials" );
    }
 
    TModel::SetLoaderTMDCallback( AModelLoaderLoadTMDCallback );
    TModel::SetLoaderTRBCallback( AModelLoaderLoadTRBCallback );
 
    // Count glow materials
    ms_iNumGlowMaterials = 0;
    auto pGlowMaterial   = ms_pGlowMaterials;
 
    while ( *pGlowMaterial )
    {
        ms_iNumGlowMaterials += 1;
        pGlowMaterial++;
    }
 
    // Load double sided materials
    ms_pDoubleSidedMaterials = ( bAssetPackLoaded ) ?
        AAssetLoader::CastSymbol<const TCHAR*>( "materialproperties", "DoubleSidedMaterials", AAssetType_AssetPack ) :
        m_oTRB.CastSymbol<const TCHAR*>( "DoubleSidedMaterials" );
 
    // Count double sided materials
    ms_iNumDoubleSidedMaterials = 0;
    auto pDoubleSidedMaterial   = ms_pDoubleSidedMaterials;
 
    while ( *pDoubleSidedMaterial )
    {
        ms_iNumDoubleSidedMaterials += 1;
        pDoubleSidedMaterial++;
    }
 
    // Symbol table is not needed anymore
    if ( !bAssetPackLoaded )
        m_oTRB.DeleteSymbolTable();
 
    if ( TNULL == ms_pDefaultSkinMaterial )
    {
        ASkinMaterial* pSkinMaterial = ASkinShader::GetSingleton()->CreateMaterial( TNULL );
        pSkinMaterial->Create( 7 );
        pSkinMaterial->SetFlags( TMaterial::FLAGS_NO_CULL, TFALSE );
        pSkinMaterial->SetTexture( TNULL );
 
        ms_pDefaultSkinMaterial = pSkinMaterial;
    }
 
    if ( TNULL == ms_pDefaultWorldMaterial )
    {
        AWorldMaterial* pWorldMaterial = AWorldShader::GetSingleton()->CreateMaterial( TNULL );
        pWorldMaterial->Create( 6 );
        pWorldMaterial->SetFlags( TMaterial::FLAGS_NO_CULL, TFALSE );
        pWorldMaterial->SetTexture( 0, TNULL );
        pWorldMaterial->SetTextureNum( 1 );
 
        ms_pDefaultWorldMaterial = pWorldMaterial;
    }
}

~AModelLoader()

AModelLoader::~AModelLoader

(

)

Definition at line 113 of file AModelLoader.cpp.

{
}

Member Function Documentation

CreateMaterial()

TMaterial * AModelLoader::CreateMaterial ( Toshi::TShader * a_pShader, const TCHAR * a_szMaterialName )

static

Definition at line 183 of file AModelLoader.cpp.

{
    TPROFILER_SCOPE();
 
    char prefixName[ 32 ];
 
    if ( a_pShader->IsA( &TGetClass( ASkinShader ) ) )
    {
        TStringManager::String8Copy( prefixName, "ss_" );
    }
    else if ( a_pShader->IsA( &TGetClass( AWorldShader ) ) )
    {
        TStringManager::String8Copy( prefixName, "ws_" );
    }
    else if ( a_pShader->IsA( &TGetClass( AGrassShader ) ) )
    {
        TStringManager::String8Copy( prefixName, "gs_" );
    }
    else
    {
        TASSERT( !"Unknown shader" );
        return TNULL;
    }
 
    TString8 materialName = prefixName;
    materialName += a_szMaterialName;
 
    auto pResultMaterial = FindMaterial( materialName );
    if ( pResultMaterial ) return pResultMaterial;
 
    TTextureResourceHAL* pTexture;
    const char*          szTextureName;
    auto                 pTMDMaterial = FindMaterialInModel( a_szMaterialName );
 
    if ( pTMDMaterial )
    {
        pTexture = TDYNAMICCAST(
            TTextureResourceHAL,
            AMaterialLibraryManager::GetSingleton()->FindTexture( pTMDMaterial->szTextureFile )
        );
 
        szTextureName = pTMDMaterial->szTextureFile;
    }
    else
    {
        TTRACE( "Couldn't find texture for material '%s'", a_szMaterialName );
        pTexture = TDYNAMICCAST(
            TTextureResourceHAL,
            TRenderD3DInterface::Interface()->GetInvalidTexture()
        );
        szTextureName = "invalid";
    }
 
    TVALIDPTR( pTexture );
 
    auto        eTextureFormat = pTexture->GetImageInfo().Format;
    const TBOOL bIsAlpha       = eTextureFormat == D3DFMT_A8R8G8B8 ||
        eTextureFormat == D3DFMT_A4R4G4B4 ||
        eTextureFormat == D3DFMT_A8R3G3B2 ||
        eTextureFormat == D3DFMT_DXT5;
 
    if ( a_pShader->IsA( &TGetClass( ASkinShader ) ) )
    {
        ASkinShaderHAL* pShader   = TDYNAMICCAST( ASkinShaderHAL, a_pShader );
        ASkinMaterial*  pMaterial = pShader->CreateMaterial( TNULL );
        pMaterial->Create( bIsAlpha ? 1 : 0 );
        pMaterial->SetTexture( pTexture );
 
        pResultMaterial = pMaterial;
    }
    else if ( a_pShader->IsA( &TGetClass( AWorldShader ) ) )
    {
        AWorldShaderHAL* pShader   = TDYNAMICCAST( AWorldShaderHAL, a_pShader );
        AWorldMaterial*  pMaterial = pShader->CreateMaterial( TNULL );
        pMaterial->Create( bIsAlpha ? 1 : 0 );
        pMaterial->SetTexture( 0, pTexture );
        pMaterial->SetTextureNum( 1 );
 
        pResultMaterial = pMaterial;
 
        TTODO( "Setup material using properties" );
    }
    else if ( a_pShader->IsA( &TGetClass( AGrassShader ) ) )
    {
        AGrassShaderHAL* pShader   = TDYNAMICCAST( AGrassShaderHAL, a_pShader );
        AGrassMaterial*  pMaterial = pShader->CreateMaterial( TNULL );
        pMaterial->Create( 0 );
        pMaterial->SetTexture( 0, pTexture );
        pMaterial->SetTextureNum( 1 );
 
        pResultMaterial = pMaterial;
    }
    else
    {
        TASSERT( !"Support other shaders" );
    }
 
    MaterialApplyFlags( pResultMaterial, a_szMaterialName );
    MaterialApplyClamp( pResultMaterial, a_szMaterialName, pTexture );
    MaterialApplyAlphaRef( pResultMaterial, a_szMaterialName, pTexture );
 
    TASSERT( !ms_oFreeMaterials.IsEmpty() );
    auto pMatNode       = ms_oFreeMaterials.PopFront();
    pMatNode->pMaterial = pResultMaterial;
    pMatNode->iNumRefs  = 1;
 
    TStringManager::String8Copy( pMatNode->szTextureName, szTextureName, TARRAYSIZE( pMatNode->szTextureName ) );
    TStringManager::String8Copy( pMatNode->szName, materialName, TARRAYSIZE( pMatNode->szName ) );
 
    // Truncate material name so it fits the limit
    if ( materialName.Length() > TMaterial::NAMESIZELIMIT )
    {
        materialName[ TMaterial::NAMESIZELIMIT ] = '\0';
    }
 
    pResultMaterial->SetName( materialName );
    ms_oUsedMaterials.PushFront( pMatNode );
 
    AddMaterial( materialName, pMatNode );
    return pResultMaterial;
}

DestroyMaterial()

void AModelLoader::DestroyMaterial ( Toshi::TMaterial * a_pMaterial )

static

Definition at line 305 of file AModelLoader.cpp.

{
    TPROFILER_SCOPE();
 
    TINT   iId = 0;
    TINT16 iIndex;
 
    if ( 0 < ms_iNumCreatedMaterials )
    {
        while ( true )
        {
            iIndex = ms_oMaterialIds[ iId ];
            if ( a_pMaterial == ms_oNodesAlloc[ iIndex ].pMaterial ) break;
 
            if ( ms_iNumCreatedMaterials <= ++iId )
            {
                TASSERT( !"Trying to destroy some unknown material" );
                return;
            }
        }
 
        ms_oNodesAlloc[ iIndex ].iNumRefs -= 1;
 
        if ( ms_oNodesAlloc[ iIndex ].iNumRefs < 1 )
        {
            ms_oNodesAlloc[ iIndex ].Remove();
            ms_oNodesAlloc[ iIndex ].pMaterial->Destroy();
            ms_oNodesAlloc[ iIndex ].pMaterial = TNULL;
 
            ms_oFreeMaterials.PushFront( &ms_oNodesAlloc[ iIndex ] );
            ms_iNumCreatedMaterials -= 1;
 
            if ( iId < ms_iNumCreatedMaterials )
            {
                TINT16* pNext = ms_oMaterialIds + iId + 1;
                TINT16* pCurr = ms_oMaterialIds + iId;
 
                for ( TINT i = ms_iNumCreatedMaterials - iId; i != 0; i-- )
                {
                    *( pCurr++ ) = *( pNext++ );
                }
            }
        }
    }
}

InitialiseStatic()

void AModelLoader::InitialiseStatic ( )

static

Definition at line 351 of file AModelLoader.cpp.

{
    InitialiseGrassLayersTextures();
}

TDECLARE_CLASS()

AModelLoader::TDECLARE_CLASS	(	AModelLoader	,
		Toshi::TObject	)

Friends And Related Symbol Documentation

AModelInstance

friend class AModelInstance

friend

Definition at line 49 of file AModelLoader.h.

Member Data Documentation

MAX_NUM_ALLOCATED_MATERIALS

TUINT AModelLoader::MAX_NUM_ALLOCATED_MATERIALS = 512

staticconstexpr

Definition at line 46 of file AModelLoader.h.

MAX_NUM_MODEL_MATERIALS

TUINT AModelLoader::MAX_NUM_MODEL_MATERIALS = 150

staticconstexpr

Definition at line 47 of file AModelLoader.h.

---

The documentation for this class was generated from the following files:

• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Assets/AModelLoader.h
• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Assets/AModelLoader.cpp
• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Assets/AModelLoader_Skin.cpp
• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Assets/AModelLoader_World.cpp