ATerrainInterface Class Reference

#include <ATerrainInterface.h>

Inheritance diagram for ATerrainInterface:

Public Types
using	JobSlot = Toshi::T2SListNodeWrapper<AMainThreadJob>
using	t_GetCurrentVISGroup = TINT ( * )()
using	t_OnVISGroupChanged = void ( * )( ATerrainSection* a_pCurrent, ATerrainSection* a_pPrevious )
using	t_OnModelNodeReady = void ( * )( ATerrainSection::ModelNode* a_pModelNode )

Public Member Functions
	ATerrainInterface (TINT a_iUnused1, TINT a_iUnused2, TINT a_iPreloadTerrainBlockSize, TINT a_iStartVISGroup)
virtual	~ATerrainInterface ()
void	Update ()
void	Render ()
TBOOL	IsLoaded () const
void	LoadFromFile (const TCHAR *a_szFilePath, TBOOL a_bLoadLater, TBOOL a_bStreamCollision)
	Loads information about terrain.
void	WaitUntilLoaded ()
void	DestroyModelData (ATerrainSection::ModelNode *a_pModelData)
void	UpdateUsedBlocks (ATerrainLODType a_eLODType)
	Sets visible blocks of specified LOD type to be used.
void	QueueStreamingAssets ()
void	UnqueueStreamingAssets ()
TBOOL	HasAnyLODsQueued ()
void	CancelUnrequiredJobs ()
ATerrainSection::ModelNode *	CreateModelInstance (ATerrainSection::ModelNode *a_pModelNode, const char *a_szModelName, const char *a_szType)
ATerrainLODBlock *	AllocateLODBlock (ATerrainLODType a_eLODType, ATerrainSection *a_pVISGroup)
	Allocates free LODBlock of specified type and assigns it to the section.
TBOOL	IsCollisionStreamed () const
ATerrainVIS *	GetVIS () const
void	GetLocatorTransform (const TCHAR *a_pszLocatorName, Toshi::TMatrix44 &a_rOutTransform)
	Finds a locator (bone) by the specified name and obtains it current transform if found.
Toshi::TVector4	GetLocatorPos (const TCHAR *a_pszLocatorName)
	Finds a locator (bone) by the specified name and obtains it current position if found.
void	GetLocatorPosAndRot (const TCHAR *a_pszLocatorName, Toshi::TVector4 &a_rOutPosition, Toshi::TQuaternion &a_rOutRotation)
	Finds a locator (bone) by the specified name and obtains it current position and rotation if found.
ATerrainLocator *	FindLocator (const TCHAR *a_pszLocatorName)
	Finds a locator (bone) by the specified name and returns it if found.
ATRBLoaderJob *	GetFreeTRBLoaderJob ()
ASkeletonDoneJob *	GetFreeSkeletonLoaderJob ()
AMatLibLoaderJob *	GetFreeMatlibLoaderJob ()
ACollisionDoneJob *	GetFreeCollisionLoaderJob ()
AModelLoaderJob *	GetFreeModelLoaderJob ()
ASectionDoneJob *	GetFreeSectionLoaderJob ()
ATerrainLocatorList *	GetLocatorList () const
const Toshi::TVector4 &	GetDefaultShadowColor () const
const Toshi::TVector4 &	GetDefaultAmbientColor () const
const Toshi::TVector4 &	GetLitShadowColor () const
const Toshi::TVector4 &	GetLitAmbientColor () const
t_OnModelNodeReady	GetOnModelNodeReadyCallback () const

Public Attributes
friend	ATerrainVIS

Static Public Attributes
static constexpr TUINT	MAX_NUM_MODEL_LOADER_JOBS = 128
static constexpr TUINT	MAX_NUM_MATLIB_LOADER_JOBS = 10
static constexpr TUINT	MAX_NUM_KEYLIB_LOADER_JOBS = 10
static constexpr TUINT	MAX_NUM_SECTION_LOADER_JOBS = 32
static constexpr TUINT	MAX_NUM_TRB_LOADER_JOBS = 2
static constexpr TUINT	MAX_NUM_SKELETON_LOADER_JOBS = 2
static constexpr TUINT	MAX_NUM_COLLISION_LOADER_JOBS = 64
static constexpr TUINT	NUM_TOTAL_JOBS

Friends
class	ABYardTerrainManager

Detailed Description

Definition at line 10 of file ATerrainInterface.h.

Member Typedef Documentation

JobSlot

using ATerrainInterface::JobSlot = Toshi::T2SListNodeWrapper<AMainThreadJob>

Definition at line 29 of file ATerrainInterface.h.

t_GetCurrentVISGroup

using ATerrainInterface::t_GetCurrentVISGroup = TINT ( * )()

Definition at line 34 of file ATerrainInterface.h.

t_OnModelNodeReady

using ATerrainInterface::t_OnModelNodeReady = void ( * )( ATerrainSection::ModelNode* a_pModelNode )

Definition at line 36 of file ATerrainInterface.h.

t_OnVISGroupChanged

using ATerrainInterface::t_OnVISGroupChanged = void ( * )( ATerrainSection* a_pCurrent, ATerrainSection* a_pPrevious )

Definition at line 35 of file ATerrainInterface.h.

Constructor & Destructor Documentation

ATerrainInterface()

ATerrainInterface::ATerrainInterface	(	TINT	a_iUnused1,
		TINT	a_iUnused2,
		TINT	a_iPreloadTerrainBlockSize,
		TINT	a_iStartVISGroup )

Definition at line 23 of file ATerrainInterface.cpp.

{
    m_bIsLoaded                = TTRUE;
    m_pTerrainVIS              = TNULL;
    m_iNumChunks               = 16;
    m_iPreloadTerrainBlockSize = a_iPreloadTerrainBlockSize;
 
    m_pJobs       = new JobSlot[ NUM_TOTAL_JOBS ];
    auto pJobSlot = &m_pJobs[ 0 ];
 
    for ( TUINT i = 0; i < MAX_NUM_MODEL_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aModelLoaderJobs[ i ] );
        m_FreeModelLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_KEYLIB_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aKeylibLoaderJobs[ i ] );
        m_FreeKeylibLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_MATLIB_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aMatlibLoaderJobs[ i ] );
        m_FreeMatlibLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_SECTION_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aSectionDoneJobs[ i ] );
        m_FreeSectionLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_TRB_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aTRBLoaderJobs[ i ] );
        m_FreeTRBLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_SKELETON_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aSkeletonDoneJobs[ i ] );
        m_FreeSkeletonLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    for ( TUINT i = 0; i < MAX_NUM_COLLISION_LOADER_JOBS; i++ )
    {
        pJobSlot->SetNodeValue( &m_aCollisionDoneJobs[ i ] );
        m_FreeCollisionLoaderJobs.PushFront( pJobSlot );
        pJobSlot++;
    }
 
    TTODO( "Call FUN_00619040() and initialise some other values" );
    m_iCurrentSection  = a_iStartVISGroup;
    m_iPreviousSection = -1;
    m_bUnused4         = TFALSE;
    // ...
    m_fUnused3                = 0.0f;
    m_cbOnCollsionModelLoaded = TNULL;
    m_cbOnModelLoaded         = TNULL;
    m_cbOnVISGroupChanged     = TNULL;
    m_fnGetCurrentVISGroup    = GetCurrentSectionID;
}

~ATerrainInterface()

ATerrainInterface::~ATerrainInterface ( )

virtual

Definition at line 94 of file ATerrainInterface.cpp.

{
    TIMPLEMENT();
    m_bIsLoaded = TFALSE;
 
    m_UsedModelLoaderJobs.Clear();
    m_FreeModelLoaderJobs.Clear();
    m_UsedUnknownLoaderJobs.Clear();
    m_FreeUnknownLoaderJobs.Clear();
    m_UsedSectionLoaderJobs.Clear();
    m_FreeSectionLoaderJobs.Clear();
    m_UsedKeylibLoaderJobs.Clear();
    m_FreeKeylibLoaderJobs.Clear();
    m_UsedMatlibLoaderJobs.Clear();
    m_FreeMatlibLoaderJobs.Clear();
    m_UsedTRBLoaderJobs.Clear();
    m_FreeTRBLoaderJobs.Clear();
    m_UsedSkeletonLoaderJobs.Clear();
    m_FreeSkeletonLoaderJobs.Clear();
    m_UsedCollisionLoaderJobs.Clear();
    m_FreeCollisionLoaderJobs.Clear();
 
    delete[] m_pJobs;
}

Member Function Documentation

AllocateLODBlock()

ATerrainLODBlock * ATerrainInterface::AllocateLODBlock	(	ATerrainLODType	a_eLODType,
		ATerrainSection *	a_pVISGroup )

Allocates free LODBlock of specified type and assigns it to the section.

Parameters

a_eLODType	type of the block you want to allocate
a_pVISGroup	section you allocate the block for

Returns

allocated block

Definition at line 599 of file ATerrainInterface.cpp.

{
    TINT               iNumBlocks;
    ATerrainLODBlock** ppBlocks;
 
    if ( a_eLODType == ATerrainLODType_High )
    {
        iNumBlocks = m_pTerrainVIS->m_iNumHighBlocks;
        ppBlocks   = m_pTerrainVIS->m_ppHighBlocks;
    }
    else
    {
        iNumBlocks = m_pTerrainVIS->m_iNumLowBlocks;
        ppBlocks   = m_pTerrainVIS->m_ppLowBlocks;
    }
 
    TFLOAT fMinAccessTime  = TMath::MAXFLOAT;
    TINT   iPrevFoundIndex = -1;
    TINT   iFoundIndex;
 
    for ( TINT i = 0; i < iNumBlocks; i++ )
    {
        auto pBlock = ppBlocks[ i ];
        iFoundIndex = iPrevFoundIndex;
 
        if ( !pBlock->IsUsed() )
        {
            iFoundIndex = i;
            if ( pBlock->m_pVISGroup == TNULL ) break;
 
            iFoundIndex = iPrevFoundIndex;
            if ( !pBlock->m_pVISGroup->IsLODLoading( a_eLODType ) )
            {
                iFoundIndex = i;
                if ( pBlock->m_pVISGroup = TNULL ) break;
 
                iFoundIndex = iPrevFoundIndex;
                if ( pBlock->m_fLastAccessTime < fMinAccessTime )
                {
                    fMinAccessTime = pBlock->m_fLastAccessTime;
                    iFoundIndex    = i;
                }
            }
        }
 
        iPrevFoundIndex = iFoundIndex;
    }
 
    if ( iFoundIndex >= 0 )
    {
        auto pBlock    = ppBlocks[ iFoundIndex ];
        auto pVISGroup = pBlock->m_pVISGroup;
 
        if ( pVISGroup )
        {
            if ( pVISGroup->IsLODEmpty( pBlock->m_eLODType ) )
            {
                pVISGroup->SetLODEmpty( pBlock->m_eLODType, TFALSE );
                return TNULL;
            }
 
            if ( pVISGroup )
            {
                if ( ( pVISGroup->m_eFlags & ( 21 << a_eLODType ) ) != 0 )
                {
                    if ( pVISGroup->IsMatLibLoaded( pBlock->m_eLODType ) )
                    {
                        pVISGroup->SetLODEmpty( pBlock->m_eLODType, TFALSE );
 
                        if ( pBlock->m_pVISGroup )
                        {
                            pBlock->m_pVISGroup->UnloadMatlib( pBlock->m_eLODType );
                        }
                    }
                    else if ( pBlock->m_pVISGroup )
                    {
                        pBlock->m_pVISGroup->DestroyLOD( pBlock->m_eLODType );
                    }
 
                    return TNULL;
                }
 
                if ( pVISGroup )
                {
                    pVISGroup->DestroyLOD( pBlock->m_eLODType );
                }
            }
        }
 
        pBlock->Assign( a_pVISGroup, a_eLODType );
        return pBlock;
    }
 
    return TNULL;
}

CancelUnrequiredJobs()

void ATerrainInterface::CancelUnrequiredJobs

(

)

Definition at line 1075 of file ATerrainInterface.cpp.

{
    if ( m_iCurrentSection != m_iPreviousSection && m_iPreviousSection >= 0 )
    {
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            auto pGroup = &m_pTerrainVIS->m_pSections[ i ];
 
            if ( pGroup->m_eFlags & ( ATerrainSection::FLAGS_HIGH_LOD_LOADING | ATerrainSection::FLAGS_LOW_LOD_LOADING ) )
            {
                if ( i < 0 ) return;
                if ( pGroup->m_pVisibility[ i ] == ( ( pGroup->m_eFlags >> 2 ) - 1 ) % ATerrainLODType_NUMOF ) return;
                if ( i == m_iCurrentSection ) return;
 
                AAssetStreaming::GetSingleton()->CancelAllJobs();
                return;
            }
        }
    }
}

CreateModelInstance()

ATerrainSection::ModelNode * ATerrainInterface::CreateModelInstance	(	ATerrainSection::ModelNode *	a_pModelNode,
		const char *	a_szModelName,
		const char *	a_szType )

Definition at line 992 of file ATerrainInterface.cpp.

{
    // Make sure model is created
    auto pModel = a_pModelNode->m_ModelRef.GetModel();
    if ( !pModel || !pModel->IsCreated() )
    {
        a_pModelNode->m_ModelRef.Create(
            a_szModelName,
            AAssetLoader::GetAssetTRB( AAssetType_AssetPack )
        );
    }
 
    auto pInstance          = a_pModelNode->m_ModelRef.CreateSceneObject();
    auto pInstanceTransform = &pInstance->GetTransform();
 
    pInstanceTransform->SetEuler( TVector3( 1.570796f, 0.0f, 0.0f ) );
    pInstanceTransform->SetTranslate( TVector3::VEC_ZERO );
 
    TMatrix44 collisionLocalMatrix;
    pInstanceTransform->GetLocalMatrixImp( collisionLocalMatrix );
    pInstanceTransform->SetMatrix( collisionLocalMatrix );
 
    a_pModelNode->m_pSceneObject = pInstance;
 
    pInstance->GetSomeVector1().x = 1.0f;
    pInstance->GetSomeVector1().y = 1.0f;
    pInstance->GetSomeVector2().x = 10000000.0f;
    pInstance->GetSomeVector2().y = 10000001.0f;
    pInstance->EnableSkeletonUpdate();
    pInstance->EnableUnknown1();
 
    TTODO( "Create collision model set" );
 
    auto pModelInstance = pInstance->GetInstance();
    pModel              = pModelInstance->GetModel();
 
    auto pWorldDatabase = pModel->CastSymbol<WorldDatabase>( "Database" );
 
    if ( TNULL == pWorldDatabase )
    {
        // Render as a simple model
        pModelInstance->SetPreRenderCallback( RenderWorldWin );
    }
    else
    {
        // Render WorldVIS
        auto& rLOD = pModel->GetLOD( 0 );
 
        if ( rLOD.iNumMeshes < 1 )
        {
            // Nothing to render here
            pModelInstance->SetPreRenderCallback( RenderNothing );
        }
        else
        {
            pModelInstance->SetCustomRenderMethod( RenderWorldVisWin, a_pModelNode );
            a_pModelNode->m_WorldVis.Create( pWorldDatabase->m_ppWorlds[ 0 ] );
 
            TBOOL bIsWorldMesh = rLOD.ppMeshes[ 0 ]->IsA( &TGetClass( AWorldMesh ) );
 
            if ( bIsWorldMesh )
            {
                a_pModelNode->m_WorldVis.m_pfnRenderCallback = RenderCellMeshDefault;
                TTODO( "Setup materials" );
            }
            else
            {
                a_pModelNode->m_WorldVis.m_pfnRenderCallback = RenderCellMeshDefault;
            }
        }
    }
 
    if ( TNULL != a_szType )
    {
        TASSERT( TStringManager::String8Length( a_szType ) <= ATerrainSection::ModelNode::TYPE_NAME_MAX_SIZE );
        TStringManager::String8Copy( a_pModelNode->m_szType, a_szType, ATerrainSection::ModelNode::TYPE_NAME_MAX_SIZE );
    }
 
    m_llModelNodes.PushBack( a_pModelNode );
    a_pModelNode->m_bCreated = TTRUE;
    return a_pModelNode;
}

DestroyModelData()

void ATerrainInterface::DestroyModelData

(

ATerrainSection::ModelNode *

a_pModelData

)

Definition at line 488 of file ATerrainInterface.cpp.

{
    TVALIDPTR( a_pModelData );
 
    if ( a_pModelData->IsLinked() )
    {
        m_llModelNodes.Erase( a_pModelData );
    }
 
    if ( a_pModelData )
    {
        delete a_pModelData;
    }
}

FindLocator()

ATerrainLocator * ATerrainInterface::FindLocator

(

const TCHAR *

a_pszLocatorName

)

Finds a locator (bone) by the specified name and returns it if found.

Definition at line 757 of file ATerrainInterface.cpp.

{
    if ( !m_pTerrainVIS )
        return TNULL;
 
    return GetLocatorList()->FindLocator( a_pszLocatorName );
}

GetDefaultAmbientColor()

const Toshi::TVector4 & ATerrainInterface::GetDefaultAmbientColor ( ) const

inline

Definition at line 140 of file ATerrainInterface.h.

{ return m_DefaultAmbientColor; }

GetDefaultShadowColor()

const Toshi::TVector4 & ATerrainInterface::GetDefaultShadowColor ( ) const

inline

Definition at line 139 of file ATerrainInterface.h.

{ return m_DefaultShadowColor; }

GetFreeCollisionLoaderJob()

ACollisionDoneJob * ATerrainInterface::GetFreeCollisionLoaderJob

(

)

Definition at line 816 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeCollisionLoaderJobs.Size() > 0, "No free ACollisionDoneJob left!" );
 
    if ( m_FreeCollisionLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeCollisionLoaderJobs.PopFront();
        m_UsedCollisionLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( ACollisionDoneJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetFreeMatlibLoaderJob()

AMatLibLoaderJob * ATerrainInterface::GetFreeMatlibLoaderJob

(

)

Definition at line 799 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeMatlibLoaderJobs.Size() > 0, "No free AMatlibLoaderJobs left!" );
 
    if ( m_FreeMatlibLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeMatlibLoaderJobs.PopFront();
        m_UsedMatlibLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( AMatLibLoaderJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetFreeModelLoaderJob()

AModelLoaderJob * ATerrainInterface::GetFreeModelLoaderJob

(

)

Definition at line 833 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeModelLoaderJobs.Size() > 0, "No free AModelLoaderJob left!" );
 
    if ( m_FreeModelLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeModelLoaderJobs.PopFront();
        m_UsedModelLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( AModelLoaderJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetFreeSectionLoaderJob()

ASectionDoneJob * ATerrainInterface::GetFreeSectionLoaderJob

(

)

Definition at line 850 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeSectionLoaderJobs.Size() > 0, "No free ASectionDoneJob left!" );
 
    if ( m_FreeSectionLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeSectionLoaderJobs.PopFront();
        m_UsedSectionLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( ASectionDoneJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetFreeSkeletonLoaderJob()

ASkeletonDoneJob * ATerrainInterface::GetFreeSkeletonLoaderJob

(

)

Definition at line 782 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeSkeletonLoaderJobs.Size() > 0, "No free ASkeletonDoneJobs left!" );
 
    if ( m_FreeSkeletonLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeSkeletonLoaderJobs.PopFront();
        m_UsedSkeletonLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( ASkeletonDoneJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetFreeTRBLoaderJob()

ATRBLoaderJob * ATerrainInterface::GetFreeTRBLoaderJob

(

)

Definition at line 765 of file ATerrainInterface.cpp.

{
    TASSERT( m_FreeTRBLoaderJobs.Size() > 0, "No free ATRBLoaderJobs left!" );
 
    if ( m_FreeTRBLoaderJobs.Size() > 0 )
    {
        auto pTRBJobSlot = m_FreeTRBLoaderJobs.PopFront();
        m_UsedTRBLoaderJobs.PushFront( pTRBJobSlot );
 
        return TSTATICCAST( ATRBLoaderJob, pTRBJobSlot->GetNodeValue() );
    }
    else
    {
        return TNULL;
    }
}

GetLitAmbientColor()

const Toshi::TVector4 & ATerrainInterface::GetLitAmbientColor ( ) const

inline

Definition at line 142 of file ATerrainInterface.h.

{ return m_LitAmbientColor; }

GetLitShadowColor()

const Toshi::TVector4 & ATerrainInterface::GetLitShadowColor ( ) const

inline

Definition at line 141 of file ATerrainInterface.h.

{ return m_LitShadowColor; }

GetLocatorList()

ATerrainLocatorList * ATerrainInterface::GetLocatorList ( ) const

inline

Definition at line 133 of file ATerrainInterface.h.

    {
        TVALIDPTR( m_pTerrainVIS );
        return m_pTerrainVIS->GetLocatorList();
    }

GetLocatorPos()

TVector4 ATerrainInterface::GetLocatorPos

(

const TCHAR *

a_pszLocatorName

)

Finds a locator (bone) by the specified name and obtains it current position if found.

Definition at line 715 of file ATerrainInterface.cpp.

{
    ATerrainLocatorList* pLocatorManager = GetLocatorList();
 
    ATerrainLocator* pLocator = pLocatorManager->FindLocator( a_pszLocatorName );
    TASSERT( pLocator != TNULL );
 
    // Get transform of the locator
    TMatrix44 matLocator;
    pLocator->GetMatrix( matLocator );
 
    // Get locators global transform and transform the locator
    TMatrix44 matTransformed;
    pLocatorManager->GetWorldTransform().GetLocalMatrixImp( matTransformed );
    matTransformed.Multiply( matLocator );
 
    return matTransformed.AsBasisVector4( BASISVECTOR_TRANSLATION );
}

GetLocatorPosAndRot()

void ATerrainInterface::GetLocatorPosAndRot	(	const TCHAR *	a_pszLocatorName,
		Toshi::TVector4 &	a_rOutPosition,
		Toshi::TQuaternion &	a_rOutRotation )

Finds a locator (bone) by the specified name and obtains it current position and rotation if found.

Definition at line 735 of file ATerrainInterface.cpp.

{
    ATerrainLocatorList* pLocatorManager = GetLocatorList();
 
    ATerrainLocator* pLocator = pLocatorManager->FindLocator( a_pszLocatorName );
    TASSERT( pLocator != TNULL );
 
    // Get transform of the locator
    TMatrix44 matLocator;
    pLocator->GetMatrix( matLocator );
 
    // Get locators global transform and transform the locator
    TMatrix44 matTransformed;
    pLocatorManager->GetWorldTransform().GetLocalMatrixImp( matTransformed );
    matTransformed.Multiply( matLocator );
 
    TVector3& vecUp = matTransformed.AsBasisVector3( BASISVECTOR_UP );
    a_rOutRotation  = TQuaternion( -vecUp.x, -vecUp.y, -vecUp.z, 1.0f );
    a_rOutPosition  = matTransformed.AsBasisVector4( BASISVECTOR_TRANSLATION );
}

GetLocatorTransform()

void ATerrainInterface::GetLocatorTransform	(	const TCHAR *	a_pszLocatorName,
		Toshi::TMatrix44 &	a_rOutTransform )

Finds a locator (bone) by the specified name and obtains it current transform if found.

Definition at line 696 of file ATerrainInterface.cpp.

{
    ATerrainLocatorList* pLocatorManager = GetLocatorList();
 
    ATerrainLocator* pLocator = pLocatorManager->FindLocator( a_pszLocatorName );
    TASSERT( pLocator != TNULL );
 
    // Get transform of the locator
    TMatrix44 matLocator;
    pLocator->GetMatrix( matLocator );
 
    // Get locators global transform
    pLocatorManager->GetWorldTransform().GetLocalMatrixImp( a_rOutTransform );
 
    // Transform locator by the global transform
    a_rOutTransform.Multiply( matLocator );
}

GetOnModelNodeReadyCallback()

t_OnModelNodeReady ATerrainInterface::GetOnModelNodeReadyCallback ( ) const

inline

Definition at line 144 of file ATerrainInterface.h.

{ return m_cbOnModelLoaded; }

GetVIS()

ATerrainVIS * ATerrainInterface::GetVIS ( ) const

inline

Returns

visibility data of the currently loaded terrain

Definition at line 104 of file ATerrainInterface.h.

{ return m_pTerrainVIS; }

HasAnyLODsQueued()

TBOOL ATerrainInterface::HasAnyLODsQueued

(

)

Returns

TTRUE if any LODs are planned to be loaded

Definition at line 584 of file ATerrainInterface.cpp.

{
    for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
    {
        auto pGroup = &m_pTerrainVIS->m_pSections[ i ];
 
        if ( pGroup->m_eFlags & ( ATerrainSection::FLAGS_HIGH_LOD_QUEUED | ATerrainSection::FLAGS_LOW_LOD_QUEUED ) )
        {
            return TTRUE;
        }
    }
 
    return TFALSE;
}

IsCollisionStreamed()

TBOOL ATerrainInterface::IsCollisionStreamed ( ) const

inline

Returns

TTRUE if collision is not preloaded

Definition at line 99 of file ATerrainInterface.h.

{ return m_bStreamCollision; }

IsLoaded()

TBOOL ATerrainInterface::IsLoaded

(

)

const

Definition at line 328 of file ATerrainInterface.cpp.

{
    if ( m_pTerrainVIS == TNULL )
    {
        return TTRUE;
    }
 
    if ( m_pTerrainVIS->GetLocatorList() && m_pTerrainVIS->GetLocatorList()->GetTRB() )
    {
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            if ( HASANYFLAG( m_pTerrainVIS->m_pSections[ i ].m_eFlags, 0xF3C ) )
            {
                return TFALSE;
            }
        }
 
        return TTRUE;
    }
 
    return TFALSE;
}

LoadFromFile()

void ATerrainInterface::LoadFromFile	(	const TCHAR *	a_szFilePath,
		TBOOL	a_bLoadLater,
		TBOOL	a_bStreamCollision )

Loads information about terrain.

Parameters

a_szFilePath	path to the terrain info file
a_bLoadLater	if TFALSE, doesn't pause thread to load all resources
a_bPreloadCollision	if TFALSE, loads all collision objects at once

Definition at line 351 of file ATerrainInterface.cpp.

{
    TFIXME( "Do something with ATerrainSectionHudElement" );
 
    m_bIsLoaded = TFALSE;
 
    m_VISTRB.Close();
    m_VISTRB.Load( a_szFilePath, 0 );
 
    m_pTerrainVIS = m_VISTRB.CastSymbol<ATerrainVIS>( "terrainvis" );
    m_pOrderDVIS  = m_VISTRB.CastSymbol<ATerrainOrderDVIS>( "orderdvis" );
 
    if ( m_VISTRB.GetSymbolAddress( "preloadcollision" ) )
    {
        // We won't stream collision models if there's any preload collision
        a_bStreamCollision         = TFALSE;
        m_iPreloadTerrainBlockSize = m_pTerrainVIS->m_uiPersistantTerrainBlockSize;
    }
 
    m_VISTRB.DeleteSymbolTable();
 
    if ( !a_bStreamCollision )
    {
        m_pTerrainVIS->m_uiPersistantTerrainBlockSize = m_iPreloadTerrainBlockSize;
    }
 
    if ( m_pTerrainVIS->m_uiPersistantTerrainBlockSize > 0 )
    {
        m_pTerrainVIS->m_pPersistantTerrainBlock = new ATerrainLODBlock(
            m_pTerrainVIS->m_uiPersistantTerrainBlockSize,
            "Terrain_Persistant"
        );
    }
 
    // Create HighLOD blocks
    if ( m_pTerrainVIS->m_iNumHighBlocks > 0 )
    {
        m_pTerrainVIS->m_ppHighBlocks = new ATerrainLODBlock*[ m_pTerrainVIS->m_iNumHighBlocks ];
 
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumHighBlocks; i++ )
        {
            TCHAR szBlockName[ 64 ];
            TStringManager::String8Format( szBlockName, sizeof( szBlockName ), "Terrain_HighLOD_Block%d", i );
 
            m_pTerrainVIS->m_ppHighBlocks[ i ] = new ATerrainLODBlock(
                m_pTerrainVIS->m_uiHighBlockSize,
                szBlockName
            );
        }
    }
 
    // Create LowLOD blocks
    if ( m_pTerrainVIS->m_iNumLowBlocks > 0 )
    {
        m_pTerrainVIS->m_ppLowBlocks = new ATerrainLODBlock*[ m_pTerrainVIS->m_iNumLowBlocks ];
 
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumLowBlocks; i++ )
        {
            TCHAR szBlockName[ 64 ];
            TStringManager::String8Format( szBlockName, sizeof( szBlockName ), "Terrain_LowLOD_Block%d", i );
 
            m_pTerrainVIS->m_ppLowBlocks[ i ] = new ATerrainLODBlock(
                m_pTerrainVIS->m_uiLowBlockSize,
                szBlockName
            );
        }
    }
 
    m_pTerrainVIS->LoadSkeleton();
 
    // Load global matlib if it is specified
    if ( *m_pTerrainVIS->m_szMatLibrary != '\0' )
    {
        auto pMatlibJob      = GetFreeMatlibLoaderJob();
        auto pPersitantBlock = m_pTerrainVIS->m_pPersistantTerrainBlock;
 
        auto pTRB                            = new ( pPersitantBlock->GetMemBlock() ) TTRB();
        m_pTerrainVIS->m_pMaterialLibraryTRB = pTRB;
        pPersitantBlock->SetupTRB( pTRB, pPersitantBlock );
 
        pMatlibJob->InitJob(
            m_pTerrainVIS->m_szMatLibrary,
            m_pTerrainVIS->m_pMaterialLibraryTRB,
            m_pTerrainVIS->m_pMaterialLibrary,
            pPersitantBlock->GetMemBlock()
        );
 
        AAssetStreaming::GetSingleton()->AddMainThreadJob( pMatlibJob );
    }
 
    m_bStreamCollision = a_bStreamCollision;
 
    // If collision is not streamed, create jobs to load it for every section
    if ( !a_bStreamCollision )
    {
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            m_pTerrainVIS->m_pSections[ i ].LoadCollision();
        }
    }
 
    // Wait until all assets are loaded
    if ( !a_bLoadLater )
    {
        while ( AAssetStreaming::GetSingleton()->HasActiveJobs() )
        {
            AAssetStreaming::GetSingleton()->Update();
 
#ifndef BARNYARD_COMMUNITY_PATCH
            ThreadSleep( 20 );
#endif // BARNYARD_COMMUNITY_PATCH
        }
 
        WaitUntilLoaded();
    }
 
    m_bIsLoaded = TTRUE;
}

QueueStreamingAssets()

void ATerrainInterface::QueueStreamingAssets

(

)

Definition at line 546 of file ATerrainInterface.cpp.

{
    TASSERT( m_iCurrentSection != -1 );
 
    auto pCurrentGroup = &m_pTerrainVIS->m_pSections[ m_iCurrentSection ];
 
    for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
    {
        auto eLODType = pCurrentGroup->m_pVisibility[ i ];
 
        if ( eLODType > ATerrainLODType_None )
        {
            auto pGroup = &m_pTerrainVIS->m_pSections[ i ];
 
            if ( ( pGroup->m_eFlags & ( 21 << eLODType ) ) == 0 )
            {
                pGroup->SetLODQueued( eLODType, TTRUE );
            }
        }
    }
 
    if ( !HASANYFLAG(
             pCurrentGroup->m_eFlags,
             ATerrainSection::FLAGS_HIGH_LOD_LOADED | ATerrainSection::FLAGS_HIGH_LOD_LOADING
         ) )
    {
        pCurrentGroup->SetLODQueued( ATerrainLODType_High, TTRUE );
    }
}

Render()

void ATerrainInterface::Render

(

)

Definition at line 271 of file ATerrainInterface.cpp.

{
    m_pTerrainVIS->m_pPersistantTerrainBlock->UpdateLastAccessTime();
 
    auto pRenderContext = TRenderInterface::GetSingleton()->GetCurrentContext();
    auto pCameraObject  = pRenderContext->GetCameraObject();
 
    if ( pCameraObject )
    {
        auto pWorldShader = TDYNAMICCAST( AWorldShaderHAL, AWorldShader::GetSingleton() );
 
        m_DefaultShadowColor  = pWorldShader->GetShadowColour();
        m_DefaultAmbientColor = pWorldShader->GetAmbientColour();
 
        m_LitShadowColor.x = 0.5f;
        m_LitShadowColor.y = 0.5f;
        m_LitShadowColor.z = 0.3254902f;
        m_LitShadowColor.w = 1.0f;
        m_LitShadowColor.Multiply( s_ShadowColor2Multiplier );
 
        m_LitAmbientColor = m_LitShadowColor;
        m_bUnused4        = TFALSE;
        m_fUnused3        = 1.0f;
        m_bUnused4        = TTRUE;
 
        auto pTerrainVIS = m_pTerrainVIS;
 
        if ( TNULL != pTerrainVIS )
        {
            // Reset current section if it is out of range
            if ( pTerrainVIS->m_iNumSections <= m_iCurrentSection || m_iCurrentSection < 0 )
            {
                m_iCurrentSection = 0;
            }
 
            auto pSections       = pTerrainVIS->m_pSections;
            auto iCurrentSection = m_iCurrentSection;
            auto pCurrentSection = &pSections[ iCurrentSection ];
 
            if ( TNULL == m_pOrderDVIS )
            {
                pCurrentSection->Draw( ATerrainLODType_High );
            }
 
            for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
            {
                ATerrainLODType eSectionVisibility = pCurrentSection->m_pVisibility[ i ];
 
                if ( eSectionVisibility != ATerrainLODType_None )
                {
                    pSections[ i ].Draw( eSectionVisibility );
                }
            }
        }
    }
}

UnqueueStreamingAssets()

void ATerrainInterface::UnqueueStreamingAssets

(

)

Definition at line 576 of file ATerrainInterface.cpp.

{
    for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
    {
        m_pTerrainVIS->m_pSections[ i ].RemoveFromStreamingQueue();
    }
}

Update()

void ATerrainInterface::Update

(

)

Definition at line 119 of file ATerrainInterface.cpp.

{
    if ( !m_pTerrainVIS ) return;
 
    if ( m_fnGetCurrentVISGroup )
    {
        TINT iCurrentGroup = m_fnGetCurrentVISGroup();
 
        if ( iCurrentGroup != -1 )
        {
            m_iCurrentSection = iCurrentGroup;
        }
    }
 
    if ( m_iCurrentSection >= 0 )
    {
        if ( m_iPreviousSection != m_iCurrentSection )
        {
            UpdateUsedBlocks( ATerrainLODType_High );
            UpdateUsedBlocks( ATerrainLODType_Low );
 
            UnqueueStreamingAssets();
            CancelUnrequiredJobs();
 
            if ( m_cbOnVISGroupChanged )
            {
                auto pPrevious = m_iPreviousSection >= 0 ? &m_pTerrainVIS->m_pSections[ m_iPreviousSection ] : TNULL;
                auto pCurrent  = m_iCurrentSection >= 0 ? &m_pTerrainVIS->m_pSections[ m_iCurrentSection ] : TNULL;
 
                m_cbOnVISGroupChanged( pPrevious, pCurrent );
            }
 
            m_iPreviousSection = m_iCurrentSection;
            QueueStreamingAssets();
        }
 
        if ( m_bIsLoaded && !IsLoaded() )
        {
            TFIXME( "Create and push ATerrainLoadingStallState if needed" );
        }
 
        TBOOL bSkipLoadingModels = TFALSE;
 
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            if ( m_pTerrainVIS->m_pSections[ i ].IsLODLoading( ATerrainLODType_High ) ||
                 m_pTerrainVIS->m_pSections[ i ].IsLODLoading( ATerrainLODType_Low ) )
            {
                // There are already some models loading, don't create any new jobs
                bSkipLoadingModels = TTRUE;
                break;
            }
        }
 
        if ( !bSkipLoadingModels )
        {
            if ( HasAnyLODsQueued() )
            {
                auto pGroups = m_pTerrainVIS->m_pSections;
 
                if ( m_pOrderDVIS )
                {
                    // Use precomputed order of queued groups to load
                    auto pDVIS = &m_pOrderDVIS[ m_iCurrentSection ];
 
                    for ( TINT i = 0; i < pDVIS->iCount; i++ )
                    {
                        auto uiGroupIndex = pDVIS->pInfo[ i ].uiGroupIndex;
                        auto eLODType     = pDVIS->pInfo[ i ].eLODType;
 
                        if ( pGroups[ uiGroupIndex ].IsLODQueued( eLODType ) )
                        {
                            pGroups[ uiGroupIndex ].LoadModels( eLODType );
                            break;
                        }
                    }
                }
                else
                {
                    // Brute force order of queued groups to load
                    if ( pGroups[ m_iCurrentSection ].IsLODQueued( ATerrainLODType_High ) )
                    {
                        pGroups[ m_iCurrentSection ].LoadModels( ATerrainLODType_High );
                    }
                    else
                    {
                        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
                        {
                            if ( pGroups[ i ].IsLODQueued( ATerrainLODType_High ) )
                            {
                                pGroups[ i ].LoadModels( ATerrainLODType_High );
                                break;
                            }
                            else if ( pGroups[ i ].IsLODQueued( ATerrainLODType_Low ) )
                            {
                                pGroups[ i ].LoadModels( ATerrainLODType_Low );
                                break;
                            }
                        }
                    }
                }
            }
        }
 
        TFIXME( "Restore value of m_fnGetCurrentVISGroup if it was saved" );
 
        // Wait till queued LODs are ready
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            if ( m_pTerrainVIS->m_pSections[ i ].IsLODQueued( ATerrainLODType_High ) ||
                 m_pTerrainVIS->m_pSections[ i ].IsLODQueued( ATerrainLODType_Low ) )
            {
                FlushJobs();
                return;
            }
        }
 
        // Wait till all LODs are loaded
        for ( TINT i = 0; i < m_pTerrainVIS->m_iNumSections; i++ )
        {
            if ( m_pTerrainVIS->m_pSections[ i ].IsLODLoading( ATerrainLODType_High ) ||
                 m_pTerrainVIS->m_pSections[ i ].IsLODLoading( ATerrainLODType_Low ) )
            {
                FlushJobs();
                return;
            }
        }
 
        if ( m_pOrderDVIS )
        {
            auto pDVIS = &m_pOrderDVIS[ m_iCurrentSection ];
 
            for ( TINT i = 0; i < pDVIS->iCount; i++ )
            {
                auto pInfo  = &pDVIS->pInfo[ i ];
                auto pGroup = &m_pTerrainVIS->m_pSections[ pInfo->uiGroupIndex ];
 
                if ( pGroup->IsLODLoaded( pInfo->eLODType ) && !pGroup->IsLODEmpty( pInfo->eLODType ) )
                {
                    TRenderInterface::GetSingleton()->BeginEndSceneHAL();
                    pGroup->DestroyLOD( pInfo->eLODType );
                    QueueStreamingAssets();
                }
            }
        }
    }
 
    FlushJobs();
}

UpdateUsedBlocks()

void ATerrainInterface::UpdateUsedBlocks

(

ATerrainLODType

a_eLODType

)

Sets visible blocks of specified LOD type to be used.

Parameters

a_eLODType

type of LODs to load (can be ATerrainLODType_High or ATerrainLODType_Low)

Definition at line 503 of file ATerrainInterface.cpp.

{
    TINT               iNumBlocks;
    ATerrainLODBlock** ppBlocks;
 
    if ( a_eLODType == ATerrainLODType_High )
    {
        iNumBlocks = m_pTerrainVIS->m_iNumHighBlocks;
        ppBlocks   = m_pTerrainVIS->m_ppHighBlocks;
    }
    else
    {
        iNumBlocks = m_pTerrainVIS->m_iNumLowBlocks;
        ppBlocks   = m_pTerrainVIS->m_ppLowBlocks;
    }
 
    auto pCurrentVISGroup = m_pTerrainVIS->m_pSections + m_iCurrentSection;
 
    for ( TINT i = 0; i < iNumBlocks; i++ )
    {
        auto pBlock = ppBlocks[ i ];
        pBlock->SetUnused();
 
        if ( a_eLODType == ATerrainLODType_High && pBlock->m_pVISGroup == pCurrentVISGroup )
        {
            pBlock->SetUsed();
        }
        else
        {
            auto pVIS = m_pTerrainVIS;
 
            for ( TINT k = 0; k < pVIS->m_iNumSections; k++ )
            {
                if ( pCurrentVISGroup->m_pVisibility[ k ] == a_eLODType &&
                     pBlock->m_pVISGroup == &pVIS->m_pSections[ k ] )
                {
                    pBlock->SetUsed();
                }
            }
        }
    }
}

WaitUntilLoaded()

void ATerrainInterface::WaitUntilLoaded

(

)

Definition at line 470 of file ATerrainInterface.cpp.

{
    TPROFILER_SCOPE();
 
    while ( TTRUE )
    {
        Update();
 
        if ( IsLoaded() ) return;
        TRenderInterface::GetSingleton()->Update( 1.0f / 1000.0f );
        AAssetStreaming::GetSingleton()->Update();
 
#ifndef BARNYARD_COMMUNITY_PATCH
        ThreadSleep( 20 );
#endif // BARNYARD_COMMUNITY_PATCH
    }
}

Friends And Related Symbol Documentation

ABYardTerrainManager

friend class ABYardTerrainManager

friend

Definition at line 32 of file ATerrainInterface.h.

Member Data Documentation

ATerrainVIS

friend ATerrainInterface::ATerrainVIS

Definition at line 31 of file ATerrainInterface.h.

MAX_NUM_COLLISION_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_COLLISION_LOADER_JOBS = 64

staticconstexpr

Definition at line 19 of file ATerrainInterface.h.

MAX_NUM_KEYLIB_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_KEYLIB_LOADER_JOBS = 10

staticconstexpr

Definition at line 15 of file ATerrainInterface.h.

MAX_NUM_MATLIB_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_MATLIB_LOADER_JOBS = 10

staticconstexpr

Definition at line 14 of file ATerrainInterface.h.

MAX_NUM_MODEL_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_MODEL_LOADER_JOBS = 128

staticconstexpr

Definition at line 13 of file ATerrainInterface.h.

MAX_NUM_SECTION_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_SECTION_LOADER_JOBS = 32

staticconstexpr

Definition at line 16 of file ATerrainInterface.h.

MAX_NUM_SKELETON_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_SKELETON_LOADER_JOBS = 2

staticconstexpr

Definition at line 18 of file ATerrainInterface.h.

MAX_NUM_TRB_LOADER_JOBS

TUINT ATerrainInterface::MAX_NUM_TRB_LOADER_JOBS = 2

staticconstexpr

Definition at line 17 of file ATerrainInterface.h.

NUM_TOTAL_JOBS

TUINT ATerrainInterface::NUM_TOTAL_JOBS

staticconstexpr

Initial value:

=
        MAX_NUM_MODEL_LOADER_JOBS +
        MAX_NUM_MATLIB_LOADER_JOBS +
        MAX_NUM_KEYLIB_LOADER_JOBS +
        MAX_NUM_SECTION_LOADER_JOBS +
        MAX_NUM_TRB_LOADER_JOBS +
        MAX_NUM_SKELETON_LOADER_JOBS +
        MAX_NUM_COLLISION_LOADER_JOBS

Definition at line 20 of file ATerrainInterface.h.

---

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

• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Terrain/ATerrainInterface.h
• D:/_dev/OpenBarnyard/Source/OpenBarnyard/Source/Terrain/ATerrainInterface.cpp