void addBunny( std::shared_ptr<Container> container )
{
AssetLoader loader;
std::string modelPath = "models";
// bunnies
std::string bunnyPath = modelPath + "/stanford/bunny/reconstruction";
auto mesh = loader.load( bunnyPath + "/bun_zipper_res2.ply" );
//auto mesh = loader.load( bunnyPath + "/bun_zipper_res4.ply" );
if( !mesh ) {
fprintf( stderr, "Error loading mesh\n" );
return;
}
//mesh->material = std::make_shared<DiffuseMaterial>( 0.0f, 0.66, 0.42f ); // emerald green
mesh->material = std::make_shared<MirrorMaterial>();
printf("Building octree\n");
auto mesh_octree = new TMOctreeAccelerator( *std::dynamic_pointer_cast<TriangleMesh>(mesh) );
mesh_octree->build();
mesh->accelerator = mesh_octree;
mesh->transform = std::make_shared<Transform>();
*mesh->transform = makeTranslation( Vector4( 0.0, 0.2, -0.5 ) );
container->add( mesh );
}
static void paintWrapper() {
// clear the palette
newCubes.clear();
lostCubes.clear();
reconnectedCubes.clear();
dirtyCubes.clear();
// fire events
System::paint();
// dynamically load assets just-in-time
if (!(newCubes | reconnectedCubes).empty()) {
loader.start(config);
while(!loader.isComplete()) {
for(CubeID cid : (newCubes | reconnectedCubes)) {
vbuf[cid].bg0rom.hBargraph(
vec(0, 4), loader.cubeProgress(cid, 128), BG0ROMDrawable::ORANGE, 8
);
}
// fire events while we wait
System::paint();
}
loader.finish();
}
// repaint cubes
for(CubeID cid : dirtyCubes) {
activateCube(cid, taskCubes[cid].task);
}
// also, handle lost cubes, if you so desire :)
}
inline void doAssetLoadTests(size_t &passCounter, size_t &failCounter)
{
AssetLoader loader;
int length = 0;
char *data = nullptr;
std::cout << "Loading the readme" << std::endl;
size_t loopCount = 0;
while(true) {
data = loader.requestData("README.org", 100, &length);
if(data) {
break;
}
// Show a progress bar thingy.
if(loopCount % 70 == 0 && loopCount) {
std::cout << std::endl;
}
std::cout << ".oO0Oo"[loopCount % 6];
loopCount++;
}
std::cout << std::endl;
EXPOP_TEST_VALUE(!!data, true);
EXPOP_TEST_VALUE(std::string(data, length), FileSystem::loadFileString("README.org"));
}
void onConnect(void *x, unsigned int cube)
{
loader.start(assetConfig);
loader.finish();
auto &vid = gVideo[cube];
vid.initMode(BG0);
vid.attach(cube);
vid.bg0.erase(StripeTile);
}
void Sound::initFile(const std::string &name) {
SLresult result;
std::string filename = name + ".mp3";
// use asset manager to open asset by filename
AssetLoader *loader = AssetLoader::instance();
AAsset *asset = loader->open(filename);
// the asset might not be found
if (NULL == asset) {
LOGI("Asset not found: %s", name.c_str());
return;
}
// open asset as file descriptor
off_t start, length;
int fd = AAsset_openFileDescriptor(asset, &start, &length);
assert(0 <= fd);
AAsset_close(asset);
// configure audio source
SLDataLocator_AndroidFD loc_fd = {SL_DATALOCATOR_ANDROIDFD, fd, start, length};
SLDataFormat_MIME format_mime = {SL_DATAFORMAT_MIME, NULL, SL_CONTAINERTYPE_UNSPECIFIED};
SLDataSource audioSrc = {&loc_fd, &format_mime};
// configure audio sink
SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, pd->outputMixObject};
SLDataSink audioSnk = {&loc_outmix, NULL};
// create audio player
PrivateImplData::SoundPlayer soundPlayer;
const SLInterfaceID ids[1] = {SL_IID_SEEK};
const SLboolean req[1] = {SL_BOOLEAN_TRUE};
result = (*pd->engineEngine)->CreateAudioPlayer(pd->engineEngine, &soundPlayer.fdPlayerObject, &audioSrc, &audioSnk,
1, ids, req);
assert(SL_RESULT_SUCCESS == result);
// realize the player
result = (*soundPlayer.fdPlayerObject)->Realize(soundPlayer.fdPlayerObject, SL_BOOLEAN_FALSE);
assert(SL_RESULT_SUCCESS == result);
// get the play interface
result = (*soundPlayer.fdPlayerObject)->GetInterface(soundPlayer.fdPlayerObject, SL_IID_PLAY, &soundPlayer.fdPlayerPlay);
assert(SL_RESULT_SUCCESS == result);
// get the seek interface
result = (*soundPlayer.fdPlayerObject)->GetInterface(soundPlayer.fdPlayerObject, SL_IID_SEEK, &soundPlayer.fdPlayerSeek);
assert(SL_RESULT_SUCCESS == result);
pd->soundPlayers[name] = soundPlayer;
}
void SoundBank::Load(const AssetLoader &loader, const ResourceIndex &index) {
sounds.clear();
sounds.resize(index.Size());
for (const auto &entry : index.Entries()) {
sounds[entry.second] = loader.LoadSound(entry.first);
}
}
Scene Scene::deserialized(io::ReaderRef reader, AssetLoader<StaticMesh>& mesh_loader, const AssetPtr<Material>& default_material) {
y_profile();
struct Header {
u32 magic;
AssetType type;
u32 version;
u32 statics;
u32 lights;
bool is_valid() const {
return magic == fs::magic_number &&
type == AssetType::Scene &&
version == 2;
}
};
auto header = reader->read_one<Header>();
if(!header.is_valid()) {
y_throw("Invalid header.");
}
Scene scene;
scene.static_meshes().set_min_capacity(header.statics);
scene.lights().set_min_capacity(header.lights);
{
for(u32 i = 0; i != header.statics; ++i) {
auto id = reader->read_one<AssetId>();
auto transform = reader->read_one<math::Transform<>>();
if(id == AssetId::invalid_id()) {
log_msg("Skipping asset with invalid id.", Log::Warning);
continue;
}
try {
auto mesh = mesh_loader.load(id);
auto inst = std::make_unique<StaticMeshInstance>(mesh, default_material);
inst->transform() = transform;
scene.static_meshes().emplace_back(std::move(inst));
} catch(std::exception& e) {
log_msg(fmt("Unable to load asset: %, Skipping.", e.what()), Log::Warning);
continue;
}
}
}
{
for(u32 i = 0; i != header.lights; ++i) {
// load as point, then read on top. Maybe change this ?
auto light = std::make_unique<Light>(Light::Point);
reader->read_one(*light);
scene.lights().emplace_back(std::move(light));
}
}
return scene;
}
void main() {
blicketCubes.mark(blicket1);
blicketCubes.mark(blicket2);
nonBlicketCubes.mark(nonBlicket1);
nonBlicketCubes.mark(nonBlicket2);
// Initialize asset configuration and loader
config.append(gMainSlot, BootstrapAssets);
loader.init();
// Subscribe to events (See pubsub design pattern)
Events::cubeConnect.set(onCubeConnect);
Events::cubeDisconnect.set(onCubeDisconnect);
Events::cubeRefresh.set(onCubeRefresh);
Events::neighborAdd.set(onNeighborAdd);
Events::neighborRemove.set(onNeighborRemove);
// Events::cubeTouch.set(onCubeTouch);
Events::cubeTouch.set(onTouch);
// Initialize cubes
for(CubeID cid : CubeSet::connected()) {
vbuf[cid].attach(cid);
activateCube(cid);
}
// Run loop
for(;;) {
paintWrapper();
}
}
//////////////////////////////////////////
// Standard Material Test Models
//////////////////////////////////////////
std::shared_ptr<TriangleMesh> loadMaterialTestModel( AssetLoader & loader )
{
std::string modelBasePath = "models";
//auto mesh = loader.load( modelBasePath + "/dacunni/material_test1.obj" );
//auto mesh = loader.load( modelBasePath + "/dacunni/material_test1.stl" );
auto mesh = loader.load( modelBasePath + "/tf3dm.com/soccerball/untitled.ply" );
return mesh;
}
void main() {
loader.init();
config1.append(slot, grp1);
config2.append(slot, grp2);
Events::cubeConnect.set(onConnect);
for(CubeID cid : CubeSet::connected()) {
init(cid);
}
TimeDelta time(0.f);
for(;;) {
System::keepAwake();
auto startTime = SystemTime::now();
loader.start(config1);
for(CubeID cid : CubeSet::connected()) {
String<32> s;
s << FixedFP(time.seconds(), 3, 3) << "s";
g[cid].bg0rom.fill(vec(0,0), vec(16,16), BG0ROMDrawable::SOLID_BG);
g[cid].bg0rom.text(vec(1,1), s.c_str(), BG0ROMDrawable::BLUE);
g[cid].bg0rom.text(vec(1,14), "Loading GRP1", BG0ROMDrawable::BLUE);
}
while(!loader.isComplete()) {
for(CubeID cid : CubeSet::connected()) {
g[cid].bg0rom.hBargraph(vec(0, 4), loader.cubeProgress(cid, 128), BG0ROMDrawable::ORANGE, 8);
}
System::paint();
}
loader.finish();
time = SystemTime::now() - startTime;
startTime = SystemTime::now();
loader.start(config2);
for(CubeID cid : CubeSet::connected()) {
String<32> s;
s << FixedFP(time.seconds(), 3, 3) << "s";
g[cid].bg0rom.fill(vec(0,0), vec(16,16), BG0ROMDrawable::SOLID_BG);
g[cid].bg0rom.text(vec(1,1), s.c_str(), BG0ROMDrawable::BLUE);
g[cid].bg0rom.text(vec(1,14), "Loading GRP2", BG0ROMDrawable::BLUE);
}
while(!loader.isComplete()) {
for(CubeID cid : CubeSet::connected()) {
g[cid].bg0rom.hBargraph(vec(0, 4), loader.cubeProgress(cid, 128), BG0ROMDrawable::ORANGE, 8);
}
System::paint();
}
loader.finish();
time = SystemTime::now() - startTime;
startTime = SystemTime::now();
}
}
//////////////////////////////////////////
// Standard Material Test Models
//////////////////////////////////////////
std::shared_ptr<TriangleMesh> loadMaterialTestModel( AssetLoader & loader )
{
std::string modelBasePath = "models";
//auto mesh = loader.load( modelBasePath + "/dacunni/material_test1.obj" );
//auto mesh = loader.load( modelBasePath + "/dacunni/material_test1.stl" );
auto mesh = loader.load( modelBasePath + "/tf3dm.com/soccerball/untitled.ply" );
//auto mesh = loader.load( modelBasePath + "/uvsphere.ply" );
//auto mesh = loader.loadMultiPartMerged( modelBasePath + "/test_objects/mori/testObj.obj" );
#if 0
auto mesh = loader.loadMultiPartMerged( modelBasePath + "/test_objects/mitsuba/mitsuba.obj" );
#endif
#if 0
mesh->makeCanonical();
#endif
#if 1
mesh->accelerator = new TMOctreeAccelerator( *mesh );
mesh->accelerator->build();
#endif
return mesh;
}
std::string ResourceLoader::loadLuaScript(const std::string &scriptname) {
const std::string &filename = scriptname + ".lua";
AssetLoader *loader = AssetLoader::instance();
AAsset *asset = loader->open(filename);
// the asset might not be found
if (NULL == asset) {
DEBUGLOG("Asset not found: %s", filename.c_str());
return NULL;
}
size_t length = AAsset_getLength(asset);
const char *buffer = (char *)AAsset_getBuffer(asset);
std::string script(buffer, length);
if (buffer = NULL) {
DEBUGLOG("Buffer is empty");
}
AAsset_close(asset);
return script;
}
void main() {
// initialize asset configuration and loader
config.append(gMainSlot, BootstrapAssets);
loader.init();
// subscribe to events
Events::cubeConnect.set(onCubeConnect);
Events::cubeDisconnect.set(onCubeDisconnect);
Events::cubeRefresh.set(onCubeRefresh);
//Set events for interactive elements
Events::neighborAdd.set(onNeighborAdd);
Events::neighborRemove.set(onNeighborRemove);
Events::cubeAccelChange.set(onAccelChange);
// initialize cubes
currentLearningTask=1;
previousLearningTask=0;
isDistracted = false;
// Background music
// AudioTracker::setVolume(0.2f * AudioChannel::MAX_VOLUME);
// AudioTracker::play(Music);
//Initial cube paint, also assigning character cubes. (should retain same IDs)
int j = 0;
for(CubeID cid : CubeSet::connected()) {
currentBackgrounds[j] = j;
vbuf[cid].attach(cid);
motion[cid].attach(cid);
activateCube(cid);
cbs [j] = cid;
j++;
}
toucan = cbs[0];
monkey = cbs[1];
giraffe = cbs[2];
// run loop
for(;;) {
paintWrapper();
}
}
void main()
{
assetConfig.append(MainSlot, BetterflowAssets);
loader.init();
for (CubeID cube : CubeSet::connected())
{
onConnect(NULL, cube);
}
Events::cubeConnect.set(&onConnect);
gVideo[0].setMode(BG0);
MainMenu gameMenu(&gVideo[0]);
int colour;
Colormap colourList;
colourList.setEGA();
while(1)
{
colour = gameMenu.runMenu();
gVideo[0].setMode(SOLID_MODE);
gVideo[0].colormap[0].set(colourList[colour].get());
System::paint();
TimeStep ts;
TimeTicker ticker = TimeTicker(1);
int tickIncr;
int tickCount = 0;
do
{
tickIncr = ticker.tick( ts.delta() );
ts.next();
tickCount += tickIncr;
} while (tickCount < 3);
gVideo[0].setMode(BG0);
gVideo[0].bg0.erase(StripeTile);
}
}
static void begin() {
// initialize asset configuration and loader
config.append(gMainSlot, BootstrapAssets);
loader.init();
// subscribe to events
Events::cubeConnect.set(onCubeConnect);
Events::cubeDisconnect.set(onCubeDisconnect);
Events::cubeRefresh.set(onCubeRefresh);
Events::cubeTouch.set(onCubeTouch);
Events::neighborAdd.set(onNeighborAdd);
Events::neighborRemove.set(onNeighborRemove);
// Blank screens, attach VideoBuffers
for(CubeID cid : CubeSet::connected()) {
auto &vid = vbuf[cid];
vid.initMode(BG0);
vid.attach(cid);
vid.bg0.erase(StripeTile);
}
}
/// @copydoc PackageLoader::BeginLoadObject()
size_t LoosePackageLoader::BeginLoadObject( AssetPath path, Reflect::ObjectResolver *pResolver, bool forceReload )
{
HELIUM_TRACE( TraceLevels::Info, TXT(" LoosePackageLoader::BeginLoadObject - Loading path %s\n"), *path.ToString() );
HELIUM_TRACE(
TraceLevels::Debug,
TXT( "LoosePackageLoader::BeginLoadObject: Beginning load for path \"%s\".\n"),
*path.ToString());
HELIUM_TRACE(
TraceLevels::Debug,
TXT( "LoosePackageLoader::BeginLoadObject: Beginning load for path \"%s\". pResolver = %x\n"),
*path.ToString(),
pResolver);
// Make sure preloading has completed.
HELIUM_ASSERT( m_preloadedCounter != 0 );
if( !m_preloadedCounter )
{
return Invalid< size_t >();
}
// If this package is requested, simply provide the (already loaded) package instance.
if( path == m_packagePath )
{
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( m_spPackage );
pRequest->spObject = m_spPackage.Ptr();
SetInvalid( pRequest->index );
HELIUM_ASSERT( !pRequest->spType );
HELIUM_ASSERT( !pRequest->spTemplate );
HELIUM_ASSERT( !pRequest->spOwner );
SetInvalid( pRequest->templateLoadId );
SetInvalid( pRequest->ownerLoadId );
SetInvalid( pRequest->persistentResourceDataLoadId );
pRequest->pCachedObjectDataBuffer = NULL;
pRequest->cachedObjectDataBufferSize = 0;
SetInvalid( pRequest->asyncFileLoadId );
pRequest->pAsyncFileLoadBuffer = NULL;
pRequest->asyncFileLoadBufferSize = 0;
pRequest->pResolver = NULL;
pRequest->forceReload = forceReload;
pRequest->flags = LOAD_FLAG_PRELOADED;
size_t requestId = m_loadRequests.Add( pRequest );
return requestId;
}
size_t objectIndex = FindObjectByPath( path );
size_t objectCount = GetObjectCount();
if( objectIndex >= objectCount )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to locate \"%s\" for loading. Verify the file exists.\n" ),
*path.ToString() );
return Invalid< size_t >();
}
SerializedObjectData& rObjectData = m_objects[ objectIndex ];
// Verify that the metadata was read successfully
if( !rObjectData.bMetadataGood )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to read metadata for object \"%s\" during PackagePreload. Search log for parsing errors.\n" ),
*path.ToString() );
return Invalid< size_t >();
}
// Locate the type object.
HELIUM_ASSERT( !rObjectData.typeName.IsEmpty() );
AssetType* pType = AssetType::Find( rObjectData.typeName );
if( !pType )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader::BeginLoadObject(): Failed to locate type \"%s\" for loading object \"%s\".\n" ),
*rObjectData.typeName,
*path.ToString() );
HELIUM_TRACE(
TraceLevels::Info,
TXT( "Current registered types:\n" ) );
for ( AssetType::ConstIterator iter = AssetType::GetTypeBegin();
iter != AssetType::GetTypeEnd(); ++iter)
{
HELIUM_TRACE(
TraceLevels::Info,
TXT( " - %s\n" ),
*iter->GetName() );
}
return Invalid< size_t >();
}
#ifndef NDEBUG
size_t loadRequestSize = m_loadRequests.GetSize();
for( size_t loadRequestIndex = 0; loadRequestIndex < loadRequestSize; ++loadRequestIndex )
{
if( !m_loadRequests.IsElementValid( loadRequestIndex ) )
{
continue;
}
LoadRequest* pRequest = m_loadRequests[ loadRequestIndex ];
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( pRequest->index != objectIndex );
if( pRequest->index == objectIndex )
{
return Invalid< size_t >();
}
}
#endif
LoadRequest* pRequest = m_loadRequestPool.Allocate();
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !pRequest->spObject );
pRequest->index = objectIndex;
pRequest->spType = pType;
HELIUM_ASSERT( !pRequest->spTemplate );
HELIUM_ASSERT( !pRequest->spOwner );
SetInvalid( pRequest->templateLoadId );
SetInvalid( pRequest->ownerLoadId );
SetInvalid( pRequest->persistentResourceDataLoadId );
pRequest->pCachedObjectDataBuffer = NULL;
pRequest->cachedObjectDataBufferSize = 0;
SetInvalid( pRequest->asyncFileLoadId );
pRequest->pAsyncFileLoadBuffer = NULL;
pRequest->asyncFileLoadBufferSize = 0;
pRequest->pResolver = pResolver;
pRequest->forceReload = forceReload;
pRequest->flags = 0;
// If a fully-loaded object already exists with the same name, do not attempt to re-load the object (just mark
// the request as complete).
if ( !forceReload )
{
pRequest->spObject = Asset::FindObject( path );
}
Asset* pObject = pRequest->spObject;
if( pObject && pObject->IsFullyLoaded() )
{
pRequest->flags = LOAD_FLAG_PRELOADED;
}
else
{
HELIUM_ASSERT( !pObject || !pObject->GetAnyFlagSet( Asset::FLAG_LOADED | Asset::FLAG_LINKED ) );
// Begin loading the template and owner objects. Note that there isn't much reason to check for failure
// until we tick this request, as we need to make sure any other load requests for the template/owner that
// did succeed are properly synced anyway.
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
if( rObjectData.templatePath.IsEmpty() )
{
// Make sure the template is fully loaded.
Asset* pTemplate = pType->GetTemplate();
rObjectData.templatePath = pTemplate->GetPath();
if( pTemplate->IsFullyLoaded() )
{
pRequest->spTemplate = pTemplate;
}
else
{
pRequest->templateLoadId = pAssetLoader->BeginLoadObject( rObjectData.templatePath );
}
}
else
{
pRequest->templateLoadId = pAssetLoader->BeginLoadObject( rObjectData.templatePath );
}
AssetPath ownerPath = path.GetParent();
if( ownerPath == m_packagePath )
{
// Easy check: if the owner is this package (which is likely), we don't need to load it.
pRequest->spOwner = m_spPackage.Ptr();
}
else if( !ownerPath.IsEmpty() )
{
pRequest->ownerLoadId = pAssetLoader->BeginLoadObject( ownerPath );
}
}
size_t requestId = m_loadRequests.Add( pRequest );
return requestId;
}
/// Begin asynchronous pre-loading of package information.
///
/// @see TryFinishPreload()
bool LoosePackageLoader::BeginPreload()
{
HELIUM_ASSERT( !m_startPreloadCounter );
HELIUM_ASSERT( !m_preloadedCounter );
HELIUM_ASSERT( IsInvalid( m_parentPackageLoadId ) );
// Load the parent package if we need to create the current package.
if( !m_spPackage )
{
AssetPath parentPackagePath = m_packagePath.GetParent();
if( !parentPackagePath.IsEmpty() )
{
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
m_parentPackageLoadId = pAssetLoader->BeginLoadObject( parentPackagePath );
HELIUM_ASSERT( IsValid( m_parentPackageLoadId ) );
}
}
AsyncLoader &rAsyncLoader = AsyncLoader::GetStaticInstance();
if ( !m_packageDirPath.Exists() )
{
HELIUM_TRACE(
TraceLevels::Warning,
"LoosePackageLoader::BeginPreload - Package physical path '%s' does not exist\n",
m_packageDirPath.c_str());
}
else if ( !m_packageDirPath.IsDirectory() )
{
HELIUM_TRACE(
TraceLevels::Warning,
"LoosePackageLoader::BeginPreload - Package physical path '%s' is not a directory\n",
m_packageDirPath.c_str());
}
else
{
DirectoryIterator packageDirectory( m_packageDirPath );
HELIUM_TRACE( TraceLevels::Info, TXT(" LoosePackageLoader::BeginPreload - Issuing read requests for all files in %s\n"), m_packageDirPath.c_str() );
for( ; !packageDirectory.IsDone(); packageDirectory.Next() )
{
const DirectoryIteratorItem& item = packageDirectory.GetItem();
#if HELIUM_TOOLS
if ( item.m_Path.IsDirectory() )
{
AssetPath packagePath;
std::string name = item.m_Path.DirectoryAsVector().back();
packagePath.Set( Name( name.c_str() ), true, m_packagePath );
m_childPackagePaths.Add( packagePath );
HELIUM_TRACE( TraceLevels::Info, TXT("- Skipping directory [%s]\n"), item.m_Path.c_str(), item.m_Path.Extension().c_str() );
}
else
#endif
if ( item.m_Path.Extension() == Persist::ArchiveExtensions[ Persist::ArchiveTypes::Json ] )
{
HELIUM_TRACE( TraceLevels::Info, TXT("- Reading file [%s]\n"), item.m_Path.c_str() );
FileReadRequest *request = m_fileReadRequests.New();
request->expectedSize = item.m_Size;
HELIUM_ASSERT( item.m_Size < UINT32_MAX );
// Create a buffer for the file to be read into temporarily
request->pLoadBuffer = DefaultAllocator().Allocate( static_cast< size_t > ( item.m_Size ) + 1 );
static_cast< char* >( request->pLoadBuffer )[ static_cast< size_t > ( item.m_Size ) ] = '\0'; // for efficiency parsing text files
HELIUM_ASSERT( request->pLoadBuffer );
// Queue up the read
request->asyncLoadId = rAsyncLoader.QueueRequest( request->pLoadBuffer, String( item.m_Path.c_str() ), 0, static_cast< size_t >( item.m_Size ) );
HELIUM_ASSERT( IsValid( request->asyncLoadId ) );
request->filePath = item.m_Path;
request->fileTimestamp = item.m_ModTime;
}
else
{
HELIUM_TRACE( TraceLevels::Info, TXT("- Skipping file [%s] (Extension is %s)\n"), item.m_Path.c_str(), item.m_Path.Extension().c_str() );
}
}
}
AtomicExchangeRelease( m_startPreloadCounter, 1 );
return true;
}
/// Update processing of object property preloading for a given load request.
///
/// @param[in] pRequest Load request to process.
///
/// @return True if object property preloading for the given load request has completed, false if not.
bool LoosePackageLoader::TickDeserialize( LoadRequest* pRequest )
{
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !( pRequest->flags & LOAD_FLAG_PROPERTY_PRELOADED ) );
Asset* pObject = pRequest->spObject;
HELIUM_ASSERT( pRequest->index < m_objects.GetSize() );
SerializedObjectData& rObjectData = m_objects[ pRequest->index ];
// Wait for the template and owner objects to load.
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
if( !rObjectData.templatePath.IsEmpty() )
{
if( IsValid( pRequest->templateLoadId ) )
{
if( !pAssetLoader->TryFinishLoad( pRequest->templateLoadId, pRequest->spTemplate ) )
{
return false;
}
SetInvalid( pRequest->templateLoadId );
}
if( !pRequest->spTemplate )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failed to load template object for \"%s\".\n" ),
*rObjectData.objectPath.ToString() );
if( pObject )
{
pObject->SetFlags( Asset::FLAG_PRELOADED | Asset::FLAG_LINKED );
pObject->ConditionalFinalizeLoad();
}
pRequest->flags |= LOAD_FLAG_PRELOADED | LOAD_FLAG_ERROR;
return true;
}
}
HELIUM_ASSERT( IsInvalid( pRequest->templateLoadId ) );
Asset* pTemplate = pRequest->spTemplate;
AssetPath ownerPath = rObjectData.objectPath.GetParent();
if( !ownerPath.IsEmpty() )
{
if( IsValid( pRequest->ownerLoadId ) )
{
if( !pAssetLoader->TryFinishLoad( pRequest->ownerLoadId, pRequest->spOwner ) )
{
return false;
}
SetInvalid( pRequest->ownerLoadId );
}
if( !pRequest->spOwner )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failed to load owner object for \"%s\".\n" ),
*rObjectData.objectPath.ToString() );
if( pObject )
{
pObject->SetFlags( Asset::FLAG_PRELOADED | Asset::FLAG_LINKED );
pObject->ConditionalFinalizeLoad();
}
pRequest->flags |= LOAD_FLAG_PRELOADED | LOAD_FLAG_ERROR;
return true;
}
}
HELIUM_ASSERT( IsInvalid( pRequest->ownerLoadId ) );
Asset* pOwner = pRequest->spOwner;
AssetType* pType = pRequest->spType;
HELIUM_ASSERT( pType );
HELIUM_ASSERT( !pOwner || pOwner->IsFullyLoaded() );
HELIUM_ASSERT( !pTemplate || pTemplate->IsFullyLoaded() );
AsyncLoader& rAsyncLoader = AsyncLoader::GetStaticInstance();
FilePath object_file_path = m_packageDirPath + *rObjectData.objectPath.GetName() + TXT( "." ) + Persist::ArchiveExtensions[ Persist::ArchiveTypes::Json ];
bool load_properties_from_file = true;
size_t object_file_size = 0;
if ( !IsValid( pRequest->asyncFileLoadId ) )
{
if (!object_file_path.IsFile())
{
if (pType->GetMetaClass()->IsType( Reflect::GetMetaClass< Resource >() ))
{
HELIUM_TRACE(
TraceLevels::Info,
TXT( "LoosePackageLoader::TickDeserialize(): No object file found for resource \"%s\". Expected file location: \"%s\". This is normal for newly added resources.\n" ),
*rObjectData.objectPath.ToString(),
*object_file_path);
// We will allow continuing to load using all default properties. This behavior is to support dropping resources into the
// data property and autogenerating objects from them.
load_properties_from_file = false;
}
else
{
HELIUM_TRACE(
TraceLevels::Warning,
TXT( "LoosePackageLoader::TickDeserialize(): No object file found for object \"%s\". Expected file location: \"%s\"\n" ),
*rObjectData.objectPath.ToString(),
*object_file_path);
}
}
else
{
Status status;
status.Read( object_file_path.Get().c_str() );
int64_t i64_object_file_size = status.m_Size;
if( i64_object_file_size == -1 )
{
HELIUM_TRACE(
TraceLevels::Warning,
TXT( "LoosePackageLoader::TickDeserialize(): Could not get file size for object file of object \"%s\". Expected file location: \"%s\"\n" ),
*rObjectData.objectPath.ToString(),
*object_file_path );
}
else if( i64_object_file_size == 0 )
{
HELIUM_TRACE(
TraceLevels::Warning,
TXT( "LoosePackageLoader::TickDeserialize(): Object file \"%s\" for objct \"%s\" is empty.\n" ),
*object_file_path,
*rObjectData.objectPath.ToString() );
}
else if( static_cast< uint64_t >( i64_object_file_size ) > static_cast< uint64_t >( ~static_cast< size_t >( 0 ) ) )
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader::TickDeserialize(): Object file \"%s\" exceeds the maximum size supported by " )
TXT( "the current platform (file size: %" ) PRIu64 TXT( " bytes; max supported: %" ) PRIuSZ
TXT( " bytes).\n" ) ),
object_file_path.c_str(),
static_cast< uint64_t >( i64_object_file_size ),
~static_cast< size_t >( 0 ) );
}
else
{
object_file_size = static_cast< size_t >(i64_object_file_size);
}
}
if (!load_properties_from_file)
{
HELIUM_ASSERT(!object_file_size);
}
else if (!object_file_size)
{
pRequest->flags |= LOAD_FLAG_PRELOADED | LOAD_FLAG_ERROR;
return true;
}
else
{
HELIUM_ASSERT( !pRequest->pAsyncFileLoadBuffer );
pRequest->pAsyncFileLoadBuffer = DefaultAllocator().Allocate( object_file_size );
HELIUM_ASSERT( pRequest->pAsyncFileLoadBuffer );
pRequest->asyncFileLoadBufferSize = object_file_size;
pRequest->asyncFileLoadId = rAsyncLoader.QueueRequest(
pRequest->pAsyncFileLoadBuffer,
String(object_file_path.c_str()),
0,
pRequest->asyncFileLoadBufferSize);
}
}
size_t bytesRead = 0;
if (load_properties_from_file)
{
HELIUM_ASSERT( IsValid( pRequest->asyncFileLoadId ) );
if ( !rAsyncLoader.TrySyncRequest( pRequest->asyncFileLoadId, bytesRead ) )
{
return false;
}
}
/////// POINT OF NO RETURN: We *will* return true after this point, and the object *will* be finished preloading,
/////// for good or for bad.
SetInvalid(pRequest->asyncFileLoadId);
bool object_creation_failure = false;
// If we already had an existing object, make sure the type and template match.
if( pObject )
{
const AssetType* pExistingType = pObject->GetAssetType();
HELIUM_ASSERT( pExistingType );
if( pExistingType != pType )
{
HELIUM_TRACE(
TraceLevels::Error,
( TXT( "LoosePackageLoader: Cannot load \"%s\" using the existing object as the types do not match " )
TXT( "(existing type: \"%s\"; serialized type: \"%s\".\n" ) ),
*rObjectData.objectPath.ToString(),
*pExistingType->GetName(),
*pType->GetName() );
pObject->SetFlags( Asset::FLAG_PRELOADED | Asset::FLAG_LINKED );
pObject->ConditionalFinalizeLoad();
object_creation_failure = true;
}
}
else
{
bool bCreateResult = false;
if (pRequest->forceReload)
{
// Create the object.
bCreateResult = Asset::CreateObject(
pRequest->spObject,
pType,
Name( NULL_NAME ),
NULL,
pTemplate );
}
else
{
// Create the object.
bCreateResult = Asset::CreateObject(
pRequest->spObject,
pType,
rObjectData.objectPath.GetName(),
pOwner,
pTemplate );
}
if( !bCreateResult )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failed to create \"%s\" during loading.\n" ),
*rObjectData.objectPath.ToString() );
object_creation_failure = true;
}
pObject = pRequest->spObject;
HELIUM_ASSERT( pObject );
}
if (load_properties_from_file && !object_creation_failure)
{
// Sanity checks for file load, then success path
HELIUM_ASSERT( bytesRead == pRequest->asyncFileLoadBufferSize );
if( IsInvalid( bytesRead ) )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failed to read the contents of object file \"%s\" in async load request \"%d\".\n" ),
object_file_path.c_str(),
pRequest->asyncFileLoadId );
}
else if( bytesRead != pRequest->asyncFileLoadBufferSize )
{
HELIUM_TRACE(
TraceLevels::Warning,
( TXT( "LoosePackageLoader: Attempted to read %" ) PRIuSZ TXT( " bytes from object file \"%s\", " )
TXT( "but only %" ) PRIuSZ TXT( " bytes were read.\n" ) ),
pRequest->asyncFileLoadBufferSize,
object_file_path.c_str(),
bytesRead );
}
else
{
StaticMemoryStream archiveStream ( pRequest->pAsyncFileLoadBuffer, pRequest->asyncFileLoadBufferSize );
HELIUM_TRACE(
TraceLevels::Info,
TXT( "LoosePackageLoader: Reading %s. pResolver = %x\n"),
object_file_path.c_str(),
pRequest->pResolver);
DynamicArray< Reflect::ObjectPtr > objects;
objects.Push( pRequest->spObject.Get() ); // use existing objects
Persist::ArchiveReaderJson::ReadFromStream( archiveStream, objects, pRequest->pResolver );
HELIUM_ASSERT( objects[0].Get() == pRequest->spObject.Get() );
}
}
if (load_properties_from_file)
{
DefaultAllocator().Free(pRequest->pAsyncFileLoadBuffer);
pRequest->pAsyncFileLoadBuffer = NULL;
pRequest->asyncFileLoadBufferSize = 0;
}
pRequest->flags |= LOAD_FLAG_PROPERTY_PRELOADED;
if( object_creation_failure )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Deserialization of object \"%s\" failed.\n" ),
*rObjectData.objectPath.ToString() );
pObject->SetFlags( Asset::FLAG_PRELOADED | Asset::FLAG_LINKED );
pObject->ConditionalFinalizeLoad();
pRequest->flags |= LOAD_FLAG_ERROR;
}
else if( !pObject->IsDefaultTemplate() )
{
// If the object is a resource (not including the default template object for resource types), attempt to begin
// loading any existing persistent resource data stored in the object cache.
Resource* pResource = Reflect::SafeCast< Resource >( pObject );
if( pResource )
{
Name objectCacheName = Name( HELIUM_ASSET_CACHE_NAME );
CacheManager& rCacheManager = CacheManager::GetStaticInstance();
Cache* pCache = rCacheManager.GetCache( objectCacheName );
HELIUM_ASSERT( pCache );
pCache->EnforceTocLoad();
const Cache::Entry* pEntry = pCache->FindEntry( rObjectData.objectPath, 0 );
if( pEntry && pEntry->size != 0 )
{
HELIUM_ASSERT( IsInvalid( pRequest->persistentResourceDataLoadId ) );
HELIUM_ASSERT( !pRequest->pCachedObjectDataBuffer );
pRequest->pCachedObjectDataBuffer =
static_cast< uint8_t* >( DefaultAllocator().Allocate( pEntry->size ) );
HELIUM_ASSERT( pRequest->pCachedObjectDataBuffer );
pRequest->cachedObjectDataBufferSize = pEntry->size;
AsyncLoader& rAsyncLoader = AsyncLoader::GetStaticInstance();
pRequest->persistentResourceDataLoadId = rAsyncLoader.QueueRequest(
pRequest->pCachedObjectDataBuffer,
pCache->GetCacheFileName(),
pEntry->offset,
pEntry->size );
HELIUM_ASSERT( IsValid( pRequest->persistentResourceDataLoadId ) );
}
}
}
if( IsInvalid( pRequest->persistentResourceDataLoadId ) )
{
// No persistent resource data needs to be loaded.
pObject->SetFlags( Asset::FLAG_PRELOADED );
pRequest->flags |= LOAD_FLAG_PERSISTENT_RESOURCE_PRELOADED;
}
// Asset is now preloaded.
return true;
}
void ForciblyFullyLoadedPackageManager::Tick()
{
AssetLoader *pAssetLoader = AssetLoader::GetStaticInstance();
// For each editable package
for ( DynamicArray< ForciblyFullyLoadedPackage >::Iterator packageIter = m_ForciblyFullyLoadedPackages.Begin();
packageIter != m_ForciblyFullyLoadedPackages.End(); ++packageIter)
{
ForciblyFullyLoadedPackage &package = *packageIter;
// Load the package if we need to
if ( Helium::IsValid< size_t >( package.m_PackageLoadId ) )
{
HELIUM_ASSERT( package.m_Assets.IsEmpty() );
HELIUM_ASSERT( package.m_AssetLoadIds.IsEmpty() );
HELIUM_ASSERT( package.m_AssetPaths.IsEmpty() );
HELIUM_ASSERT( !package.m_Package );
AssetPtr packagePtr;
if ( pAssetLoader->TryFinishLoad( package.m_PackageLoadId, packagePtr ) )
{
// Load request is finished.
package.m_PackageLoadId = Helium::Invalid< size_t >();
package.m_Package = Reflect::AssertCast<Package>(packagePtr);
if ( package.m_Package )
{
if ( !package.m_Package->GetAllFlagsSet( Asset::FLAG_EDITOR_FORCIBLY_LOADED ) )
{
// Package loaded successfully, queue load requests for all children
package.m_Package->SetFlags( Asset::FLAG_EDITOR_FORCIBLY_LOADED );
e_AssetForciblyLoadedEvent.Raise( AssetEventArgs( package.m_Package ) );
}
PackageLoader *pLoader = package.m_Package->GetLoader();
pLoader->EnumerateChildren( package.m_AssetPaths );
package.m_Assets.Resize( package.m_AssetPaths.GetSize() );
package.m_AssetLoadIds.Resize( package.m_AssetPaths.GetSize() );
DynamicArray< AssetPath >::Iterator assetPathIter = package.m_AssetPaths.Begin();
DynamicArray< size_t >::Iterator assetLoadIdIter = package.m_AssetLoadIds.Begin();
int i = 0;
for ( ; assetPathIter != package.m_AssetPaths.End(); ++assetPathIter, ++assetLoadIdIter )
{
*assetLoadIdIter = pAssetLoader->BeginLoadObject( *assetPathIter );
HELIUM_ASSERT( !package.m_Assets[i++] );
}
}
else
{
HELIUM_TRACE(
TraceLevels::Warning,
"Failed to load package '%s' for editor.",
*package.m_PackagePath.ToString());
}
}
}
}
// For each editable package
for ( DynamicArray< ForciblyFullyLoadedPackage >::Iterator packageIter = m_ForciblyFullyLoadedPackages.Begin();
packageIter != m_ForciblyFullyLoadedPackages.End(); ++packageIter)
{
ForciblyFullyLoadedPackage &package = *packageIter;
// If the package is loaded
if ( package.m_Package )
{
// Load the child assets if we need to
for ( int i = 0; i < package.m_AssetPaths.GetSize(); ++i )
{
if ( Helium::IsValid<size_t>( package.m_AssetLoadIds[i] ) )
{
HELIUM_ASSERT( !package.m_Assets[i] );
if ( pAssetLoader->TryFinishLoad( package.m_AssetLoadIds[i], package.m_Assets[i] ) )
{
package.m_AssetLoadIds[i] = Invalid< size_t >();
if ( package.m_Assets[i] )
{
// Asset loaded successfully
if ( !package.m_Assets[i]->IsPackage() && !package.m_Assets[i]->GetAllFlagsSet( Asset::FLAG_EDITOR_FORCIBLY_LOADED ) )
{
package.m_Assets[i]->SetFlags( Asset::FLAG_EDITOR_FORCIBLY_LOADED );
e_AssetForciblyLoadedEvent.Raise( AssetEventArgs( package.m_Assets[i] ) );
}
}
else
{
HELIUM_TRACE(
TraceLevels::Warning,
"Failed to asset '%s' for editor.",
*package.m_PackagePath.ToString());
}
}
else
{
HELIUM_ASSERT( !package.m_Assets[i] );
}
if ( Helium::IsValid<size_t>( package.m_AssetLoadIds[i] ) )
{
HELIUM_ASSERT( !package.m_Assets[i] );
}
}
}
}
}
}
int main( int argc, const char* argv[] )
#endif
{
HELIUM_TRACE_SET_LEVEL( TraceLevels::Debug );
Helium::GetComponentsDefaultHeap();
Helium::GetBulletDefaultHeap();
#if HELIUM_TOOLS
Helium::GetEditorSupportDefaultHeap();
#endif
int32_t result = 0;
{
// Initialize a GameSystem instance.
CommandLineInitializationImpl commandLineInitialization;
MemoryHeapPreInitializationImpl memoryHeapPreInitialization;
AssetLoaderInitializationImpl assetLoaderInitialization;
ConfigInitializationImpl configInitialization;
#if HELIUM_DIRECT3D
WindowManagerInitializationImpl windowManagerInitialization( hInstance, nCmdShow );
#else
WindowManagerInitializationImpl windowManagerInitialization;
#endif
RendererInitializationImpl rendererInitialization;
//NullRendererInitialization rendererInitialization;
AssetPath systemDefinitionPath( "/ExampleGames/PhysicsDemo:System" );
GameSystem* pGameSystem = GameSystem::CreateStaticInstance();
HELIUM_ASSERT( pGameSystem );
bool bSystemInitSuccess = pGameSystem->Initialize(
commandLineInitialization,
memoryHeapPreInitialization,
assetLoaderInitialization,
configInitialization,
windowManagerInitialization,
rendererInitialization,
systemDefinitionPath);
if( bSystemInitSuccess )
{
World *pWorld = NULL;
{
AssetLoader *pAssetLoader = AssetLoader::GetStaticInstance();
SceneDefinitionPtr spSceneDefinition;
AssetPath scenePath( TXT( "/ExampleGames/PhysicsDemo/Scenes/TestScene:SceneDefinition" ) );
pAssetLoader->LoadObject(scenePath, spSceneDefinition );
HELIUM_ASSERT( !spSceneDefinition->GetAllFlagsSet( Asset::FLAG_BROKEN ) );
pWorld = pGameSystem->LoadScene(spSceneDefinition.Get());
}
HELIUM_ASSERT( pWorld );
if ( pWorld )
{
AssetLoader *pAssetLoader = AssetLoader::GetStaticInstance();
EntityDefinitionPtr spCubeDefinition;
EntityDefinitionPtr spSphereDefinition;
AssetPath spCubePath( TXT( "/ExampleGames/PhysicsDemo:Cube" ) );
AssetPath spSpherePath( TXT( "/ExampleGames/PhysicsDemo:Sphere" ) );
pAssetLoader->LoadObject(spCubePath, spCubeDefinition );
pAssetLoader->LoadObject(spSpherePath, spSphereDefinition );
Helium::StrongPtr< ParameterSet_InitLocated > locatedParamSet( new ParameterSet_InitLocated() );
locatedParamSet->m_Position = Simd::Vector3::Zero;
locatedParamSet->m_Rotation = Simd::Quat::IDENTITY;
Simd::Vector3 &position = locatedParamSet->m_Position;
Simd::Quat &rotation = locatedParamSet->m_Rotation;
for (int i = 0; i < 25; ++i)
{
position = Simd::Vector3(
50.0f * static_cast<float>(i / 5) - 100.0f + Helium::Ran(-10.0f, 10.0f),
Helium::Ran(150.0f, 200.0f),
50.0f * static_cast<float>(i % 5) - 100.0f + Helium::Ran(-10.0f, 10.0f));
pWorld->GetRootSlice()->CreateEntity(spCubeDefinition, locatedParamSet.Get());
}
for (int i = 0; i < 25; ++i)
{
position = Simd::Vector3(
50.0f * static_cast<float>(i / 5) - 100.0f + Helium::Ran(-10.0f, 10.0f),
Helium::Ran(250.0f, 300.0f),
50.0f * static_cast<float>(i % 5) - 100.0f + Helium::Ran(-10.0f, 10.0f));
pWorld->GetRootSlice()->CreateEntity(spSphereDefinition, locatedParamSet.Get());
}
for (int i = 0; i < 25; ++i)
{
position = Simd::Vector3(
50.0f * static_cast<float>(i / 5) - 100.0f + Helium::Ran(-10.0f, 10.0f),
Helium::Ran(350.0f, 400.0f),
50.0f * static_cast<float>(i % 5) - 100.0f + Helium::Ran(-10.0f, 10.0f));
pWorld->GetRootSlice()->CreateEntity(spCubeDefinition, locatedParamSet.Get());
}
for (int i = 0; i < 25; ++i)
{
position = Simd::Vector3(
50.0f * static_cast<float>(i / 5) - 100.0f + Helium::Ran(-10.0f, 10.0f),
Helium::Ran(450.0f, 500.0f),
50.0f * static_cast<float>(i % 5) - 100.0f + Helium::Ran(-10.0f, 10.0f));
pWorld->GetRootSlice()->CreateEntity(spSphereDefinition, locatedParamSet.Get());
}
for (int i = 0; i < 25; ++i)
{
position = Simd::Vector3(
50.0f * static_cast<float>(i / 5) - 100.0f + Helium::Ran(-10.0f, 10.0f),
Helium::Ran(550.0f, 600.0f),
50.0f * static_cast<float>(i % 5) - 100.0f + Helium::Ran(-10.0f, 10.0f));
pWorld->GetRootSlice()->CreateEntity(spCubeDefinition, locatedParamSet.Get());
}
Window::NativeHandle windowHandle = rendererInitialization.GetMainWindow()->GetNativeHandle();
Input::Initialize(windowHandle, false);
Input::SetWindowSize(
rendererInitialization.GetMainWindow()->GetWidth(),
rendererInitialization.GetMainWindow()->GetHeight());
// Run the application.
result = pGameSystem->Run();
}
}
// Shut down and destroy the system.
pGameSystem->Shutdown();
System::DestroyStaticInstance();
}
// Perform final cleanup.
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#if HELIUM_ENABLE_MEMORY_TRACKING
DynamicMemoryHeap::LogMemoryStats();
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#endif
return result;
}
static void paintWrapper() {
// clear the palette
newCubes.clear();
lostCubes.clear();
reconnectedCubes.clear();
dirtyCubes.clear();
if(previousLearningTask != currentLearningTask){
previousLearningTask++;
}
// fire events
System::paint();
// dynamically load assets just-in-time
if (!(newCubes | reconnectedCubes).empty()) {
AudioTracker::pause();
playSfx(SfxConnect);
loader.start(config);
while(!loader.isComplete()) {
for(CubeID cid : (newCubes | reconnectedCubes)) {
vbuf[cid].bg0rom.hBargraph(
vec(0, 4), loader.cubeProgress(cid, 128), BG0ROMDrawable::ORANGE, 8
);
}
// fire events while we wait
System::paint();
}
loader.finish();
AudioTracker::resume();
}
// // repaint cubes (will this paint right? If not, try repainting all of them)
// for(CubeID cid : dirtyCubes) {
// activateCube(cid);
// }
//If the shaken timer flag is too old, turn it off again here.
if(distractTime.isValid() && (currentLearningTask==2)) {
TimeDelta timeSinceShook = SystemTime::now() - distractTime;
double duration = timeSinceShook.milliseconds() / 1000;
if((duration > 11) && isDistracted) {
currentBackgrounds[2] = 3;
currentBackgrounds[1] = 1;
isDistracted = false;
}
}
//update art to new task
int j = 0;
for(CubeID cid : CubeSet::connected()) {
vbuf[cid].attach(cid);
activateCube(cid);
cbs [j] = cid;
j++;
}
// also, handle lost cubes, if you so desire :)
}
/// @copydoc PackageLoader::TryFinishLoadObject()
bool CachePackageLoader::TryFinishLoadObject( size_t requestId, AssetPtr& rspObject )
{
HELIUM_ASSERT( requestId < m_loadRequests.GetSize() );
HELIUM_ASSERT( m_loadRequests.IsElementValid( requestId ) );
LoadRequest* pRequest = m_loadRequests[ requestId ];
HELIUM_ASSERT( pRequest );
if( !( pRequest->flags & LOAD_FLAG_PRELOADED ) )
{
return false;
}
// Sync on template and owner dependencies.
AssetLoader* pAssetLoader = AssetLoader::GetInstance();
HELIUM_ASSERT( pAssetLoader );
if( IsValid( pRequest->ownerLoadIndex ) )
{
size_t linkLoadId = pRequest->ownerLoadIndex;
if( IsValid( linkLoadId ) && !pAssetLoader->TryFinishLoad( linkLoadId, pRequest->spOwner ) )
{
return false;
}
SetInvalid( pRequest->ownerLoadIndex );
}
rspObject = pRequest->spObject;
Asset* pObject = rspObject;
if( pObject && ( pRequest->flags & LOAD_FLAG_ERROR ) )
{
pObject->SetFlags( Asset::FLAG_BROKEN );
}
if ( pObject->IsPackage() )
{
Package *pPackage = Reflect::AssertCast<Package>( pObject );
pPackage->SetLoader( this );
}
pRequest->spObject.Release();
HELIUM_ASSERT( IsInvalid( pRequest->asyncLoadId ) );
HELIUM_ASSERT( !pRequest->pAsyncLoadBuffer );
//pRequest->spTemplate.Release();
pRequest->spOwner.Release();
HELIUM_ASSERT( IsInvalid( pRequest->ownerLoadIndex ) );
//HELIUM_ASSERT( IsInvalid( pRequest->templateLoadIndex ) );
HELIUM_ASSERT( pObject || pRequest->pEntry );
HELIUM_TRACE(
TraceLevels::Debug,
"CachePackageLoader::TryFinishLoadObject(): Load request for \"%s\" (ID: %" PRIuSZ ") synced.\n",
*( pObject ? pObject->GetPath() : pRequest->pEntry->path ).ToString(),
requestId );
m_loadRequests.Remove( requestId );
m_loadRequestPool.Release( pRequest );
return true;
}
bool ProjectViewModel::OpenProject( const FilePath& project )
{
if ( !m_CurrentProject.Empty() )
{
CloseProject();
}
m_CurrentProject = project;
FileLocations::SetBaseDirectory( project );
// Make sure various module-specific heaps are initialized from the main thread before use.
InitEngineJobsDefaultHeap();
InitGraphicsJobsDefaultHeap();
// Register shutdown for general systems.
m_InitializerStack.Push( FileLocations::Shutdown );
m_InitializerStack.Push( Name::Shutdown );
m_InitializerStack.Push( AssetPath::Shutdown );
m_InitializerStack.Push( AsyncLoader::Startup, AsyncLoader::Shutdown );
// Asset cache management.
m_InitializerStack.Push( CacheManager::Startup, CacheManager::Shutdown );
m_InitializerStack.Push( Reflect::ObjectRefCountSupport::Shutdown );
m_InitializerStack.Push( Asset::Shutdown );
m_InitializerStack.Push( AssetType::Shutdown );
m_InitializerStack.Push( Reflect::Startup, Reflect::Shutdown );
m_InitializerStack.Push( Persist::Startup, Persist::Shutdown );
m_InitializerStack.Push( LooseAssetLoader::Startup, LooseAssetLoader::Shutdown );
m_InitializerStack.Push( AssetPreprocessor::Startup, AssetPreprocessor::Shutdown );
AssetPreprocessor* pAssetPreprocessor = AssetPreprocessor::GetInstance();
HELIUM_ASSERT( pAssetPreprocessor );
PlatformPreprocessor* pPlatformPreprocessor = new PcPreprocessor;
HELIUM_ASSERT( pPlatformPreprocessor );
pAssetPreprocessor->SetPlatformPreprocessor( Cache::PLATFORM_PC, pPlatformPreprocessor );
m_InitializerStack.Push( AssetTracker::Startup, AssetTracker::Shutdown );
m_InitializerStack.Push( ThreadSafeAssetTrackerListener::Startup, ThreadSafeAssetTrackerListener::Shutdown );
ThreadSafeAssetTrackerListener::GetInstance()->e_AssetLoaded.AddMethod( this, &ProjectViewModel::OnAssetLoaded );
ThreadSafeAssetTrackerListener::GetInstance()->e_AssetChanged.AddMethod( this, &ProjectViewModel::OnAssetChanged );
m_InitializerStack.Push( Config::Startup, Config::Shutdown );
HELIUM_ASSERT( AssetLoader::GetInstance() );
AssetLoader::GetInstance()->LoadObject<SystemDefinition>( "/Editor:System", m_pEditorSystemDefinition );
if ( HELIUM_VERIFY( m_pEditorSystemDefinition ) )
{
m_pEditorSystemDefinition->Initialize();
}
else
{
HELIUM_TRACE( TraceLevels::Error, "InitializeEditorSystem(): Could not find SystemDefinition. LoadObject on '/Editor:System' failed.\n" );
}
Components::Startup( m_pEditorSystemDefinition.Get() );
// Engine configuration.
Config* pConfig = Config::GetInstance();
HELIUM_ASSERT( pConfig );
AssetLoader* pAssetLoader = AssetLoader::GetInstance();
HELIUM_ASSERT( pAssetLoader );
pConfig->BeginLoad();
while( !pConfig->TryFinishLoad() )
{
pAssetLoader->Tick();
}
ConfigPc::SaveUserConfig();
#if HELIUM_OS_WIN
m_Engine.Initialize( &wxGetApp().GetFrame()->GetSceneManager(), GetHwndOf( wxGetApp().GetFrame() ) );
#else
m_Engine.Initialize( &wxGetApp().GetFrame()->GetSceneManager(), NULL );
#endif
ForciblyFullyLoadedPackageManager::GetInstance()->e_AssetForciblyLoadedEvent.AddMethod( this, &ProjectViewModel::OnAssetEditable );
return true;
}
/// Update during the package preload process.
void LoosePackageLoader::TickPreload()
{
HELIUM_ASSERT( m_startPreloadCounter != 0 );
HELIUM_ASSERT( m_preloadedCounter == 0 );
AsyncLoader& rAsyncLoader = AsyncLoader::GetStaticInstance();
bool bAllFileRequestsDone = true;
// Walk through every load request
for (size_t i = 0; i < m_fileReadRequests.GetSize();)
{
FileReadRequest &rRequest = m_fileReadRequests[i];
HELIUM_ASSERT(rRequest.asyncLoadId);
HELIUM_ASSERT(rRequest.pLoadBuffer);
size_t bytes_read = 0;
if (!rAsyncLoader.TrySyncRequest(rRequest.asyncLoadId, bytes_read))
{
// Havn't finished reading yet, move on to next entry
bAllFileRequestsDone = false;
++i;
continue;
}
HELIUM_ASSERT(bytes_read == rRequest.expectedSize);
if( IsInvalid( bytes_read ) )
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failed to read the contents of async load request \"%d\".\n" ),
rRequest.asyncLoadId );
}
else if( bytes_read != rRequest.expectedSize)
{
HELIUM_TRACE(
TraceLevels::Warning,
( TXT( "LoosePackageLoader: Attempted to read %" ) PRIuSZ TXT( " bytes from package file \"%s\", " )
TXT( "but only %" ) PRIuSZ TXT( " bytes were read.\n" ) ),
rRequest.expectedSize,
bytes_read );
}
else
{
HELIUM_ASSERT( rRequest.expectedSize < ~static_cast<size_t>( 0 ) );
// the name is deduced from the file name (bad idea to store it in the file)
Name name ( m_fileReadRequests[i].filePath.Basename().c_str() );
// read some preliminary data from the json
struct PreliminaryObjectHandler : rapidjson::BaseReaderHandler<>
{
Helium::Name typeName;
Helium::String templatePath;
bool templateIsNext;
PreliminaryObjectHandler()
: typeName( ENullName () )
, templatePath( "" )
{
templateIsNext = false;
}
void String(const Ch* chars, rapidjson::SizeType length, bool copy)
{
if ( typeName.IsEmpty() )
{
typeName.Set( Helium::String ( chars, length ) );
return;
}
if ( templatePath.IsEmpty() )
{
Helium::String str ( chars, length );
if ( templateIsNext )
{
templatePath = str;
templateIsNext = false;
return;
}
else
{
if ( str == "m_spTemplate" )
{
templateIsNext = true;
return;
}
}
}
}
void StartObject() { Default(); }
void EndObject( rapidjson::SizeType ) { Default(); }
} handler;
// non destructive in-place stream helper
rapidjson::StringStream stream ( static_cast< char* >( rRequest.pLoadBuffer ) );
// the main reader object
rapidjson::Reader reader;
if ( reader.Parse< rapidjson::kParseDefaultFlags >( stream, handler ) )
{
SerializedObjectData* pObjectData = m_objects.New();
HELIUM_ASSERT( pObjectData );
HELIUM_VERIFY( pObjectData->objectPath.Set( name, false, m_packagePath ) );
pObjectData->templatePath.Set( handler.templatePath );
pObjectData->typeName = handler.typeName;
pObjectData->filePath = rRequest.filePath;
pObjectData->fileTimeStamp = rRequest.fileTimestamp;
pObjectData->bMetadataGood = true;
HELIUM_TRACE(
TraceLevels::Debug,
TXT( "LoosePackageLoader: Success reading preliminary data for object '%s' from file '%s'.\n" ),
*name,
rRequest.filePath.c_str() );
}
else
{
HELIUM_TRACE(
TraceLevels::Error,
TXT( "LoosePackageLoader: Failure reading preliminary data for object '%s' from file '%s': %s\n" ),
*name,
rRequest.filePath.c_str(),
reader.GetParseError() );
}
}
// We're finished with this load, so deallocate memory and get rid of the request
DefaultAllocator().Free( rRequest.pLoadBuffer );
rRequest.pLoadBuffer = NULL;
SetInvalid(rRequest.asyncLoadId);
m_fileReadRequests.RemoveSwap(i);
}
// Wait for the parent package to finish loading.
AssetPtr spParentPackage;
if( IsValid( m_parentPackageLoadId ) )
{
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
if( !pAssetLoader->TryFinishLoad( m_parentPackageLoadId, spParentPackage ) )
{
return;
}
SetInvalid( m_parentPackageLoadId );
// Package loading should not fail. If it does, this is a sign of a potentially serious issue.
HELIUM_ASSERT( spParentPackage );
}
// Everything beyond this point "finalizes" the package preload, so stop here if we aren't ready to go
if (!bAllFileRequestsDone)
{
return;
}
// Create the package object if it does not yet exist.
Package* pPackage = m_spPackage;
if( !pPackage )
{
HELIUM_ASSERT( spParentPackage ? !m_packagePath.GetParent().IsEmpty() : m_packagePath.GetParent().IsEmpty() );
HELIUM_VERIFY( Asset::Create< Package >( m_spPackage, m_packagePath.GetName(), spParentPackage ) );
pPackage = m_spPackage;
HELIUM_ASSERT( pPackage );
pPackage->SetLoader( this );
}
HELIUM_ASSERT( pPackage->GetLoader() == this );
FilePath packageDirectoryPath;
if ( !FileLocations::GetDataDirectory( packageDirectoryPath ) )
{
HELIUM_TRACE( TraceLevels::Error, TXT( "LoosePackageLoader::TickPreload(): Could not get data directory.\n" ) );
return;
}
packageDirectoryPath += m_packagePath.ToFilePathString().GetData();
packageDirectoryPath += TXT("/");
DirectoryIterator packageDirectory( packageDirectoryPath );
for( ; !packageDirectory.IsDone(); packageDirectory.Next() )
{
const DirectoryIteratorItem& item = packageDirectory.GetItem();
if ( !item.m_Path.IsFile() )
{
continue;
}
Name objectName( item.m_Path.Filename().c_str() );
String objectNameString( item.m_Path.Filename().c_str() );
size_t objectIndex = FindObjectByName( objectName );
if( objectIndex != Invalid< size_t >() )
{
m_objects[ objectIndex ].fileTimeStamp = Helium::Max(
m_objects[ objectIndex ].fileTimeStamp,
static_cast< int64_t >( packageDirectory.GetItem().m_ModTime ) );
continue;
}
// Check the extension to see if the file is supported by one of the resource handlers.
ResourceHandler* pBestHandler = ResourceHandler::GetBestResourceHandlerForFile( objectNameString );
if( pBestHandler )
{
// File extension matches a supported source asset type, so add it to the object list.
const AssetType* pResourceType = pBestHandler->GetResourceType();
HELIUM_ASSERT( pResourceType );
HELIUM_TRACE(
TraceLevels::Debug,
( TXT( "LoosePackageLoader: Registered source asset file \"%s\" as as instance of resource " )
TXT( "type \"%s\" in package \"%s\".\n" ) ),
*objectNameString,
*pResourceType->GetName(),
*m_packagePath.ToString() );
SerializedObjectData* pObjectData = m_objects.New();
HELIUM_ASSERT( pObjectData );
HELIUM_VERIFY( pObjectData->objectPath.Set( objectName, false, m_packagePath ) );
pObjectData->typeName = pResourceType->GetName();
pObjectData->templatePath.Clear();
pObjectData->filePath.Clear();
pObjectData->fileTimeStamp = packageDirectory.GetItem().m_ModTime;
pObjectData->bMetadataGood = true;
}
else
{
HELIUM_TRACE(
TraceLevels::Debug,
( TXT( "LoosePackageLoader: Did not recognize \"%s\" as as instance of resource " )
TXT( "in package \"%s\".\n" ) ),
*objectNameString,
*m_packagePath.ToString() );
for ( AssetType::ConstIterator iter = AssetType::GetTypeBegin();
iter != AssetType::GetTypeEnd(); ++iter)
{
HELIUM_TRACE(
TraceLevels::Info,
TXT( " - %s\n" ),
*iter->GetName() );
}
}
}
// Package preloading is now complete.
pPackage->SetFlags( Asset::FLAG_PRELOADED | Asset::FLAG_LINKED );
pPackage->ConditionalFinalizeLoad();
AtomicExchangeRelease( m_preloadedCounter, 1 );
LooseAssetLoader::OnPackagePreloaded( this );
}
int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, LPTSTR /*lpCmdLine*/, int nCmdShow )
{
ForceLoadComponentsDll();
#if HELIUM_TOOLS
ForceLoadEditorSupportDll();
#endif
HELIUM_TRACE_SET_LEVEL( TraceLevels::Debug );
Timer::StaticInitialize();
#if !HELIUM_RELEASE && !HELIUM_PROFILE
Helium::InitializeSymbols();
#endif
AsyncLoader::GetStaticInstance().Initialize();
FilePath baseDirectory;
if ( !FileLocations::GetBaseDirectory( baseDirectory ) )
{
HELIUM_TRACE( TraceLevels::Error, TXT( "Could not get base directory." ) );
return -1;
}
HELIUM_VERIFY( CacheManager::InitializeStaticInstance( baseDirectory ) );
Helium::Bullet::Initialize();
int resultCode = -1;
{
Reflect::Initialize();
Helium::Components::Initialize();
Helium::TaskScheduler::CalculateSchedule();
#if HELIUM_TOOLS
#endif
InitEngineJobsDefaultHeap();
InitGraphicsJobsDefaultHeap();
InitTestJobsDefaultHeap();
#if HELIUM_TOOLS
//HELIUM_VERIFY( LooseAssetLoader::InitializeStaticInstance() );
HELIUM_VERIFY( LooseAssetLoader::InitializeStaticInstance() );
AssetPreprocessor* pAssetPreprocessor = AssetPreprocessor::CreateStaticInstance();
HELIUM_ASSERT( pAssetPreprocessor );
PlatformPreprocessor* pPlatformPreprocessor = new PcPreprocessor;
HELIUM_ASSERT( pPlatformPreprocessor );
pAssetPreprocessor->SetPlatformPreprocessor( Cache::PLATFORM_PC, pPlatformPreprocessor );
#else
HELIUM_VERIFY( CacheAssetLoader::InitializeStaticInstance() );
#endif
#if !GTEST
AssetLoader* gAssetLoader = NULL;
#endif
gAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( gAssetLoader );
Config& rConfig = Config::GetStaticInstance();
rConfig.BeginLoad();
while( !rConfig.TryFinishLoad() )
{
gAssetLoader->Tick();
}
#if HELIUM_TOOLS
ConfigPc::SaveUserConfig();
#endif
uint32_t displayWidth;
uint32_t displayHeight;
//bool bFullscreen;
bool bVsync;
{
StrongPtr< GraphicsConfig > spGraphicsConfig(
rConfig.GetConfigObject< GraphicsConfig >( Name( TXT( "GraphicsConfig" ) ) ) );
HELIUM_ASSERT( spGraphicsConfig );
displayWidth = spGraphicsConfig->GetWidth();
displayHeight = spGraphicsConfig->GetHeight();
//bFullscreen = spGraphicsConfig->GetFullscreen();
bVsync = spGraphicsConfig->GetVsync();
}
WNDCLASSEXW windowClass;
windowClass.cbSize = sizeof( windowClass );
windowClass.style = 0;
windowClass.lpfnWndProc = WindowProc;
windowClass.cbClsExtra = 0;
windowClass.cbWndExtra = 0;
windowClass.hInstance = hInstance;
windowClass.hIcon = NULL;
windowClass.hCursor = NULL;
windowClass.hbrBackground = NULL;
windowClass.lpszMenuName = NULL;
windowClass.lpszClassName = L"HeliumTestAppClass";
windowClass.hIconSm = NULL;
HELIUM_VERIFY( RegisterClassEx( &windowClass ) );
WindowData windowData;
windowData.hMainWnd = NULL;
windowData.hSubWnd = NULL;
windowData.bProcessMessages = true;
windowData.bShutdownRendering = false;
windowData.resultCode = 0;
DWORD dwStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU;
RECT windowRect;
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = static_cast< LONG >( displayWidth );
windowRect.bottom = static_cast< LONG >( displayHeight );
HELIUM_VERIFY( AdjustWindowRect( &windowRect, dwStyle, FALSE ) );
HWND hMainWnd = ::CreateWindowW(
L"HeliumTestAppClass",
L"Helium TestApp",
dwStyle,
CW_USEDEFAULT,
CW_USEDEFAULT,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL );
HELIUM_ASSERT( hMainWnd );
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = static_cast< LONG >( displayWidth );
windowRect.bottom = static_cast< LONG >( displayHeight );
HELIUM_VERIFY( AdjustWindowRect( &windowRect, dwStyle, FALSE ) );
#if MULTI_WINDOW
HWND hSubWnd = ::CreateWindowW(
L"HeliumTestAppClass",
L"Helium TestApp (second view)",
dwStyle,
CW_USEDEFAULT,
CW_USEDEFAULT,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL );
HELIUM_ASSERT( hSubWnd );
#endif
windowData.hMainWnd = hMainWnd;
SetWindowLongPtr( hMainWnd, GWLP_USERDATA, reinterpret_cast< LONG_PTR >( &windowData ) );
ShowWindow( hMainWnd, nCmdShow );
UpdateWindow( hMainWnd );
#if MULTI_WINDOW
windowData.hSubWnd = hSubWnd;
SetWindowLongPtr( hSubWnd, GWLP_USERDATA, reinterpret_cast< LONG_PTR >( &windowData ) );
ShowWindow( hSubWnd, nCmdShow );
UpdateWindow( hSubWnd );
#endif
HELIUM_VERIFY( D3D9Renderer::CreateStaticInstance() );
Renderer* pRenderer = Renderer::GetStaticInstance();
HELIUM_ASSERT( pRenderer );
pRenderer->Initialize();
Renderer::ContextInitParameters contextInitParams;
contextInitParams.pWindow = hMainWnd;
contextInitParams.displayWidth = displayWidth;
contextInitParams.displayHeight = displayHeight;
contextInitParams.bVsync = bVsync;
HELIUM_VERIFY( pRenderer->CreateMainContext( contextInitParams ) );
#if MULTI_WINDOW
contextInitParams.pWindow = hSubWnd;
RRenderContextPtr spSubRenderContext = pRenderer->CreateSubContext( contextInitParams );
HELIUM_ASSERT( spSubRenderContext );
#endif
Input::Initialize(&hMainWnd, false);
{
AssetPath prePassShaderPath;
HELIUM_VERIFY( prePassShaderPath.Set(
HELIUM_PACKAGE_PATH_CHAR_STRING TXT( "Shaders" ) HELIUM_OBJECT_PATH_CHAR_STRING TXT( "PrePass.hlsl" ) ) );
AssetPtr spPrePassShader;
HELIUM_VERIFY( AssetLoader::GetStaticInstance()->LoadObject( prePassShaderPath, spPrePassShader ) );
HELIUM_ASSERT( spPrePassShader.Get() );
}
RenderResourceManager& rRenderResourceManager = RenderResourceManager::GetStaticInstance();
rRenderResourceManager.Initialize();
rRenderResourceManager.UpdateMaxViewportSize( displayWidth, displayHeight );
//// Create a scene definition
SceneDefinitionPtr spSceneDefinition;
gAssetLoader->LoadObject( AssetPath( TXT( "/ExampleGames/Empty/Scenes/TestScene:SceneDefinition" ) ), spSceneDefinition );
EntityDefinitionPtr spEntityDefinition;
gAssetLoader->LoadObject( AssetPath( TXT( "/ExampleGames/Empty/Scenes/TestScene:TestBull_Entity" ) ), spEntityDefinition );
DynamicDrawer& rDynamicDrawer = DynamicDrawer::GetStaticInstance();
HELIUM_VERIFY( rDynamicDrawer.Initialize() );
RRenderContextPtr spMainRenderContext = pRenderer->GetMainContext();
HELIUM_ASSERT( spMainRenderContext );
WorldManager& rWorldManager = WorldManager::GetStaticInstance();
HELIUM_VERIFY( rWorldManager.Initialize() );
// Create a world
WorldPtr spWorld( rWorldManager.CreateWorld( spSceneDefinition ) );
HELIUM_ASSERT( spWorld );
HELIUM_TRACE( TraceLevels::Info, TXT( "Created world \"%s\".\n" ), *spSceneDefinition->GetPath().ToString() );
//Slice *pRootSlice = spWorld->GetRootSlice();
//Entity *pEntity = pRootSlice->CreateEntity(spEntityDefinition);
GraphicsScene* pGraphicsScene = spWorld->GetComponents().GetFirst<GraphicsManagerComponent>()->GetGraphicsScene();
HELIUM_ASSERT( pGraphicsScene );
GraphicsSceneView* pMainSceneView = NULL;
if( pGraphicsScene )
{
uint32_t mainSceneViewId = pGraphicsScene->AllocateSceneView();
if( IsValid( mainSceneViewId ) )
{
float32_t aspectRatio =
static_cast< float32_t >( displayWidth ) / static_cast< float32_t >( displayHeight );
RSurface* pDepthStencilSurface = rRenderResourceManager.GetDepthStencilSurface();
HELIUM_ASSERT( pDepthStencilSurface );
pMainSceneView = pGraphicsScene->GetSceneView( mainSceneViewId );
HELIUM_ASSERT( pMainSceneView );
pMainSceneView->SetRenderContext( spMainRenderContext );
pMainSceneView->SetDepthStencilSurface( pDepthStencilSurface );
pMainSceneView->SetAspectRatio( aspectRatio );
pMainSceneView->SetViewport( 0, 0, displayWidth, displayHeight );
pMainSceneView->SetClearColor( Color( 0x00202020 ) );
//spMainCamera->SetSceneViewId( mainSceneViewId );
#if MULTI_WINDOW
uint32_t subSceneViewId = pGraphicsScene->AllocateSceneView();
if( IsValid( subSceneViewId ) )
{
GraphicsSceneView* pSubSceneView = pGraphicsScene->GetSceneView( subSceneViewId );
HELIUM_ASSERT( pSubSceneView );
pSubSceneView->SetRenderContext( spSubRenderContext );
pSubSceneView->SetDepthStencilSurface( pDepthStencilSurface );
pSubSceneView->SetAspectRatio( aspectRatio );
pSubSceneView->SetViewport( 0, 0, displayWidth, displayHeight );
pSubSceneView->SetClearColor( Color( 0x00202020 ) );
//spSubCamera->SetSceneViewId( subSceneViewId );
}
#endif
}
#if !HELIUM_RELEASE && !HELIUM_PROFILE
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "CACHING" ) ),
Color( 0xff00ff00 ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
rSceneDrawer.DrawScreenText(
21,
20,
String( TXT( "CACHING" ) ),
Color( 0xff00ff00 ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
//rSceneDrawer.Draw
//Helium::DynamicDrawer &drawer = DynamicDrawer::GetStaticInstance();
//drawer.
#endif
}
rWorldManager.Update();
float time = 0.0f;
#if MULTI_WINDOW
spSubRenderContext.Release();
#endif
spMainRenderContext.Release();
Helium::StrongPtr<Helium::Texture2d> texture;
gAssetLoader->LoadObject( AssetPath( TXT( "/Textures:Triangle.png" ) ), texture);
Helium::RTexture2d *rTexture2d = texture->GetRenderResource2d();
while( windowData.bProcessMessages )
{
#if GRAPHICS_SCENE_BUFFERED_DRAWER
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "RUNNING" ) ),
Color( 0xffffffff ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
rSceneDrawer.DrawScreenText(
21,
20,
String( TXT( "RUNNING" ) ),
Color( 0xffffffff ),
RenderResourceManager::DEBUG_FONT_SIZE_LARGE );
time += 0.01f;
DynamicArray<SimpleVertex> verticesU;
verticesU.New( -100.0f, -100.0f, 750.0f );
verticesU.New( 100.0f, -100.0f, 750.0f );
verticesU.New( 100.0f, 100.0f, 750.0f );
verticesU.New( -100.0f, 100.0f, 750.0f );
rSceneDrawer.DrawLineList( verticesU.GetData(), static_cast<uint32_t>( verticesU.GetSize() ) );
DynamicArray<SimpleTexturedVertex> verticesT;
verticesT.New( Simd::Vector3( -100.0f, 100.0f, 750.0f ), Simd::Vector2( 0.0f, 0.0f ) );
verticesT.New( Simd::Vector3( 100.0f, 100.0f, 750.0f ), Simd::Vector2( 1.0f, 0.0f ) );
verticesT.New( Simd::Vector3( -100.0f, -100.0f, 750.0f ), Simd::Vector2( 0.0f, 1.0f ) );
verticesT.New( Simd::Vector3( 100.0f, -100.0f, 750.0f ), Simd::Vector2( 1.0f, 1.0f ) );
//rSceneDrawer.DrawTextured(
// RENDERER_PRIMITIVE_TYPE_TRIANGLE_STRIP,
// verticesT.GetData(),
// verticesT.GetSize(),
// NULL,
// 2,
// rTexture2d, Helium::Color(1.0f, 1.0f, 1.0f, 1.0f), Helium::RenderResourceManager::RASTERIZER_STATE_DEFAULT, Helium::RenderResourceManager::DEPTH_STENCIL_STATE_NONE);
//rSceneDrawer.DrawTexturedQuad(rTexture2d);
Helium::Simd::Matrix44 transform = Helium::Simd::Matrix44::IDENTITY;
Simd::Vector3 location(0.0f, 400.0f, 0.0f);
Simd::Quat rotation(Helium::Simd::Vector3::BasisZ, time);
Simd::Vector3 scale(1000.0f, 1000.0f, 1000.0f);
transform.SetRotationTranslationScaling(rotation, location, scale);
rSceneDrawer.DrawTexturedQuad(rTexture2d, transform, Simd::Vector2(0.0f, 0.0f), Simd::Vector2(0.5f, 0.5f));
#endif
//Helium::Simd::Vector3 up = Simd::Vector3::BasisY;
////Helium::Simd::Vector3 eye(5000.0f * sin(time), 0.0f, 5000.0f * cos(time));
//Helium::Simd::Vector3 eye(0.0f, 0.0f, -1000.0f);
//Helium::Simd::Vector3 forward = Simd::Vector3::Zero - eye;
//forward.Normalize();
////pMainSceneView->SetClearColor( Color( 0xffffffff ) );
//pMainSceneView->SetView(eye, forward, up);
if (Input::IsKeyDown(Input::KeyCodes::KC_A))
{
HELIUM_TRACE( TraceLevels::Info, TXT( "A is down" ) );
}
if (Input::IsKeyDown(Input::KeyCodes::KC_ESCAPE))
{
HELIUM_TRACE( TraceLevels::Info, TXT( "Exiting" ) );
break;
}
MSG message;
if( PeekMessage( &message, NULL, 0, 0, PM_REMOVE ) )
{
TranslateMessage( &message );
DispatchMessage( &message );
if( windowData.bShutdownRendering )
{
if( spWorld )
{
spWorld->Shutdown();
}
spWorld.Release();
WorldManager::DestroyStaticInstance();
spSceneDefinition.Release();
spEntityDefinition.Release();
DynamicDrawer::DestroyStaticInstance();
RenderResourceManager::DestroyStaticInstance();
Renderer::DestroyStaticInstance();
break;
}
if( message.message == WM_QUIT )
{
windowData.bProcessMessages = false;
windowData.resultCode = static_cast< int >( message.wParam );
resultCode = static_cast< int >( message.wParam );
break;
}
}
rWorldManager.Update();
#if GRAPHICS_SCENE_BUFFERED_DRAWER
if( pGraphicsScene )
{
BufferedDrawer& rSceneDrawer = pGraphicsScene->GetSceneBufferedDrawer();
rSceneDrawer.DrawScreenText(
20,
20,
String( TXT( "Debug text test!" ) ),
Color( 0xffffffff ) );
}
#endif
}
if( spWorld )
{
spWorld->Shutdown();
}
spWorld.Release();
}
WorldManager::DestroyStaticInstance();
DynamicDrawer::DestroyStaticInstance();
RenderResourceManager::DestroyStaticInstance();
Helium::Input::Cleanup();
Renderer::DestroyStaticInstance();
JobManager::DestroyStaticInstance();
Config::DestroyStaticInstance();
#if HELIUM_TOOLS
AssetPreprocessor::DestroyStaticInstance();
#endif
AssetLoader::DestroyStaticInstance();
CacheManager::DestroyStaticInstance();
Helium::Components::Cleanup();
Reflect::Cleanup();
AssetType::Shutdown();
Asset::Shutdown();
Reflect::ObjectRefCountSupport::Shutdown();
Helium::Bullet::Cleanup();
AssetPath::Shutdown();
Name::Shutdown();
FileLocations::Shutdown();
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#if HELIUM_ENABLE_MEMORY_TRACKING
DynamicMemoryHeap::LogMemoryStats();
ThreadLocalStackAllocator::ReleaseMemoryHeap();
#endif
return resultCode;
}
/// Initialize all resources provided by this manager.
///
/// @see Cleanup(), PostConfigUpdate()
bool RenderResourceManager::Initialize()
{
// Release any existing resources.
Cleanup();
// Get the renderer and graphics configuration.
Renderer* pRenderer = Renderer::GetInstance();
if ( !pRenderer )
{
return false;
}
Config* pConfig = Config::GetInstance();
if ( !HELIUM_VERIFY( pConfig ) )
{
return false;
}
StrongPtr< GraphicsConfig > spGraphicsConfig( pConfig->GetConfigObject< GraphicsConfig >( Name( "GraphicsConfig" ) ) );
if ( !spGraphicsConfig )
{
HELIUM_TRACE( TraceLevels::Error, "RenderResourceManager::Initialize(): Initialization failed; missing GraphicsConfig.\n" );
return false;
}
// Create the standard rasterizer states.
RRasterizerState::Description rasterizerStateDesc;
rasterizerStateDesc.fillMode = RENDERER_FILL_MODE_SOLID;
rasterizerStateDesc.cullMode = RENDERER_CULL_MODE_BACK;
rasterizerStateDesc.winding = RENDERER_WINDING_CLOCKWISE;
rasterizerStateDesc.depthBias = 0;
rasterizerStateDesc.slopeScaledDepthBias = 0.0f;
m_rasterizerStates[RASTERIZER_STATE_DEFAULT] = pRenderer->CreateRasterizerState( rasterizerStateDesc );
HELIUM_ASSERT( m_rasterizerStates[RASTERIZER_STATE_DEFAULT] );
rasterizerStateDesc.cullMode = RENDERER_CULL_MODE_NONE;
m_rasterizerStates[RASTERIZER_STATE_DOUBLE_SIDED] = pRenderer->CreateRasterizerState( rasterizerStateDesc );
HELIUM_ASSERT( m_rasterizerStates[RASTERIZER_STATE_DOUBLE_SIDED] );
rasterizerStateDesc.depthBias = 1;
rasterizerStateDesc.slopeScaledDepthBias = 2.0f;
m_rasterizerStates[RASTERIZER_STATE_SHADOW_DEPTH] = pRenderer->CreateRasterizerState( rasterizerStateDesc );
HELIUM_ASSERT( m_rasterizerStates[RASTERIZER_STATE_SHADOW_DEPTH] );
rasterizerStateDesc.depthBias = 0;
rasterizerStateDesc.slopeScaledDepthBias = 0.0f;
rasterizerStateDesc.fillMode = RENDERER_FILL_MODE_WIREFRAME;
m_rasterizerStates[RASTERIZER_STATE_WIREFRAME_DOUBLE_SIDED] = pRenderer->CreateRasterizerState(
rasterizerStateDesc );
HELIUM_ASSERT( m_rasterizerStates[RASTERIZER_STATE_WIREFRAME_DOUBLE_SIDED] );
rasterizerStateDesc.cullMode = RENDERER_CULL_MODE_BACK;
m_rasterizerStates[RASTERIZER_STATE_WIREFRAME] = pRenderer->CreateRasterizerState( rasterizerStateDesc );
HELIUM_ASSERT( m_rasterizerStates[RASTERIZER_STATE_WIREFRAME] );
// Create the standard blend states.
RBlendState::Description blendStateDesc;
blendStateDesc.bBlendEnable = false;
m_blendStates[BLEND_STATE_OPAQUE] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_OPAQUE] );
blendStateDesc.colorWriteMask = 0;
m_blendStates[BLEND_STATE_NO_COLOR] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_NO_COLOR] );
blendStateDesc.colorWriteMask = RENDERER_COLOR_WRITE_MASK_FLAG_ALL;
blendStateDesc.bBlendEnable = true;
blendStateDesc.sourceFactor = RENDERER_BLEND_FACTOR_SRC_ALPHA;
blendStateDesc.destinationFactor = RENDERER_BLEND_FACTOR_INV_SRC_ALPHA;
blendStateDesc.function = RENDERER_BLEND_FUNCTION_ADD;
m_blendStates[BLEND_STATE_TRANSPARENT] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_TRANSPARENT] );
blendStateDesc.sourceFactor = RENDERER_BLEND_FACTOR_ONE;
blendStateDesc.destinationFactor = RENDERER_BLEND_FACTOR_ONE;
m_blendStates[BLEND_STATE_ADDITIVE] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_ADDITIVE] );
blendStateDesc.function = RENDERER_BLEND_FUNCTION_REVERSE_SUBTRACT;
m_blendStates[BLEND_STATE_SUBTRACTIVE] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_SUBTRACTIVE] );
blendStateDesc.sourceFactor = RENDERER_BLEND_FACTOR_DEST_COLOR;
blendStateDesc.destinationFactor = RENDERER_BLEND_FACTOR_ZERO;
blendStateDesc.function = RENDERER_BLEND_FUNCTION_ADD;
m_blendStates[BLEND_STATE_MODULATE] = pRenderer->CreateBlendState( blendStateDesc );
HELIUM_ASSERT( m_blendStates[BLEND_STATE_MODULATE] );
// Create the standard depth/stencil states.
RDepthStencilState::Description depthStateDesc;
depthStateDesc.stencilWriteMask = 0;
depthStateDesc.bStencilTestEnable = false;
depthStateDesc.depthFunction = RENDERER_COMPARE_FUNCTION_LESS_EQUAL;
depthStateDesc.bDepthTestEnable = true;
depthStateDesc.bDepthWriteEnable = true;
m_depthStencilStates[DEPTH_STENCIL_STATE_DEFAULT] = pRenderer->CreateDepthStencilState( depthStateDesc );
HELIUM_ASSERT( m_depthStencilStates[DEPTH_STENCIL_STATE_DEFAULT] );
depthStateDesc.bDepthWriteEnable = false;
m_depthStencilStates[DEPTH_STENCIL_STATE_TEST_ONLY] = pRenderer->CreateDepthStencilState( depthStateDesc );
HELIUM_ASSERT( m_depthStencilStates[DEPTH_STENCIL_STATE_TEST_ONLY] );
depthStateDesc.bDepthTestEnable = false;
m_depthStencilStates[DEPTH_STENCIL_STATE_NONE] = pRenderer->CreateDepthStencilState( depthStateDesc );
HELIUM_ASSERT( m_depthStencilStates[DEPTH_STENCIL_STATE_NONE] );
// Create the standard sampler states that are not dependent on configuration settings.
RSamplerState::Description samplerStateDesc;
samplerStateDesc.filter = RENDERER_TEXTURE_FILTER_MIN_POINT_MAG_POINT_MIP_POINT;
samplerStateDesc.addressModeW = RENDERER_TEXTURE_ADDRESS_MODE_CLAMP;
samplerStateDesc.mipLodBias = 0;
samplerStateDesc.maxAnisotropy = spGraphicsConfig->GetMaxAnisotropy();
for ( size_t addressModeIndex = 0; addressModeIndex < RENDERER_TEXTURE_ADDRESS_MODE_MAX; ++addressModeIndex )
{
ERendererTextureAddressMode addressMode = static_cast<ERendererTextureAddressMode>( addressModeIndex );
samplerStateDesc.addressModeU = addressMode;
samplerStateDesc.addressModeV = addressMode;
samplerStateDesc.addressModeW = addressMode;
m_samplerStates[TEXTURE_FILTER_POINT][addressModeIndex] = pRenderer->CreateSamplerState( samplerStateDesc );
HELIUM_ASSERT( m_samplerStates[TEXTURE_FILTER_POINT][addressModeIndex] );
}
// Create the standard set of mesh vertex descriptions.
RVertexDescription::Element vertexElements[6];
vertexElements[0].type = RENDERER_VERTEX_DATA_TYPE_FLOAT32_3;
vertexElements[0].semantic = RENDERER_VERTEX_SEMANTIC_POSITION;
vertexElements[0].semanticIndex = 0;
vertexElements[0].bufferIndex = 0;
vertexElements[1].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[1].semantic = RENDERER_VERTEX_SEMANTIC_COLOR;
vertexElements[1].semanticIndex = 0;
vertexElements[1].bufferIndex = 0;
vertexElements[2].type = RENDERER_VERTEX_DATA_TYPE_FLOAT16_2;
vertexElements[2].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[2].semanticIndex = 0;
vertexElements[2].bufferIndex = 0;
vertexElements[3].type = RENDERER_VERTEX_DATA_TYPE_FLOAT32_2;
vertexElements[3].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[3].semanticIndex = 1;
vertexElements[3].bufferIndex = 0;
m_spSimpleVertexDescription = pRenderer->CreateVertexDescription( vertexElements, 2 );
HELIUM_ASSERT( m_spSimpleVertexDescription );
m_spSimpleTexturedVertexDescription = pRenderer->CreateVertexDescription( vertexElements, 3 );
HELIUM_ASSERT( m_spSimpleTexturedVertexDescription );
m_spProjectedVertexDescription = pRenderer->CreateVertexDescription( vertexElements, 4 );
HELIUM_ASSERT( m_spProjectedVertexDescription );
vertexElements[1].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[1].semantic = RENDERER_VERTEX_SEMANTIC_NORMAL;
vertexElements[1].semanticIndex = 0;
vertexElements[1].bufferIndex = 0;
vertexElements[2].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[2].semantic = RENDERER_VERTEX_SEMANTIC_TANGENT;
vertexElements[2].semanticIndex = 0;
vertexElements[2].bufferIndex = 0;
vertexElements[3].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[3].semantic = RENDERER_VERTEX_SEMANTIC_COLOR;
vertexElements[3].semanticIndex = 0;
vertexElements[3].bufferIndex = 0;
vertexElements[4].type = RENDERER_VERTEX_DATA_TYPE_FLOAT16_2;
vertexElements[4].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[4].semanticIndex = 0;
vertexElements[4].bufferIndex = 0;
vertexElements[5].type = RENDERER_VERTEX_DATA_TYPE_FLOAT16_2;
vertexElements[5].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[5].semanticIndex = 1;
vertexElements[5].bufferIndex = 0;
m_staticMeshVertexDescriptions[0] = pRenderer->CreateVertexDescription( vertexElements, 5 );
HELIUM_ASSERT( m_staticMeshVertexDescriptions[0] );
m_staticMeshVertexDescriptions[1] = pRenderer->CreateVertexDescription( vertexElements, 6 );
HELIUM_ASSERT( m_staticMeshVertexDescriptions[1] );
vertexElements[1].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[1].semantic = RENDERER_VERTEX_SEMANTIC_BLENDWEIGHT;
vertexElements[1].semanticIndex = 0;
vertexElements[1].bufferIndex = 0;
vertexElements[2].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4;
vertexElements[2].semantic = RENDERER_VERTEX_SEMANTIC_BLENDINDICES;
vertexElements[2].semanticIndex = 0;
vertexElements[2].bufferIndex = 0;
vertexElements[3].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[3].semantic = RENDERER_VERTEX_SEMANTIC_NORMAL;
vertexElements[3].semanticIndex = 0;
vertexElements[3].bufferIndex = 0;
vertexElements[4].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[4].semantic = RENDERER_VERTEX_SEMANTIC_TANGENT;
vertexElements[4].semanticIndex = 0;
vertexElements[4].bufferIndex = 0;
vertexElements[5].type = RENDERER_VERTEX_DATA_TYPE_FLOAT16_2;
vertexElements[5].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[5].semanticIndex = 0;
vertexElements[5].bufferIndex = 0;
m_spSkinnedMeshVertexDescription = pRenderer->CreateVertexDescription( vertexElements, 6 );
HELIUM_ASSERT( m_spSkinnedMeshVertexDescription );
vertexElements[0].type = RENDERER_VERTEX_DATA_TYPE_FLOAT32_2;
vertexElements[0].semantic = RENDERER_VERTEX_SEMANTIC_POSITION;
vertexElements[0].semanticIndex = 0;
vertexElements[0].bufferIndex = 0;
vertexElements[1].type = RENDERER_VERTEX_DATA_TYPE_UINT8_4_NORM;
vertexElements[1].semantic = RENDERER_VERTEX_SEMANTIC_COLOR;
vertexElements[1].semanticIndex = 0;
vertexElements[1].bufferIndex = 0;
vertexElements[2].type = RENDERER_VERTEX_DATA_TYPE_FLOAT16_2;
vertexElements[2].semantic = RENDERER_VERTEX_SEMANTIC_TEXCOORD;
vertexElements[2].semanticIndex = 0;
vertexElements[2].bufferIndex = 0;
m_spScreenVertexDescription = pRenderer->CreateVertexDescription( vertexElements, 3 );
HELIUM_ASSERT( m_spScreenVertexDescription );
// Create configuration-dependent render resources.
PostConfigUpdate();
// Attempt to load the depth-only pre-pass shader.
// TODO: XXX TMC: Migrate to a more data-driven solution.
AssetLoader* pAssetLoader = AssetLoader::GetInstance();
HELIUM_ASSERT( pAssetLoader );
#ifdef HELIUM_DIRECT3D
AssetPath prePassShaderPath;
HELIUM_VERIFY( prePassShaderPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Shaders" HELIUM_OBJECT_PATH_CHAR_STRING "PrePass.hlsl" ) );
AssetPtr spPrePassShader;
HELIUM_VERIFY( pAssetLoader->LoadObject( prePassShaderPath, spPrePassShader ) );
Shader* pPrePassShader = Reflect::SafeCast< Shader >( spPrePassShader.Get() );
if ( HELIUM_VERIFY( pPrePassShader ) )
{
size_t loadId = pPrePassShader->BeginLoadVariant( RShader::TYPE_VERTEX, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pPrePassShader->TryFinishLoadVariant( loadId, m_spPrePassVertexShader ) )
{
pAssetLoader->Tick();
}
}
}
// Attempt to load the simple world-space, simple screen-space, and screen-space text shaders.
// TODO: XXX TMC: Migrate to a more data-driven solution.
AssetPath shaderPath;
HELIUM_VERIFY( shaderPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Shaders" HELIUM_OBJECT_PATH_CHAR_STRING "Simple.hlsl" ) );
AssetPtr spShader;
HELIUM_VERIFY( pAssetLoader->LoadObject( shaderPath, spShader ) );
Shader* pShader = Reflect::SafeCast< Shader >( spShader.Get() );
if ( HELIUM_VERIFY( pShader ) )
{
size_t loadId = pShader->BeginLoadVariant( RShader::TYPE_VERTEX, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spSimpleWorldSpaceVertexShader ) )
{
pAssetLoader->Tick();
}
}
loadId = pShader->BeginLoadVariant( RShader::TYPE_PIXEL, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spSimpleWorldSpacePixelShader ) )
{
pAssetLoader->Tick();
}
}
}
HELIUM_VERIFY( shaderPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Shaders" HELIUM_OBJECT_PATH_CHAR_STRING "ScreenSpaceTexture.hlsl" ) );
HELIUM_VERIFY( pAssetLoader->LoadObject( shaderPath, spShader ) );
pShader = Reflect::SafeCast< Shader >( spShader.Get() );
if ( HELIUM_VERIFY( pShader ) )
{
size_t loadId = pShader->BeginLoadVariant( RShader::TYPE_VERTEX, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spSimpleScreenSpaceVertexShader ) )
{
pAssetLoader->Tick();
}
}
loadId = pShader->BeginLoadVariant( RShader::TYPE_PIXEL, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spSimpleScreenSpacePixelShader ) )
{
pAssetLoader->Tick();
}
}
}
HELIUM_VERIFY( shaderPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Shaders" HELIUM_OBJECT_PATH_CHAR_STRING "ScreenText.hlsl" ) );
HELIUM_VERIFY( pAssetLoader->LoadObject( shaderPath, spShader ) );
pShader = Reflect::SafeCast< Shader >( spShader.Get() );
if ( HELIUM_VERIFY( pShader ) )
{
size_t loadId = pShader->BeginLoadVariant( RShader::TYPE_VERTEX, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spScreenTextVertexShader ) )
{
pAssetLoader->Tick();
}
}
loadId = pShader->BeginLoadVariant( RShader::TYPE_PIXEL, 0 );
HELIUM_ASSERT( IsValid( loadId ) );
if ( IsValid( loadId ) )
{
while ( !pShader->TryFinishLoadVariant( loadId, m_spScreenTextPixelShader ) )
{
pAssetLoader->Tick();
}
}
}
// Attempt to load the debug fonts.
// TODO: XXX TMC: Migrate to a more data-driven solution.
AssetPath fontPath;
AssetPtr spFont;
HELIUM_VERIFY( fontPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Fonts" HELIUM_OBJECT_PATH_CHAR_STRING "DebugSmall" ) );
HELIUM_VERIFY( pAssetLoader->LoadObject( fontPath, spFont ) );
m_debugFonts[DEBUG_FONT_SIZE_SMALL] = Reflect::SafeCast< Font >( spFont.Get() );
spFont.Release();
HELIUM_VERIFY( fontPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Fonts" HELIUM_OBJECT_PATH_CHAR_STRING "DebugMedium" ) );
HELIUM_VERIFY( pAssetLoader->LoadObject( fontPath, spFont ) );
m_debugFonts[DEBUG_FONT_SIZE_MEDIUM] = Reflect::SafeCast< Font >( spFont.Get() );
spFont.Release();
HELIUM_VERIFY( fontPath.Set( HELIUM_PACKAGE_PATH_CHAR_STRING "Fonts" HELIUM_OBJECT_PATH_CHAR_STRING "DebugLarge" ) );
HELIUM_VERIFY( pAssetLoader->LoadObject( fontPath, spFont ) );
m_debugFonts[DEBUG_FONT_SIZE_LARGE] = Reflect::SafeCast< Font >( spFont.Get() );
spFont.Release();
#endif
return true;
}
/// Tick the object deserialization process for the given object load request.
///
/// @param[in] pRequest Load request.
///
/// @return True if the deserialization process has completed, false if it still needs time to process.
bool CachePackageLoader::TickDeserialize( LoadRequest* pRequest )
{
HELIUM_ASSERT( pRequest );
HELIUM_ASSERT( !( pRequest->flags & LOAD_FLAG_PRELOADED ) );
HELIUM_ASSERT( !pRequest->spObject );
const Cache::Entry* pCacheEntry = pRequest->pEntry;
HELIUM_ASSERT( pCacheEntry );
// Wait for the template and owner objects to load.
AssetLoader* pAssetLoader = AssetLoader::GetInstance();
HELIUM_ASSERT( pAssetLoader );
if( IsValid( pRequest->ownerLoadIndex ) )
{
size_t ownerLoadId = pRequest->ownerLoadIndex;
if( IsValid( ownerLoadId ) && !pAssetLoader->TryFinishLoad( ownerLoadId, pRequest->spOwner ) )
{
return false;
}
SetInvalid( pRequest->ownerLoadIndex );
if( !pRequest->spOwner )
{
HELIUM_TRACE(
TraceLevels::Error,
"CachePackageLoader: Failed to load owner object for \"%s\".\n",
*pCacheEntry->path.ToString() );
DefaultAllocator().Free( pRequest->pAsyncLoadBuffer );
pRequest->pAsyncLoadBuffer = NULL;
pRequest->flags |= LOAD_FLAG_PRELOADED | LOAD_FLAG_ERROR;
return true;
}
}
Asset* pOwner = pRequest->spOwner;
HELIUM_ASSERT( !pOwner || pOwner->IsFullyLoaded() );
Reflect::ObjectPtr cached_object = Cache::ReadCacheObjectFromBuffer(
pRequest->pPropertyDataBegin,
0,
pRequest->pPropertyDataEnd - pRequest->pPropertyDataBegin,
pRequest->pResolver);
AssetPtr assetPtr = Reflect::AssertCast<Asset>(cached_object);
Asset::RenameParameters params;
params.instanceIndex = -1;
params.name = pCacheEntry->path.GetName();
params.spOwner = pRequest->spOwner;
assetPtr->Rename(params);
pRequest->spObject = assetPtr;
Asset *pObject = assetPtr;
HELIUM_ASSERT( pObject );
if (!cached_object.ReferencesObject())
{
HELIUM_TRACE(
TraceLevels::Error,
"CachePackageLoader: Failed to deserialize object \"%s\".\n",
*pCacheEntry->path.ToString() );
pObject->SetFlags( Asset::FLAG_LINKED );
pObject->ConditionalFinalizeLoad();
pRequest->flags |= LOAD_FLAG_ERROR;
}
else
{
//cached_object->CopyTo(pObject);
if( !pObject->IsDefaultTemplate() )
{
// Load persistent resource data.
Resource* pResource = Reflect::SafeCast< Resource >( pObject );
if( pResource )
{
Reflect::ObjectPtr cached_prd = Cache::ReadCacheObjectFromBuffer(
pRequest->pPersistentResourceDataBegin,
0,
(pRequest->pPersistentResourceDataEnd - pRequest->pPersistentResourceDataBegin),
pRequest->pResolver);
if (!cached_prd.ReferencesObject())
{
HELIUM_TRACE(
TraceLevels::Error,
"CachePackageLoader: Failed to deserialize persistent resource data for \"%s\".\n",
*pCacheEntry->path.ToString() );
}
else
{
pResource->LoadPersistentResourceObject(cached_prd);
}
}
}
}
DefaultAllocator().Free( pRequest->pAsyncLoadBuffer );
pRequest->pAsyncLoadBuffer = NULL;
pObject->SetFlags( Asset::FLAG_PRELOADED );
pRequest->flags |= LOAD_FLAG_PRELOADED;
// Asset is now preloaded.
return true;
}
///////////////////////////////////////////////////////////////////////////////
// Called after OnInitCmdLine. The base class handles the /help command line
// switch and exits. If we get this far, we need to parse the command line
// and determine what mode to launch the app in.
//
bool App::OnInit()
{
SetVendorName( HELIUM_APP_NAME );
#if !HELIUM_RELEASE && !HELIUM_PROFILE
HELIUM_TRACE_SET_LEVEL( TraceLevels::Debug );
Helium::InitializeSymbols();
#endif
// Initialize sibling dynamically loaded modules.
Helium::FilePath path ( Helium::GetProcessPath() );
for ( DirectoryIterator itr ( FilePath( path.Directory() ) ); !itr.IsDone(); itr.Next() )
{
std::string ext = itr.GetItem().m_Path.Extension();
if ( ext == HELIUM_MODULE_EXTENSION )
{
ModuleHandle module = LoadModule( itr.GetItem().m_Path.c_str() );
HELIUM_ASSERT( module != HELIUM_INVALID_MODULE );
}
}
// don't spend a lot of time updating idle events for windows that don't need it
wxUpdateUIEvent::SetMode( wxUPDATE_UI_PROCESS_SPECIFIED );
wxIdleEvent::SetMode( wxIDLE_PROCESS_SPECIFIED );
Helium::FilePath exePath( GetProcessPath() );
Helium::FilePath iconFolder( exePath.Directory() + TXT( "Icons/" ) );
wxInitAllImageHandlers();
wxImageHandler* curHandler = wxImage::FindHandler( wxBITMAP_TYPE_CUR );
if ( curHandler )
{
// Force the cursor handler to the end of the list so that it doesn't try to
// open TGA files.
wxImage::RemoveHandler( curHandler->GetName() );
curHandler = NULL;
wxImage::AddHandler( new wxCURHandler );
}
ArtProvider* artProvider = new ArtProvider();
wxArtProvider::Push( artProvider );
wxSimpleHelpProvider* helpProvider = new wxSimpleHelpProvider();
wxHelpProvider::Set( helpProvider );
// Make sure various module-specific heaps are initialized from the main thread before use.
InitEngineJobsDefaultHeap();
InitGraphicsJobsDefaultHeap();
// Register shutdown for general systems.
m_InitializerStack.Push( FileLocations::Shutdown );
m_InitializerStack.Push( Name::Shutdown );
m_InitializerStack.Push( AssetPath::Shutdown );
// Async I/O.
AsyncLoader& asyncLoader = AsyncLoader::GetStaticInstance();
HELIUM_VERIFY( asyncLoader.Initialize() );
m_InitializerStack.Push( AsyncLoader::DestroyStaticInstance );
// Asset cache management.
FilePath baseDirectory;
if ( !FileLocations::GetBaseDirectory( baseDirectory ) )
{
HELIUM_TRACE( TraceLevels::Error, TXT( "Could not get base directory." ) );
return false;
}
HELIUM_VERIFY( CacheManager::InitializeStaticInstance( baseDirectory ) );
m_InitializerStack.Push( CacheManager::DestroyStaticInstance );
// libs
Editor::PerforceWaitDialog::EnableWaitDialog( true );
m_InitializerStack.Push( Perforce::Initialize, Perforce::Cleanup );
m_InitializerStack.Push( Reflect::ObjectRefCountSupport::Shutdown );
m_InitializerStack.Push( Asset::Shutdown );
m_InitializerStack.Push( AssetType::Shutdown );
m_InitializerStack.Push( Reflect::Initialize, Reflect::Cleanup );
m_InitializerStack.Push( Editor::Initialize, Editor::Cleanup );
// Asset loader and preprocessor.
HELIUM_VERIFY( LooseAssetLoader::InitializeStaticInstance() );
m_InitializerStack.Push( LooseAssetLoader::DestroyStaticInstance );
AssetLoader* pAssetLoader = AssetLoader::GetStaticInstance();
HELIUM_ASSERT( pAssetLoader );
AssetPreprocessor* pAssetPreprocessor = AssetPreprocessor::CreateStaticInstance();
HELIUM_ASSERT( pAssetPreprocessor );
PlatformPreprocessor* pPlatformPreprocessor = new PcPreprocessor;
HELIUM_ASSERT( pPlatformPreprocessor );
pAssetPreprocessor->SetPlatformPreprocessor( Cache::PLATFORM_PC, pPlatformPreprocessor );
m_InitializerStack.Push( AssetPreprocessor::DestroyStaticInstance );
m_InitializerStack.Push( ThreadSafeAssetTrackerListener::DestroyStaticInstance );
m_InitializerStack.Push( AssetTracker::DestroyStaticInstance );
m_InitializerStack.Push( InitializeEditorSystem, DestroyEditorSystem );
//HELIUM_ASSERT( g_EditorSystemDefinition.Get() ); // TODO: Figure out why this sometimes doesn't load
Helium::Components::Initialize( g_EditorSystemDefinition.Get() );
m_InitializerStack.Push( Components::Cleanup );
// Engine configuration.
Config& rConfig = Config::GetStaticInstance();
rConfig.BeginLoad();
while( !rConfig.TryFinishLoad() )
{
pAssetLoader->Tick();
}
m_InitializerStack.Push( Config::DestroyStaticInstance );
ConfigPc::SaveUserConfig();
LoadSettings();
Connect( wxEVT_CHAR, wxKeyEventHandler( App::OnChar ), NULL, this );
m_Frame = new MainFrame( m_SettingsManager );
#if HELIUM_OS_WIN
m_Engine.Initialize( &m_Frame->GetSceneManager(), GetHwndOf( m_Frame ) );
#else
m_Engine.Initialize( &m_Frame->GetSceneManager(), NULL );
#endif
HELIUM_VERIFY( m_Frame->Initialize() );
m_Frame->Show();
if ( GetSettingsManager()->GetSettings< EditorSettings >()->GetReopenLastProjectOnStartup() )
{
const std::vector< std::string >& mruPaths = wxGetApp().GetSettingsManager()->GetSettings<EditorSettings>()->GetMRUProjects();
if ( !mruPaths.empty() )
{
FilePath projectPath( *mruPaths.rbegin() );
if ( projectPath.Exists() )
{
m_Frame->OpenProject( FilePath( *mruPaths.rbegin() ) );
}
}
}
return true;
}