Ogre::DataStreamPtr Utf8Archive::open(const String& _filename, bool _readOnly) const
{
String filename2 = _filename;
StringUtil::utf8ToAnsi(filename2);
Ogre::DataStreamPtr stream = mBaseArchive->open(filename2, _readOnly);
if(!stream.isNull())
static_cast<DataStream_NameHelper*>(stream.get())->setName(_filename);
return stream;
}
/*
void TextureAsset::RegenerateAllMipLevels()
{
if (ogreTexture.isNull())
return;
///\todo This function does not quite work, since ogreTexture->getNumMipmaps() will return 0 to denote a "full mipmap chain".
for(int f = 0; f < ogreTexture->getNumFaces(); ++f)
for(int i = 1; i < ogreTexture->getNumMipmaps(); ++i)
{
Ogre::HardwarePixelBufferSharedPtr src = ogreTexture->getBuffer(f, i-1);
Ogre::Box srcSize(0, 0, src->getWidth(), src->getHeight());
Ogre::HardwarePixelBufferSharedPtr dst = ogreTexture->getBuffer(f, i);
Ogre::Box dstSize(0, 0, dst->getWidth(), dst->getHeight());
dst->blit(src, srcSize, dstSize);
}
}
*/
bool TextureAsset::SerializeTo(std::vector<u8> &data, const QString &serializationParameters) const
{
if (ogreTexture.isNull())
{
LogWarning("SerializeTo: Called on an unloaded texture \"" + Name().toStdString() + "\".");
return false;
}
try
{
Ogre::Image new_image;
// From Ogre 1.7 Texture::convertToImage()
size_t numMips = 1;
size_t dataSize = Ogre::Image::calculateSize(numMips,
ogreTexture->getNumFaces(), ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
void* pixData = OGRE_MALLOC(dataSize, Ogre::MEMCATEGORY_GENERAL);
// if there are multiple faces and mipmaps we must pack them into the data
// faces, then mips
void* currentPixData = pixData;
for (size_t face = 0; face < ogreTexture->getNumFaces(); ++face)
{
for (size_t mip = 0; mip < numMips; ++mip)
{
size_t mipDataSize = Ogre::PixelUtil::getMemorySize(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
Ogre::PixelBox pixBox(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), currentPixData);
ogreTexture->getBuffer(face, mip)->blitToMemory(pixBox);
currentPixData = (void*)((char*)currentPixData + mipDataSize);
}
}
// load, and tell Image to delete the memory when it's done.
new_image.loadDynamicImage((Ogre::uchar*)pixData, ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), true,
ogreTexture->getNumFaces(), numMips - 1);
Ogre::DataStreamPtr imageStream = new_image.encode(serializationParameters.toStdString());
if (imageStream.get() && imageStream->size() > 0)
{
data.resize(imageStream->size());
imageStream->read(&data[0], data.size());
}
} catch (std::exception &e)
{
LogError("SerializeTo: Failed to export Ogre texture " + Name().toStdString() + ":");
if (e.what())
OgreRenderer::OgreRenderingModule::LogError(e.what());
return false;
}
return true;
}
void DotSceneLoader::processTerrainPage(rapidxml::xml_node<>* XMLNode)
{
Ogre::String name = getAttrib(XMLNode, "name");
int pageX = Ogre::StringConverter::parseInt(XMLNode->first_attribute("pageX")->value());
int pageY = Ogre::StringConverter::parseInt(XMLNode->first_attribute("pageY")->value());
Ogre::Real worldSize = getAttribReal(XMLNode, "worldSize");
int mapSize = Ogre::StringConverter::parseInt(XMLNode->first_attribute("mapSize")->value());
bool colourmapEnabled = getAttribBool(XMLNode, "colourmapEnabled");
int colourmapTexturesize = Ogre::StringConverter::parseInt(XMLNode->first_attribute("colourmapTexturesize")->value());
int layerCount = Ogre::StringConverter::parseInt(XMLNode->first_attribute("layerCount")->value());
Ogre::String filename = mTerrainGroup->generateFilename(pageX, pageY);
if (Ogre::ResourceGroupManager::getSingleton().resourceExists(mTerrainGroup->getResourceGroup(), filename))
{
mTerrainGroup->defineTerrain(pageX, pageY);
}
else
{
rapidxml::xml_node<>* pElement;
pElement = XMLNode->first_node("position");
if(pElement)
mTerrainPosition = parseVector3(pElement);
Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(name + Ogre::String(".ohm"), "General" );
size_t size = stream.get()->size();
if(size != mapSize * mapSize * 4)
{
OGRE_EXCEPT( Ogre::Exception::ERR_INTERNAL_ERROR, "Size of stream does not match terrainsize!", "TerrainPage" );
}
float* buffer = OGRE_ALLOC_T(float, size, Ogre::MEMCATEGORY_GEOMETRY);
stream->read(buffer, size);
Ogre::Terrain::ImportData& imp = mTerrainGroup->getDefaultImportSettings();
imp.terrainSize = mapSize;
imp.worldSize = worldSize;
imp.inputFloat = buffer;
imp.inputImage = 0;
imp.deleteInputData = true;
imp.minBatchSize = 33;
imp.maxBatchSize = 65;
imp.layerList.resize(layerCount);
int count = 0;
// Process layers (*)
rapidxml::xml_node<>* pTerrainLayer;
rapidxml::xml_node<>* pTerrainTextures;
rapidxml::xml_node<>* pTerrainTexture;
pElement = XMLNode->first_node("layers");
while(pElement)
{
pTerrainLayer = pElement->first_node("layer");
while(pTerrainLayer)
{
int worldSize = Ogre::StringConverter::parseInt(pTerrainLayer->first_attribute("worldSize")->value());
pTerrainTextures = pTerrainLayer->first_node("textures");
pTerrainTexture = pTerrainTextures->first_node("texture");
while(pTerrainTexture)
{
imp.layerList[count].textureNames.push_back(getAttrib(pTerrainTexture,"name",""));
imp.layerList[count].worldSize = (Ogre::Real)worldSize;
pTerrainTexture = pTerrainTexture->next_sibling("texture");
}
count++;
// do stuff
pTerrainLayer = pTerrainLayer->next_sibling("layer");
}
pElement = pElement->next_sibling("layers");
}
mTerrainGroup->defineTerrain(pageX, pageY, &imp);
}
}
int _tmain(int argc, _TCHAR* argv[])
{
// ------------------------- Check for command line argument -------------------------------------------
if (! argv[1])
{
printf("\n");
printf("Missing argument.\nExample: \"Converter.exe job1.cfg\"");
return 0;
}
// ------------------------- Basic Ogre Engine initialization -------------------------------------------
Ogre::Root* root = new Ogre::Root;
Ogre::RenderSystem* rendersys = root->getRenderSystemByName("Direct3D9 Rendering Subsystem");
rendersys->setConfigOption("Full Screen", "No");
rendersys->setConfigOption("Video Mode", "800 x 600 @ 32-bit colour");
root->setRenderSystem(rendersys);
Ogre::ResourceGroupManager::getSingleton().addResourceLocation("resource", "FileSystem", "General");
Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
root->initialise(false);
Ogre::RenderWindow* window = root->createRenderWindow("RAW2OGT", 800, 600, false);
Ogre::SceneManager* scenemgr = root->createSceneManager(Ogre::SceneType::ST_GENERIC);
Ogre::Camera* camera = scenemgr->createCamera("camera");
Ogre::Viewport* viewport = window->addViewport(camera);
/*Ogre::Vector3 lightdir(0, -0.3, 0.75);
lightdir.normalise();
Ogre::Light* l = scenemgr->createLight("tstLight");
l->setType(Ogre::Light::LT_DIRECTIONAL);
l->setDirection(lightdir);
l->setDiffuseColour(Ogre::ColourValue(1.0, 1.0, 1.0));
l->setSpecularColour(Ogre::ColourValue(0.4, 0.4, 0.4));*/
scenemgr->setAmbientLight(Ogre::ColourValue(0.7, 0.7, 0.7));
// --------------------------------- Start convert ----------------------------------------------------
// Load job config
Ogre::ConfigFile* terrainconfig = OGRE_NEW Ogre::ConfigFile();
terrainconfig->loadDirect(argv[1]);
// Load info from [general] block
Ogre::String heightmapfile = terrainconfig->getSetting("heightmap", "general");
Ogre::Real heightmapscale = Ogre::StringConverter::parseReal(terrainconfig->getSetting("heightmapscale", "general"));
Ogre::Real heightmapoffset = Ogre::StringConverter::parseReal(terrainconfig->getSetting("heightmapoffset", "general"));
Ogre::uint16 terrainsize = Ogre::StringConverter::parseUnsignedInt(terrainconfig->getSetting("terrainsize", "general"));
Ogre::Real worldsize = Ogre::StringConverter::parseReal(terrainconfig->getSetting("worldsize", "general"));
Ogre::uint16 layercount = Ogre::StringConverter::parseUnsignedInt(terrainconfig->getSetting("layercount", "general"));
// initialise stream to heightmapfile
Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(heightmapfile, "General");
size_t size = stream.get()->size();
// verify size
if(size != terrainsize * terrainsize * 4)
OGRE_EXCEPT( Ogre::Exception::ERR_INTERNAL_ERROR, "Size of stream does not match terrainsize!", "TerrainPage" );
// load to buffer
float* buffer = OGRE_ALLOC_T(float, size, Ogre::MEMCATEGORY_GENERAL);
stream->read(buffer, size);
// apply scale and offset
for(int i=0;i<terrainsize*terrainsize;i++)
{
buffer[i] = (buffer[i] + heightmapoffset) * heightmapscale;
}
// Terrain initialization
Ogre::TerrainGlobalOptions* terrainglobals = OGRE_NEW Ogre::TerrainGlobalOptions();
terrainglobals->setMaxPixelError(1);
//terrainglobals->setCompositeMapDistance(30000);
//terrainglobals->setLightMapDirection(lightdir);
//terrainglobals->setCompositeMapAmbient(scenemgr->getAmbientLight());
//terrainglobals->setCompositeMapDiffuse(l->getDiffuseColour());
Ogre::TerrainMaterialGeneratorA::SM2Profile* pMatProfile =
static_cast<Ogre::TerrainMaterialGeneratorA::SM2Profile*>(terrainglobals->getDefaultMaterialGenerator()->getActiveProfile());
pMatProfile->setLightmapEnabled(false);
pMatProfile->setCompositeMapEnabled(false);
Ogre::TerrainGroup* terraingroup = OGRE_NEW Ogre::TerrainGroup(scenemgr, Ogre::Terrain::ALIGN_X_Z, terrainsize, worldsize);
terraingroup->setFilenameConvention(Ogre::String("terrain"), Ogre::String("ogt"));
terraingroup->setOrigin(Ogre::Vector3::ZERO);
Ogre::Terrain* terrain = OGRE_NEW Ogre::Terrain(scenemgr);
// terrainsettings
Ogre::Terrain::ImportData& imp = terraingroup->getDefaultImportSettings();
imp.terrainSize = terrainsize;
imp.worldSize = worldsize;
imp.minBatchSize = 33;
imp.maxBatchSize = 65;
// use float RAW heightmap as input
imp.inputFloat = buffer;
// process texture layers
imp.layerList.resize(layercount);
Ogre::StringVector blendmaps(layercount);
for(int i=0;i<layercount;i++)
{
// load layer info
Ogre::String sectionStr = Ogre::StringConverter::toString(i);
Ogre::Real layerworldsize = Ogre::StringConverter::parseReal(terrainconfig->getSetting("worldsize", sectionStr));
if (i==0)
{
// no blendmap at layer 0 (baselayer)
Ogre::String specular = terrainconfig->getSetting("specular", sectionStr);
Ogre::String normal = terrainconfig->getSetting("normal", sectionStr);
// add layer
imp.layerList[i].textureNames.push_back(specular);
imp.layerList[i].textureNames.push_back(normal);
imp.layerList[i].worldSize = layerworldsize;
}
else
{
Ogre::String specular = terrainconfig->getSetting("specular", sectionStr);
Ogre::String normal = terrainconfig->getSetting("normal", sectionStr);
Ogre::String blend = terrainconfig->getSetting("blend", sectionStr);
// add layer
imp.layerList[i].textureNames.push_back(specular);
imp.layerList[i].textureNames.push_back(normal);
imp.layerList[i].worldSize = layerworldsize;
blendmaps[i] = blend;
}
}
// load the terrain
terrain->prepare(imp);
terrain->load();
// load those blendmaps into the layers
for(int j = 1;j < terrain->getLayerCount();j++)
{
Ogre::TerrainLayerBlendMap *blendmap = terrain->getLayerBlendMap(j);
Ogre::Image img;
img.load(blendmaps[j],"General");
int blendmapsize = terrain->getLayerBlendMapSize();
if(img.getWidth() != blendmapsize)
img.resize(blendmapsize, blendmapsize);
float *ptr = blendmap->getBlendPointer();
Ogre::uint8 *data = static_cast<Ogre::uint8*>(img.getPixelBox().data);
for(int bp = 0;bp < blendmapsize * blendmapsize;bp++)
ptr[bp] = static_cast<float>(data[bp]) / 255.0f;
blendmap->dirty();
blendmap->update();
}
// create filename for writing
int pos = heightmapfile.find_last_of('.');
if (pos < 0)
heightmapfile = heightmapfile + ".ogt";
else
heightmapfile = heightmapfile.substr(0, pos) + ".ogt";
// save as Ogre .OGT
terrain->save(heightmapfile);
Ogre::LogManager::getSingletonPtr()->logMessage(Ogre::LogMessageLevel::LML_NORMAL, heightmapfile + " successfully written.");
// debug viewing (exit with CTRL+C)
camera->setPosition(-terrainsize, 7000, -terrainsize);
camera->lookAt(terrainsize/2,0,terrainsize/2);
root->startRendering();
return 0;
}