TEST(ImageResourceTest, CancelOnDetach)
{
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html", "text/html");
ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
// Emulate starting a real load.
ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(testURL), nullptr);
cachedImage->setIdentifier(createUniqueIdentifier());
cachedImage->load(fetcher, ResourceLoaderOptions());
memoryCache()->add(cachedImage.get());
MockImageResourceClient client(cachedImage);
EXPECT_EQ(Resource::Pending, cachedImage->status());
// The load should still be alive, but a timer should be started to cancel the load inside removeClient().
client.removeAsClient();
EXPECT_EQ(Resource::Pending, cachedImage->status());
EXPECT_NE(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
// Trigger the cancel timer, ensure the load was cancelled and the resource was evicted from the cache.
blink::testing::runPendingTasks();
EXPECT_EQ(Resource::LoadError, cachedImage->status());
EXPECT_EQ(reinterpret_cast<Resource*>(0), memoryCache()->resourceForURL(testURL));
Platform::current()->unitTestSupport()->unregisterMockedURL(testURL);
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::load(const String& name,
const String& group, bool isManual, ManualResourceLoader* loader,
const NameValuePairList* loadParams, bool backgroundThread)
{
ResourcePtr r = createOrRetrieve(name,group,isManual,loader,loadParams).first;
// ensure loaded
r->load(backgroundThread);
return r;
}
TEST(ImageResourceTest, MultipartImage)
{
ResourceFetcher* fetcher = ResourceFetcher::create(nullptr);
KURL testURL(ParsedURLString, "http://www.test.com/cancelTest.html");
URLTestHelpers::registerMockedURLLoad(testURL, "cancelTest.html", "text/html");
// Emulate starting a real load, but don't expect any "real" WebURLLoaderClient callbacks.
ResourcePtr<ImageResource> cachedImage = new ImageResource(ResourceRequest(testURL), nullptr);
cachedImage->setIdentifier(createUniqueIdentifier());
cachedImage->load(fetcher, ResourceLoaderOptions());
Platform::current()->unitTestSupport()->unregisterMockedURL(testURL);
MockImageResourceClient client(cachedImage);
EXPECT_EQ(Resource::Pending, cachedImage->status());
// Send the multipart response. No image or data buffer is created.
// Note that the response must be routed through ResourceLoader to
// ensure the load is flagged as multipart.
ResourceResponse multipartResponse(KURL(), "multipart/x-mixed-replace", 0, nullAtom, String());
cachedImage->loader()->didReceiveResponse(nullptr, WrappedResourceResponse(multipartResponse), nullptr);
ASSERT_FALSE(cachedImage->resourceBuffer());
ASSERT_FALSE(cachedImage->hasImage());
ASSERT_EQ(client.imageChangedCount(), 0);
ASSERT_FALSE(client.notifyFinishedCalled());
// Send the response for the first real part. No image or data buffer is created.
const char* svgData = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'><rect width='1' height='1' fill='green'/></svg>";
unsigned svgDataLength = strlen(svgData);
ResourceResponse payloadResponse(KURL(), "image/svg+xml", svgDataLength, nullAtom, String());
cachedImage->loader()->didReceiveResponse(nullptr, WrappedResourceResponse(payloadResponse), nullptr);
ASSERT_FALSE(cachedImage->resourceBuffer());
ASSERT_FALSE(cachedImage->hasImage());
ASSERT_EQ(client.imageChangedCount(), 0);
ASSERT_FALSE(client.notifyFinishedCalled());
// The first bytes arrive. The data buffer is created, but no image is created.
cachedImage->appendData(svgData, svgDataLength);
ASSERT_TRUE(cachedImage->resourceBuffer());
ASSERT_EQ(cachedImage->resourceBuffer()->size(), svgDataLength);
ASSERT_FALSE(cachedImage->hasImage());
ASSERT_EQ(client.imageChangedCount(), 0);
ASSERT_FALSE(client.notifyFinishedCalled());
// This part finishes. The image is created, callbacks are sent, and the data buffer is cleared.
cachedImage->finish();
ASSERT_FALSE(cachedImage->resourceBuffer());
ASSERT_FALSE(cachedImage->errorOccurred());
ASSERT_TRUE(cachedImage->hasImage());
ASSERT_FALSE(cachedImage->image()->isNull());
ASSERT_EQ(cachedImage->image()->width(), 1);
ASSERT_EQ(cachedImage->image()->height(), 1);
ASSERT_EQ(client.imageChangedCount(), 2);
ASSERT_TRUE(client.notifyFinishedCalled());
}
void OgreApp::setupDemoScene()
{
globals.initPaths();
#if defined(OGRE_IS_IOS) && defined(NETWORKING)
syncConfig();
#endif
seed = time(0);
srand(seed);
// The code snippet below is used to output text
// create a font resource
ResourcePtr resourceText = OgreFramework::getSingletonPtr()->m_pFontMgr->create("Arial", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
resourceText->setParameter("type", "truetype");
//resourceText->setParameter("source", "C64_User_Mono_v1.0-STYLE.ttf");
resourceText->setParameter("source", "NEUROPOL.ttf");
resourceText->setParameter("size", "16");
resourceText->setParameter("resolution", "96");
resourceText->load();
Util::createSphere(OgreFramework::getSingletonPtr()->m_pSceneMgrMain, "sphereMesh", 1.0, 8, 8);
Util::createCylinder(OgreFramework::getSingletonPtr()->m_pSceneMgrMain, "cylinderMesh", 1.0, 1.0, 8);
Util::createDiamond(OgreFramework::getSingletonPtr()->m_pSceneMgrMain, "diamondMesh", 1.0, 1.0);
Util::createBox(OgreFramework::getSingletonPtr()->m_pSceneMgrMain, "boxMesh", 1.0, 1.0, 1.0);
Util::createPlane(OgreFramework::getSingletonPtr()->m_pSceneMgrMain, "planeMesh", 1.0, 1.0);
Util::createDefaultSegments(OgreFramework::getSingletonPtr()->m_pSceneMgrMain);
globals.initPaths();
//if (!configStageType(globals.configPath, globals.configBackup, "globalConfig"))
// globals.setMessage("WARNING: Failed to read configuration", MESSAGE_ERROR);
OgreFramework::getSingletonPtr()->m_pCameraMain->setPosition(Vector3::ZERO);
OgreFramework::getSingletonPtr()->m_pCameraMain->lookAt(Vector3::ZERO);
player = new Player(
globals.playerName,
OgreFramework::getSingletonPtr()->m_pCameraMain->getPosition(),
OgreFramework::getSingletonPtr()->m_pCameraMain->getOrientation(),
globals.initCamSpeed,
globals.vineTOffset,
seed,
"vinezors" + Util::toStringInt(seed) + ".csv");
player->setSounds(true);
if (!player->loadProgress(globals.savePath))
std::cout << "WARNING: Save File could not be loaded correctly" << std::endl;
globals.initLogs(player->getSkillLevel().sessionID);
engineStateMgr = new EngineStateManager();
engineStateMgr->requestPushEngine(ENGINE_MAIN_MENU, player);
#if defined(OGRE_IS_IOS) && (NETWORKING)
syncLogs();
#endif
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::load(const String& name,
const String& group, bool isManual, ManualResourceLoader* loader,
const NameValuePairList* loadParams)
{
ResourcePtr ret = getByName(name);
if (ret.isNull())
{
ret = create(name, group, isManual, loader, loadParams);
}
// ensure loaded
ret->load();
return ret;
}
DebugOverlay::DebugOverlay(Ogre::Camera *camera)
{
myCamera = camera;
Ogre::OverlayManager& overlayManager = Ogre::OverlayManager::getSingleton();
panel = static_cast<OverlayContainer*>(overlayManager.createOverlayElement("Panel", "PanelName"));
panel->setMetricsMode(Ogre::GMM_PIXELS);
panel->setPosition(10, 10);
panel->setDimensions(100, 100);
// Create a text area
FontManager &fontMgr = FontManager::getSingleton();
ResourcePtr font = fontMgr.create("MyFont","General");
font->setParameter("type","truetype");
font->setParameter("source","trebuc.ttf");
font->setParameter("size","26");
font->setParameter("resolution","96");
font->load();
textArea = static_cast<TextAreaOverlayElement*>(
overlayManager.createOverlayElement("TextArea", "TextAreaName"));
textArea->setMetricsMode(Ogre::GMM_PIXELS);
textArea->setPosition(0, 0);
textArea->setDimensions(100, 100);
textArea->setCaption("LOADING..");
textArea->setCharHeight(16);
textArea->setFontName("MyFont");
textArea->setColourBottom(ColourValue(0.3, 0.5, 0.3));
textArea->setColourTop(ColourValue(0.5, 0.7, 0.5));
// Create an overlay, and add the panel
Overlay* overlay = overlayManager.create("OverlayName");
overlay->add2D(panel);
// Add the text area to the panel
panel->addChild(textArea);
// Show the overlay
overlay->show();
}
void GameScreen::setUpOverlay(){
// Load the Font
FontManager &fontMgr = FontManager::getSingleton();
ResourcePtr font = fontMgr.create("GameFont","General");
font->setParameter("type","truetype");
font->setParameter("source","Smirnof.ttf");
font->setParameter("size","20");
font->setParameter("resolution","96");
font->load();
// Load the overlay
OverlayManager& overlayMgr = OverlayManager::getSingleton();
Ogre::OverlayContainer* panel = static_cast<OverlayContainer*>(
overlayMgr.createOverlayElement("Panel", "PanelName"));
panel->_setPosition(0.05, 0.925);
panel->setDimensions(300, 120);
TextAreaOverlayElement* textArea = static_cast<TextAreaOverlayElement*>(
overlayMgr.createOverlayElement("TextArea", "TextAreaName"));
textArea->setMetricsMode(Ogre::GMM_PIXELS);
textArea->setPosition(0, 0);
textArea->setDimensions(300, 120);
textArea->setCharHeight(24);
textArea->setColour(ColourValue(1,1,0));
// set the font name to the font resource that you just created.
textArea->setFontName("GameFont");
// say something
std::stringstream ss;
ss << "Score: " << score;
textArea->setCaption(ss.str().c_str());
overlay = overlayMgr.create("OverlayName");
overlay->add2D(panel);
panel->addChild(textArea);
}
ResourcePtr<Resource> ResourceFetcher::requestResource(Resource::Type type, FetchRequest& request)
{
ASSERT(request.options().synchronousPolicy == RequestAsynchronously || type == Resource::Raw);
TRACE_EVENT0("blink", "ResourceFetcher::requestResource");
KURL url = request.resourceRequest().url();
WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), ResourceTypeName(type));
// If only the fragment identifiers differ, it is the same resource.
url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
if (!url.isValid())
return 0;
if (!canRequest(type, url, request.options(), request.originRestriction()))
return 0;
if (LocalFrame* f = frame())
f->loaderClient()->dispatchWillRequestResource(&request);
// See if we can use an existing resource from the cache.
ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url);
const RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
switch (policy) {
case Reload:
memoryCache()->remove(resource.get());
// Fall through
case Load:
resource = createResourceForLoading(type, request, request.charset());
break;
case Revalidate:
resource = createResourceForRevalidation(request, resource.get());
break;
case Use:
memoryCache()->updateForAccess(resource.get());
break;
}
if (!resource)
return 0;
if (!resource->hasClients())
m_deadStatsRecorder.update(policy);
if (policy != Use)
resource->setIdentifier(createUniqueIdentifier());
ResourceLoadPriority priority = loadPriority(type, request);
if (priority != resource->resourceRequest().priority()) {
resource->mutableResourceRequest().setPriority(priority);
resource->didChangePriority(priority, 0);
}
if (resourceNeedsLoad(resource.get(), request, policy)) {
if (!shouldLoadNewResource(type)) {
if (memoryCache()->contains(resource.get()))
memoryCache()->remove(resource.get());
return 0;
}
resource->load(this, request.options());
// For asynchronous loads that immediately fail, it's sufficient to return a
// null Resource, as it indicates that something prevented the load from starting.
// If there's a network error, that failure will happen asynchronously. However, if
// a sync load receives a network error, it will have already happened by this point.
// In that case, the requester should have access to the relevant ResourceError, so
// we need to return a non-null Resource.
if (resource->errorOccurred()) {
if (memoryCache()->contains(resource.get()))
memoryCache()->remove(resource.get());
return 0;
}
}
requestLoadStarted(resource.get(), request, policy == Use ? ResourceLoadingFromCache : ResourceLoadingFromNetwork);
ASSERT(resource->url() == url.string());
m_documentResources.set(resource->url(), resource);
return resource;
}
ResourcePtr ResourceManager::load(const String &name, int32_t argc, ...)
{
ResourcePtr res = nullptr;
// First, search cache
auto itr = mResourceCache.find(name);
if (itr != mResourceCache.end())
{
// Found it in cache.
Resources &resources = itr->second;
if (resources.size() > 0)
{
auto i = resources.find(0);
if (i != resources.end())
{
// Found in original resource list
res = i->second;
}
else
{
// Found not in original resource list
va_list params;
va_start(params, argc);
res = create(name, argc, params);
va_end(params);
if (res != nullptr)
{
bool ret = res->load();
if (ret)
{
resources.insert(ResPairValue(0, res));
}
else
{
res = nullptr;
}
}
}
}
}
else
{
// Found not, it should create a new instance.
va_list params;
va_start(params, argc);
res = create(name, argc, params);
va_end(params);
if (res != nullptr)
{
bool ret = res->load();
if (ret)
{
Resources resources;
resources.insert(ResPairValue(0, res));
mResourceCache.insert(ResMapPairValue(name, resources));
}
else
{
res = nullptr;
}
}
}
return res;
}
void initializeImpl()
{
c.setPosition(Vector3f(0.0f, 0.0f, 150.0f));
/*
float lightAmbient[] = { 0.2f, 0.3f, 0.6f, 1.0f };
float lightDiffuse[] = { 0.2f, 0.3f, 0.6f, 1.0f };
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);
*/
swmR.readFile("ViperMKVII.swm", model);
const std::vector<GLfloat> &mdlVertices = model.getVerticeVec();
const std::vector<GLfloat> &mdlNormals = model.getVNormalVec();
const std::vector<GLfloat> &mdlTexCoords = model.getVTextureVec();
std::size_t totalSize, vertexSize, normalSize, texCoordSize;
vertexSize = sizeof(&mdlVertices[0]) * mdlVertices.size();
normalSize = sizeof(&mdlNormals[0]) * mdlNormals.size();
texCoordSize = sizeof(&mdlTexCoords[0]) * mdlTexCoords.size();
totalSize = vertexSize + normalSize + texCoordSize;
vertexBuffer = HardwareBufferPtr(new HardwareBuffer(totalSize, HardwareBuffer::STATIC_DRAW, HardwareBuffer::VERTEX));
vertexBuffer->upload(0, vertexSize, &mdlVertices[0]);
vertexBuffer->upload(vertexSize, normalSize, &mdlNormals[0]);
vertexBuffer->upload(vertexSize + normalSize, texCoordSize, &mdlTexCoords[0]);
//indexBuffer = HardwareBufferPtr(new HardwareBuffer(sizeof(&mdlIndices[0]) * mdlIndices.size(), HardwareBuffer::STATIC_DRAW, HardwareBuffer::INDEX));
//indexBuffer->upload(&mdlIndices[0]);
//rop.indexData = new IndexData();
//rop.indexData->indexBuffer = indexBuffer;
//rop.indexData->count = mdlIndices.size();
//rop.indexData->start = 0;
rop.indexed = false;
rop.vertexData = new VertexData();
rop.vertexData->count = mdlVertices.size();
rop.vertexData->start = 0;
rop.vertexData->bufferElementGroup.addElement(0,0,POSITION,FLOAT3);
rop.vertexData->bufferElementGroup.addElement(0,vertexSize,NORMAL,FLOAT3);
rop.vertexData->bufferElementGroup.addElement(0,vertexSize + normalSize,TEXTURE_COORDINATES,FLOAT3);
rop.vertexData->bufferBinding[0] = vertexBuffer;
rop.primitiveType = RenderOperation::TRIANGLES;
glShadeModel(GL_SMOOTH);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
//c.move(Vector3f(0.0, 10450.0, 0.0));
//c.setPosition(Vector3f(4000.0, 10450.0, 20620.0));
//c.setDirection(Vector3f(3999.0, 10450.0, 20620.0));
//c.rotate(Vector3f::Y, static_cast<Math::Units::Radians>(270 * Math::Units::degrees));
texture = TexturePtr(new Texture(NULL, "ViperMKVII", 0, TEXTURE_2D));
texture->setFilePath("ViperMKVII.dds");
texture->prepare();
std::cout << static_cast<Texture*> (texture.get())->getID() << std::endl;
texture->load();
atm.Start();
s.myinit();
}
Hud::Hud()
{
player = NULL;
tunnel = NULL;
// The code snippet below is used to output text
// create a font resource
ResourcePtr resourceText = OgreFramework::getSingletonPtr()->m_pFontMgr->create("Arial",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
resourceText->setParameter("type", "truetype");
resourceText->setParameter("source", "C64_User_Mono_v1.0-STYLE.ttf");
resourceText->setParameter("size", "16");
resourceText->setParameter("resolution", "96");
resourceText->load();
panelText = static_cast<OverlayContainer*>(OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "TextInterface"));
panelText->setMetricsMode(GMM_PIXELS);
panelText->setPosition(10, 10);
panelText->setDimensions(10, 10);
healthArea = static_cast<BorderPanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("BorderPanel", "HealthAreaBorder"));
barHP = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "HealthBar"));
indicator = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "Indicator"));
threshold1 = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "threshold1"));
threshold2 = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "threshold2"));
threshold3 = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "threshold3"));
pauseButton = static_cast<PanelOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("Panel", "pauseButton"));
// Create text area
label1 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel1"));
label2 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel2"));
label3 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel3"));
label4 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel4"));
label5 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel5"));
label6 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel6"));
label7 = static_cast<TextAreaOverlayElement*>(
OgreFramework::getSingletonPtr()->m_pOverlayMgr->createOverlayElement("TextArea", "TextAreaLabel7"));
// Create an overlay, and add the panel
Overlay* overlay1 = OgreFramework::getSingletonPtr()->m_pOverlayMgr->create("OverlayHealthArea");
Overlay* overlay2 = OgreFramework::getSingletonPtr()->m_pOverlayMgr->create("OverlayText");
overlay1->add2D(healthArea);
//overlay1->add2D(barHP);
overlay1->add2D(indicator);
//overlay1->add2D(threshold1);
//overlay1->add2D(threshold2);
//overlay1->add2D(threshold3);
overlay1->add2D(pauseButton);
overlay2->add2D(panelText);
panelText->addChild(label1);
panelText->addChild(label2);
panelText->addChild(label3);
panelText->addChild(label4);
panelText->addChild(label5);
panelText->addChild(label6);
panelText->addChild(label7);
overlays.push_back(overlay1);
overlays.push_back(overlay2);
}
