void newDeleteTest() {
PageManager *pm = ((Environment *)m_env)->get_page_manager();
REQUIRE(pm->test_get_cache());
if (m_inmemory)
REQUIRE(!pm->get_freelist(0));
}
//---------------------------------------------------------------------
bool Page::prepareImpl(StreamSerialiser& stream, PageData* dataToPopulate)
{
// Now do the real loading
if (!stream.readChunkBegin(CHUNK_ID, CHUNK_VERSION, "Page"))
return false;
// pageID check (we should know the ID we're expecting)
uint32 storedID;
stream.read(&storedID);
if (mID != storedID)
{
LogManager::getSingleton().stream() << "Error: Tried to populate Page ID " << mID
<< " with data corresponding to page ID " << storedID;
stream.undoReadChunk(CHUNK_ID);
return false;
}
PageManager* mgr = getManager();
while(stream.peekNextChunkID() == CHUNK_CONTENTCOLLECTION_DECLARATION_ID)
{
const StreamSerialiser::Chunk* collChunk = stream.readChunkBegin();
String factoryName;
stream.read(&factoryName);
stream.readChunkEnd(CHUNK_CONTENTCOLLECTION_DECLARATION_ID);
// Supported type?
PageContentCollectionFactory* collFact = mgr->getContentCollectionFactory(factoryName);
if (collFact)
{
PageContentCollection* collInst = collFact->createInstance();
if (collInst->prepare(stream)) // read type-specific data
{
dataToPopulate->collectionsToAdd.push_back(collInst);
}
else
{
LogManager::getSingleton().stream() << "Error preparing PageContentCollection type: "
<< factoryName << " in " << *this;
collFact->destroyInstance(collInst);
}
}
else
{
LogManager::getSingleton().stream() << "Unsupported PageContentCollection type: "
<< factoryName << " in " << *this;
// skip
stream.readChunkEnd(collChunk->id);
}
}
mModified = false;
return true;
}
void fetchInvalidPageTest() {
PageManager *pm = ((Environment *)m_env)->get_page_manager();
Page *page;
page = 0;
REQUIRE(HAM_IO_ERROR ==
pm->fetch_page(&page, 0, 1024 * 1024 * 200, false));
REQUIRE(page == (Page *)0);
}
void allocPageTest() {
PageManager *pm = ((Environment *)m_env)->get_page_manager();
Page *page;
page = 0;
REQUIRE(0 ==
pm->alloc_page(&page, 0, Page::TYPE_FREELIST,
PageManager::kClearWithZero));
if (m_inmemory == false)
REQUIRE(page->get_self() == 2 * 16 * 1024ull);
REQUIRE(page != 0);
REQUIRE(!page->get_db());
}
void fetchPageTest() {
PageManager *pm = ((Environment *)m_env)->get_page_manager();
Page *page;
page = 0;
REQUIRE(0 == pm->fetch_page(&page, 0, 16 * 1024ull, false));
REQUIRE(page->get_self() == 16 * 1024ull);
page = 0;
REQUIRE(0 == pm->fetch_page(&page, 0, 16 * 1024ull, true));
REQUIRE(page->get_self() == 16 * 1024ull);
REQUIRE(page);
}
CuckooTable::CuckooTable(PageManager& pageManager)
: mPageManager(pageManager)
, hash1(ENTRIES_PER_PAGE)
, hash2(ENTRIES_PER_PAGE)
, hash3(ENTRIES_PER_PAGE)
, mSize(0)
{
mPages.reserve(3);
for (size_t i = 0; i < 3; ++i) {
auto page = pageManager.alloc();
if (!page) {
LOG_ERROR("PageManager ran out of space");
std::terminate();
}
mPages.emplace_back(reinterpret_cast<EntryT*>(page));
}
}
Page *fetch_page(uint64_t address) {
LocalDatabase *db = (LocalDatabase *)m_db;
PageManager *pm = db->get_local_env()->get_page_manager();
return (pm->fetch_page(db, address));
}
void setupContent()
{
bool blankTerrain = false;
//blankTerrain = true;
mTerrainGlobals = OGRE_NEW TerrainGlobalOptions();
ResourceGroupManager::getSingleton().createResourceGroup( "Terrain" );
ResourceGroupManager::getSingleton().addResourceLocation( mFSLayer->getWritablePath( "" ), "FileSystem", "Terrain", false, false );
mEditMarker = mSceneMgr->createEntity( "editMarker", "sphere.mesh" );
mEditNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
mEditNode->attachObject( mEditMarker );
mEditNode->setScale( 0.05, 0.05, 0.05 );
setupControls();
mCameraMan->setTopSpeed( 50 );
setDragLook( true );
MaterialManager::getSingleton().setDefaultTextureFiltering( TFO_ANISOTROPIC );
MaterialManager::getSingleton().setDefaultAnisotropy( 7 );
mSceneMgr->setFog( FOG_LINEAR, ColourValue( 0.7, 0.7, 0.8 ), 0, 10000, 25000 );
LogManager::getSingleton().setLogDetail( LL_BOREME );
Vector3 lightdir( 0.55, -0.3, 0.75 );
lightdir.normalise();
Light* l = mSceneMgr->createLight( "tstLight" );
l->setType( Light::LT_DIRECTIONAL );
l->setDirection( lightdir );
l->setDiffuseColour( ColourValue::White );
l->setSpecularColour( ColourValue( 0.4, 0.4, 0.4 ) );
mSceneMgr->setAmbientLight( ColourValue( 0.2, 0.2, 0.2 ) );
mTerrainGroup = OGRE_NEW TerrainGroup( mSceneMgr, Terrain::ALIGN_X_Z, TERRAIN_SIZE, TERRAIN_WORLD_SIZE );
mTerrainGroup->setFilenameConvention( TERRAIN_FILE_PREFIX, TERRAIN_FILE_SUFFIX );
mTerrainGroup->setOrigin( mTerrainPos );
mTerrainGroup->setResourceGroup( "Terrain" );
configureTerrainDefaults( l );
#ifdef PAGING
// Paging setup
mPageManager = OGRE_NEW PageManager();
// Since we're not loading any pages from .page files, we need a way just
// to say we've loaded them without them actually being loaded
mPageManager->setPageProvider( &mDummyPageProvider );
mPageManager->addCamera( mCamera );
mTerrainPaging = OGRE_NEW TerrainPaging( mPageManager );
PagedWorld* world = mPageManager->createWorld();
mTerrainPaging->createWorldSection( world, mTerrainGroup, 2000, 3000,
TERRAIN_PAGE_MIN_X, TERRAIN_PAGE_MIN_Y,
TERRAIN_PAGE_MAX_X, TERRAIN_PAGE_MAX_Y );
#else
for( long x = TERRAIN_PAGE_MIN_X; x <= TERRAIN_PAGE_MAX_X; ++x )
for( long y = TERRAIN_PAGE_MIN_Y; y <= TERRAIN_PAGE_MAX_Y; ++y )
defineTerrain( x, y, blankTerrain );
// sync load since we want everything in place when we start
mTerrainGroup->loadAllTerrains( true );
#endif
if( mTerrainsImported )
{
TerrainGroup::TerrainIterator ti = mTerrainGroup->getTerrainIterator();
while( ti.hasMoreElements() )
{
Terrain* t = ti.getNext()->instance;
initBlendMaps( t );
}
}
mTerrainGroup->freeTemporaryResources();
// create a few entities on the terrain
Entity* e = mSceneMgr->createEntity( "tudorhouse.mesh" );
Vector3 entPos( mTerrainPos.x + 2043, 0, mTerrainPos.z + 1715 );
Quaternion rot;
entPos.y = mTerrainGroup->getHeightAtWorldPosition( entPos ) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis( Degree( Math::RangeRandom( -180, 180 ) ), Vector3::UNIT_Y );
SceneNode* sn = mSceneMgr->getRootSceneNode()->createChildSceneNode( entPos, rot );
sn->setScale( Vector3( 0.12, 0.12, 0.12 ) );
sn->attachObject( e );
mHouseList.push_back( e );
e = mSceneMgr->createEntity( "tudorhouse.mesh" );
entPos = Vector3( mTerrainPos.x + 1850, 0, mTerrainPos.z + 1478 );
entPos.y = mTerrainGroup->getHeightAtWorldPosition( entPos ) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis( Degree( Math::RangeRandom( -180, 180 ) ), Vector3::UNIT_Y );
sn = mSceneMgr->getRootSceneNode()->createChildSceneNode( entPos, rot );
sn->setScale( Vector3( 0.12, 0.12, 0.12 ) );
sn->attachObject( e );
mHouseList.push_back( e );
e = mSceneMgr->createEntity( "tudorhouse.mesh" );
entPos = Vector3( mTerrainPos.x + 1970, 0, mTerrainPos.z + 2180 );
entPos.y = mTerrainGroup->getHeightAtWorldPosition( entPos ) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis( Degree( Math::RangeRandom( -180, 180 ) ), Vector3::UNIT_Y );
sn = mSceneMgr->getRootSceneNode()->createChildSceneNode( entPos, rot );
sn->setScale( Vector3( 0.12, 0.12, 0.12 ) );
sn->attachObject( e );
mHouseList.push_back( e );
mSceneMgr->setSkyBox( true, "Examples/CloudyNoonSkyBox" );
}
int WINAPI WinMain ( HINSTANCE hInst, HINSTANCE, LPSTR szCmdLine, int)
{
Root * pRoot = new Root(StringUtil::BLANK);
pRoot->loadPlugin(PLUGIN("RenderSystem_GL"));
pRoot->loadPlugin(PLUGIN("RenderSystem_Direct3D9"));
pRoot->addResourceLocation("paging", "FileSystem", "Paging");
if (pRoot->showConfigDialog())
{
OverhangTerrainSceneManager * pScMgr = OGRE_NEW OverhangTerrainSceneManager("Default");
PageManager * pPgMan = OGRE_NEW PageManager();
OverhangTerrainPaging * pOhPging = new OverhangTerrainPaging(pPgMan);
RenderWindow * pRendWindow = pRoot->initialise(true);
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
Light * pSun = pScMgr->createLight("Sun");
pSun->setPosition(0,5000, 0);
pSun->setType(Light::LT_POINT);
MaterialPtr pMat = MaterialManager::getSingleton().create("BaseMaterial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Pass * pPass = pMat->getTechnique(0) ->getPass(0);
pPass->setLightingEnabled(true);
pPass->setDiffuse(0.1f, 0.5f, 1.0f, 1.0f);
pPass->setAmbient(0.05f, 0.1f, 0.2f);
pPass->setSpecular(1.0f, 1.0f, 1.0f, 1.0f);
pPass->setShininess(80);
Camera * pCam = pScMgr->createCamera("Photographer");
pCam->setNearClipDistance(0.1f);
pCam->setFarClipDistance(7000);
pCam->setPosition(Vector3(-2725.24f, 277.747f, 2748.56f));
pCam->setDirection(Vector3(0.998938f, 0.0495558f, 0.00161433f));
Viewport * vp = pRendWindow->addViewport(pCam);
pCam->setAspectRatio(Real(vp->getActualWidth()) / Real(vp->getActualHeight()));
SceneNode
* pnCam = pScMgr->getRootSceneNode()->createChildSceneNode("Helicopter"),
* pnLight = pScMgr->getRootSceneNode() ->createChildSceneNode("Aura");
pnCam->attachObject(pCam);
pnLight->attachObject(pSun);
OverhangTerrainOptions options;
options.primaryCamera = pCam;
options.pageSize = 129;
options.tileSize = 33;
options.cellScale = 50.0;
options.heightScale = 8.0;
options.channels[TERRAIN_ENTITY_CHANNEL].material = pMat;
options.channels[TERRAIN_ENTITY_CHANNEL].maxGeoMipMapLevel = 6;
options.channels[TERRAIN_ENTITY_CHANNEL].maxPixelError = 10;
options.channels[TERRAIN_ENTITY_CHANNEL].qid = RENDER_QUEUE_1;
pScMgr->setOptions(options);
OverhangTerrainGroup * pGrp = OGRE_NEW OverhangTerrainGroup(pScMgr, NULL, "Paging");
pPgMan->addCamera(pCam);
DummyPageProvider dpp;
pPgMan->setPageProvider(&dpp);
PagedWorld * pWorld = pPgMan->createWorld("OhTSM");
OverhangTerrainPagedWorldSection * pOhPgSect = pOhPging->createWorldSection(pWorld, pGrp);
pScMgr->initialise();
ExamplePageProvider pp(pOhPgSect, pGrp->getResourceGroupName());
pGrp->setPageProvider(&pp);
ExampleController * pController = new ExampleController (pRendWindow, pCam, pScMgr);
pRoot->addFrameListener(pController);
pRoot->startRendering();
delete pController;
OGRE_DELETE pOhPgSect;
OGRE_DELETE pOhPging;
OGRE_DELETE pPgMan;
OGRE_DELETE pScMgr;
}
delete pRoot;
return 0;
}
void PGSampleApp::createScene(void)
{
bool blankTerrain = false;
mTerrainGlobals = OGRE_NEW TerrainGlobalOptions();
Vector3 lightdir(0.55, -0.3, 0.75);
lightdir.normalise();
Light* l = mSceneMgr->createLight("tstLight");
l->setType(Light::LT_DIRECTIONAL);
l->setDirection(lightdir);
l->setDiffuseColour(ColourValue::White);
l->setSpecularColour(ColourValue(0.4, 0.4, 0.4));
mSceneMgr->setAmbientLight(ColourValue(0.2, 0.2, 0.2));
mTerrainGroup = OGRE_NEW TerrainGroup(mSceneMgr, Terrain::ALIGN_X_Z, TERRAIN_SIZE, TERRAIN_WORLD_SIZE);
mTerrainGroup->setFilenameConvention(TERRAIN_FILE_PREFIX, TERRAIN_FILE_SUFFIX);
mTerrainGroup->setOrigin(mTerrainPos + Vector3(TERRAIN_WORLD_SIZE/2, 0, TERRAIN_WORLD_SIZE/2));
configureTerrainDefaults(l);
#ifdef PAGING
// Paging setup
mPageManager = OGRE_NEW PageManager();
// Since we're not loading any pages from .page files, we need a way just
// to say we've loaded them without them actually being loaded
mPageManager->setPageProvider(&mDummyPageProvider);
mPageManager->addCamera(mCamera);
mTerrainPaging = OGRE_NEW TerrainPaging(mPageManager);
PagedWorld* world = mPageManager->createWorld();
mTerrainPaging->createWorldSection(world, mTerrainGroup, 2000, 3000,
TERRAIN_PAGE_MIN_X, TERRAIN_PAGE_MIN_Y,
TERRAIN_PAGE_MAX_X, TERRAIN_PAGE_MAX_Y);
#else
for (long x = TERRAIN_PAGE_MIN_X; x <= TERRAIN_PAGE_MAX_X; ++x)
for (long y = TERRAIN_PAGE_MIN_Y; y <= TERRAIN_PAGE_MAX_Y; ++y)
defineTerrain(x, y, blankTerrain);
// sync load since we want everything in place when we start
mTerrainGroup->loadAllTerrains(true);
#endif
if (mTerrainsImported)
{
TerrainGroup::TerrainIterator ti = mTerrainGroup->getTerrainIterator();
while(ti.hasMoreElements())
{
Terrain* t = ti.getNext()->instance;
initBlendMaps(t);
}
}
mTerrainGroup->freeTemporaryResources();
// create a few entities on the terrain
Entity* e = mSceneMgr->createEntity("tudorhouse.mesh");
Vector3 entPos(mTerrainPos.x + 2043, 0, mTerrainPos.z + 1715);
Quaternion rot;
entPos.y = mTerrainGroup->getHeightAtWorldPosition(entPos) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis(Degree(Math::RangeRandom(-180, 180)), Vector3::UNIT_Y);
SceneNode* sn = mSceneMgr->getRootSceneNode()->createChildSceneNode(entPos, rot);
sn->setScale(Vector3(0.12, 0.12, 0.12));
sn->attachObject(e);
mHouseList.push_back(e);
e = mSceneMgr->createEntity("tudorhouse.mesh");
entPos = Vector3(mTerrainPos.x + 1850, 0, mTerrainPos.z + 1478);
entPos.y = mTerrainGroup->getHeightAtWorldPosition(entPos) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis(Degree(Math::RangeRandom(-180, 180)), Vector3::UNIT_Y);
sn = mSceneMgr->getRootSceneNode()->createChildSceneNode(entPos, rot);
sn->setScale(Vector3(0.12, 0.12, 0.12));
sn->attachObject(e);
mHouseList.push_back(e);
e = mSceneMgr->createEntity("tudorhouse.mesh");
entPos = Vector3(mTerrainPos.x + 1970, 0, mTerrainPos.z + 2180);
entPos.y = mTerrainGroup->getHeightAtWorldPosition(entPos) + 65.5 + mTerrainPos.y;
rot.FromAngleAxis(Degree(Math::RangeRandom(-180, 180)), Vector3::UNIT_Y);
sn = mSceneMgr->getRootSceneNode()->createChildSceneNode(entPos, rot);
sn->setScale(Vector3(0.12, 0.12, 0.12));
sn->attachObject(e);
mHouseList.push_back(e);
mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox");
configureShadows(true, false);
mCamera->setPosition(mTerrainPos + Vector3(1683, 50, 2116));
mCamera->lookAt(Vector3(1963, 50, 1660));
mCamera->setNearClipDistance(0.1);
mCamera->setFarClipDistance(50000);
if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
{
mCamera->setFarClipDistance(0); // enable infinite far clip distance if we can
}
}
