//-----------------------------------------------------------------------
void Noise3D::noise2img(Ogre::ushort dimension)
{
double x = 0.0;
double y = 0.0;
double step = 1.0 / (double)dimension;
size_t buffSize = 4 * dimension * dimension; // Assume Image of pixelformat 32 bits (i.e. PF_R8G8B8A8)
Ogre::uchar* buff = new Ogre::uchar[buffSize];
size_t p = 0;
while (p < buffSize)
{
Ogre::uchar n = (Ogre::uchar)(255 * noise(x, y, 0.5));
buff[p] = n;
buff[p+1] = n;
buff[p+2] = n;
buff[p+3] = n;
p += 4;
x += step;
if (x >= 1.0)
{
x = 0.0;
y += step;
}
}
Ogre::Image* image = new Ogre::Image();
image->loadDynamicImage(buff, dimension, dimension, 0, Ogre::PF_R8G8B8A8 , false, 1, 0);
image->save("noise2img.png");
delete image;
delete [] buff;
}
Ogre::MaterialPtr TextureManager::makeOgreMaterial(int16_t MaterialTypeID, int16_t TextureID)
{
Ogre::MaterialPtr NewMaterial = Ogre::MaterialManager::getSingleton().create("GrassMaterial", "General", true);
Ogre::Image* NewImage = new Ogre::Image(); // Delete?
uint16_t ImageID = IMAGE->GenerateMaterialImage(MaterialTypeID, TextureID);
uint8_t* iData = IMAGE->getImageData(ImageID);
uint16_t Width = IMAGE->getImageWidth(ImageID);
uint16_t Height = IMAGE->getImageHeight(ImageID);
NewImage->loadDynamicImage(iData, Width, Height, Ogre::PF_A8R8G8B8);
Ogre::TexturePtr NewTex = Ogre::TextureManager::getSingleton().loadImage("TextureX", "General", *NewImage, Ogre::TEX_TYPE_2D, 1);
Ogre::Technique* FirstTechnique = NewMaterial->getTechnique(0);
Ogre::Pass* FirstPass = FirstTechnique->getPass(0);
FirstPass->setLightingEnabled(false);
Ogre::TextureUnitState* TextureUnit = FirstPass->createTextureUnitState();
TextureUnit->setTextureName("TextureX", Ogre::TEX_TYPE_2D);
delete NewImage;
return NewMaterial;
}
void OgreTexture::saveToFile(const std::string& _filename)
{
Ogre::uchar* readrefdata = (Ogre::uchar*)lock(TextureUsage::Read);
Ogre::Image img;
img = img.loadDynamicImage(readrefdata, mTexture->getWidth(), mTexture->getHeight(), mTexture->getFormat());
img.save(_filename);
unlock();
}
void WebView::captureImage(const std::string& filename)
{
#ifdef HAVE_AWESOMIUM
Ogre::Image result;
int bpp = isWebViewTransparent? 4 : 3;
unsigned char* buffer = OGRE_ALLOC_T(unsigned char, viewWidth * viewHeight * bpp, Ogre::MEMCATEGORY_GENERAL);
webView->render(buffer, viewWidth * bpp, bpp);
result.loadDynamicImage(buffer, viewWidth, viewHeight, 1, isWebViewTransparent? Ogre::PF_BYTE_BGRA : Ogre::PF_BYTE_BGR, false);
result.save(Awesomium::WebCore::Get().getBaseDirectory() + "\\" + filename);
OGRE_FREE(buffer, Ogre::MEMCATEGORY_GENERAL);
#endif
}
void Simple::addLightingPass(Ogre::Technique* technique, std::set<std::string>& managedTextures) const
{
Ogre::Pass* lightingPass = technique->createPass();
lightingPass->setSceneBlending(Ogre::SBT_MODULATE);
lightingPass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitStateSplat = lightingPass->createTextureUnitState();
//we need an unique name for our alpha texture
std::stringstream lightingTextureNameSS;
lightingTextureNameSS << technique->getParent()->getName() << "_lighting";
const Ogre::String lightingTextureName(lightingTextureNameSS.str());
Ogre::TexturePtr texture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(lightingTextureName));
if (texture.isNull()) {
texture = Ogre::Root::getSingletonPtr()->getTextureManager()->createManual(lightingTextureName, "General", Ogre::TEX_TYPE_2D, mPage.getBlendMapSize(), mPage.getBlendMapSize(), 1, Ogre::PF_L8, Ogre::TU_DYNAMIC_WRITE_ONLY);
managedTextures.insert(texture->getName());
}
Ogre::Image ogreImage;
ogreImage.loadDynamicImage(const_cast<unsigned char*>(mLightingImage->getData()), mLightingImage->getResolution(), mLightingImage->getResolution(), 1, Ogre::PF_L8);
texture->loadImage(ogreImage);
//blit the whole image to the hardware buffer
Ogre::PixelBox sourceBox(ogreImage.getPixelBox());
//blit for each mipmap
for (unsigned int i = 0; i <= texture->getNumMipmaps(); ++i) {
Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(texture->getBuffer(0, i));
hardwareBuffer->blitFromMemory(sourceBox);
}
textureUnitStateSplat->setTextureName(texture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
}
void GlobalMap::exploreCell(int cellX, int cellY)
{
float originX = static_cast<float>((cellX - mMinX) * mCellSize);
// NB y + 1, because we want the top left corner, not bottom left where the origin of the cell is
float originY = static_cast<float>(mHeight - (cellY + 1 - mMinY) * mCellSize);
if (cellX > mMaxX || cellX < mMinX || cellY > mMaxY || cellY < mMinY)
return;
Ogre::TexturePtr localMapTexture = Ogre::TextureManager::getSingleton().getByName("Cell_"
+ boost::lexical_cast<std::string>(cellX) + "_" + boost::lexical_cast<std::string>(cellY));
if (!localMapTexture.isNull())
{
int mapWidth = localMapTexture->getWidth();
int mapHeight = localMapTexture->getHeight();
mOverlayTexture->load();
mOverlayTexture->getBuffer()->blit(localMapTexture->getBuffer(), Ogre::Image::Box(0,0,mapWidth,mapHeight),
Ogre::Image::Box(static_cast<Ogre::uint32>(originX), static_cast<Ogre::uint32>(originY),
static_cast<Ogre::uint32>(originX + mCellSize), static_cast<Ogre::uint32>(originY + mCellSize)));
Ogre::Image backup;
std::vector<Ogre::uchar> data;
data.resize(mCellSize*mCellSize*4, 0);
backup.loadDynamicImage(&data[0], mCellSize, mCellSize, Ogre::PF_A8B8G8R8);
localMapTexture->getBuffer()->blitToMemory(Ogre::Image::Box(0,0,mapWidth,mapHeight), backup.getPixelBox());
for (int x=0; x<mCellSize; ++x)
for (int y=0; y<mCellSize; ++y)
{
assert (originX+x < mOverlayImage.getWidth());
assert (originY+y < mOverlayImage.getHeight());
assert (x < int(backup.getWidth()));
assert (y < int(backup.getHeight()));
mOverlayImage.setColourAt(backup.getColourAt(x, y, 0), static_cast<size_t>(originX + x), static_cast<size_t>(originY + y), 0);
}
}
}
void MapView::createTerrainFromFile()
{
if (mMap->getTexture().size())
{
mMaterial = (Ogre::MaterialPtr)
Ogre::MaterialManager::getSingleton().getByName(mMap->getTexture());
if (mMaterial.isNull())
{
mMaterial = (Ogre::MaterialPtr)
Ogre::MaterialManager::getSingleton().create(mMap->getTexture(), "General");
mMaterial->getTechnique(0)->getPass(0)->createTextureUnitState(mMap->getTexture());
mMaterial->getTechnique(0)->getPass(0)->setVertexColourTracking(Ogre::TVC_AMBIENT);
}
}
else
{
mMaterial = (Ogre::MaterialPtr)
Ogre::MaterialManager::getSingleton().getByName("terrain");
}
Ogre::Image img;
Ogre::uchar* data = new Ogre::uchar[mMap->getTerrainData().size()];
float min = mMap->getTerrainData()[0];
float max = mMap->getTerrainData()[0];
for (size_t i = 1; i < mMap->getTerrainData().size(); ++i)
{
if (mMap->getTerrainData()[i] < min) min = mMap->getTerrainData()[i];
else if (mMap->getTerrainData()[i] > max) max = mMap->getTerrainData()[i];
}
for (size_t i = 0; i < mMap->getTerrainData().size(); ++i)
{
data[i] = mMap->getTerrainData()[i];
}
img.loadDynamicImage(
data,
mMap->getTerrainSize().x,
mMap->getTerrainSize().z,
1, Ogre::PF_L8);
// Save bitmap file.
std::string name(Convert::ToString(mMap->getID()));
img.save("..\\cache\\" + name + ".png");
// Create config file.
std::ofstream config(
("..\\cache\\" + name + ".cfg").c_str(),
std::ios::out | std::ios::trunc);
config << "DetailTile=3" << "\n";
config << "PageSource=Heightmap" << "\n";
config << "Heightmap.image=" << "..\\cache\\" << name << ".png" << "\n";
config << "PageSize=" << mMap->getTerrainSize().x << "\n";
config << "TileSize=33" << "\n";
config << "MaxPixelError=3" << "\n";
config << "PageWorldX=" << mMap->getSize().x << "\n";
config << "PageWorldZ=" << mMap->getSize().z << "\n";
config << "MaxHeight=255" << "\n";
config << "MaxMipMapLevel=5" << "\n";
config << "VertexNormals=yes" << "\n";
config << "VertexColors=yes" << "\n";
config << "VertexProgramMorph=yes" << "\n";
config << "LODMorphStart=0.2" << "\n";
config << "CustomMaterialName=" << mMaterial->getName() << "\n";
config.close();
delete[] data;
mManager->setWorldGeometry("..\\cache\\" + name + ".cfg");
}
//--------------------------------------------------------------------------------------------------
bool DiscoApplication::frameStarted( const Ogre::FrameEvent& evt )
{
static Ogre::Timer a;
static uint32_t lastTimeMS;
static uint32_t curTimeMS;
curTimeMS = a.getMilliseconds();
uint32_t timeDiffMS = curTimeMS - lastTimeMS;
if ( timeDiffMS > 0 )
{
//printf( "FPS = %f\n", 1000.0/(float)timeDiffMS );//1.0/((float)timeDiffMS/1000.0) );
}
lastTimeMS = curTimeMS;
const int32_t MAX_DEPTH_MM = 10000;
const float FOCAL_LENGTH = 0.525f; // Focal length in metres
const float FADE_START_XZ_DISTANCE = 0.5f;
const float FADE_MAX_XZ_DISTANCE = 6.0f;
xn::SceneMetaData sceneMD;
xn::DepthMetaData depthMD;
mpKinectController->getContext().WaitAndUpdateAll();
mpKinectController->getDepthGenerator().GetMetaData( depthMD );
mpKinectController->getUserGenerator().GetUserPixels( 0, sceneMD );
XnUserID userIdx[15];
XnUInt16 numUsers = 15;
mpKinectController->getUserGenerator().GetUsers( userIdx, numUsers );
if ( 0 == numUsers )
{
// Restart the time if there are no users to record
mRecordingGapTimer.reset();
}
else
{
for ( uint32_t i = 0; i < numUsers; i++ )
{
if ( tryToAttachParticleToUser( userIdx[ i ] ) )
{
break;
}
}
}
// Start recording if we see a person
if ( numUsers > 0 && !mbRecording
&& mRecordingGapTimer.getMilliseconds() > TIME_BETWEEN_RECORDINGS_MS )
{
mbRecording = true;
memset( mpImageData, 0, RECORDED_DATA_SIZE );
mRecordingFrameIdx = 0;
}
// Build an accumulative histogram to work out the colour for each point
uint32_t depthHist[ MAX_DEPTH_MM ];
memset( depthHist, 0, sizeof( depthHist ) );
uint32_t numPoints = 0;
const XnDepthPixel* pDepth = depthMD.Data();
int32_t recordingPixelStepX = depthMD.XRes() / SMALL_FRAME_WIDTH;
int32_t recordingPixelStepY = depthMD.YRes() / SMALL_FRAME_HEIGHT;
if ( recordingPixelStepX <= 0 ) recordingPixelStepX = 1;
if ( recordingPixelStepY <= 0 ) recordingPixelStepY = 1;
for ( uint32_t y = 0; y < depthMD.YRes(); y++ )
{
for ( uint32_t x = 0; x < depthMD.XRes(); x++ )
{
XnUInt16 value = *pDepth;
if ( 0 != value )
{
depthHist[ value ]++;
numPoints++;
}
pDepth++;
}
}
for ( uint32_t i = 1; i < MAX_DEPTH_MM; i++ )
{
depthHist[ i ] += depthHist[ i - 1 ];
}
if ( numPoints > 0 )
{
for ( uint32_t i = 1; i < MAX_DEPTH_MM; i++ )
{
depthHist[ i ] = (unsigned int)(256 * (1.0f - ((float)depthHist[ i ] / numPoints)));
}
}
// Update the point cloud to reflect the depth data
const float COLOURS[][3] =
{
{0,1,1},
{0,0,1},
{0,1,0},
{1,1,0},
{1,0,0},
{1,.5,0},
{.5,1,0},
{0,.5,1},
{.5,0,1},
{1,1,.5},
{1,1,1}
};
const uint32_t NUM_COLOURS = 10;
pDepth = depthMD.Data();
const XnLabel* pLabels = sceneMD.Data();
mpRosPointCloud->clear();
ogre_tools::PointCloud::Point* pPoints = new ogre_tools::PointCloud::Point[ numPoints ];
int32_t pointIdx = 0;
int32_t width = depthMD.XRes();
int32_t height = depthMD.YRes();
int32_t halfWidth = width / 2;
int32_t halfHeight = height / 2;
for ( int32_t y = 0; y < height; y++ )
{
for ( int32_t x = 0; x < width; x++ )
{
XnUInt16 value = *pDepth;
XnLabel label = *pLabels;
XnUInt32 colorId = label % NUM_COLOURS;
float fade = 1.0;
if (label == 0)
{
// Ignore background
colorId = NUM_COLOURS;
}
{
float worldZ = (float)(*pDepth)/1000.0; // Convert from mm to m
float worldX = (((float)(x-halfWidth)/1000.0)*worldZ) / FOCAL_LENGTH;
float distanceXZ = sqrtf( worldX*worldX + worldZ*worldZ );
if ( distanceXZ > FADE_MAX_XZ_DISTANCE )
{
fade = 0.0f;
}
else if ( distanceXZ > FADE_START_XZ_DISTANCE )
{
fade = 1.0 - (distanceXZ - FADE_START_XZ_DISTANCE)/(FADE_MAX_XZ_DISTANCE - FADE_START_XZ_DISTANCE);
}
}
if ( //mbRecording
0 != value && fade > 0.0
&& ( SHOW_BACKGROUND || label != 0 ) )
{
float worldZ = (float)(*pDepth)/1000.0; // Convert from mm to m
float worldX = (((float)(x-halfWidth)/1000.0)*worldZ) / FOCAL_LENGTH;
float worldY = (((float)(y-halfHeight)/1000.0)*worldZ) / FOCAL_LENGTH;
//float worldY = (((float)(((height-1)-y)-halfHeight)/1000.0)*worldZ) / FOCAL_LENGTH;
float histValue = (float)depthHist[ value ]/255.0;
pPoints[ pointIdx ].setColor(
fade * histValue * COLOURS[ colorId ][ 0 ],
fade * histValue * COLOURS[ colorId ][ 1 ],
fade * histValue * COLOURS[ colorId ][ 2 ] );
pPoints[ pointIdx ].x = worldX;
pPoints[ pointIdx ].y = worldY;
pPoints[ pointIdx ].z = worldZ;
pointIdx++;
if ( mbRecording && label != 0
&& x%recordingPixelStepX == 0 && y%recordingPixelStepY == 0 )
{
int32_t smallFrameX = x / recordingPixelStepX;
int32_t smallFrameY = y / recordingPixelStepY;
int32_t smallPixelIdx = mRecordingFrameIdx*SMALL_FRAME_WIDTH*SMALL_FRAME_HEIGHT
+ smallFrameY*SMALL_FRAME_WIDTH + smallFrameX;
//((uint16_t*)mpImageData)[ smallPixelIdx ] = 0xFFFF;
//((uint32_t*)mpImageData)[ smallPixelIdx ] = 0xFFFFFFFF;
mpImageData[ smallPixelIdx ] = 0xFF; // 255; //(uint8_t)(fade * histValue * 255.0);
//printf( "recorded %i to pixel %i\n", mpImageData[ smallPixelIdx ], smallPixelIdx );
}
}
pDepth++;
pLabels++;
}
}
mpRosPointCloud->addPoints( pPoints, pointIdx );
//printf( "Added %i points\n", pointIdx );
delete [] pPoints;
// Draw the crowd
uint32_t numCrowdMembers = mCrowdMembers.size();
mpCrowdObject->clear();
mpCrowdObject->estimateVertexCount( numCrowdMembers*4 );
mpCrowdObject->estimateIndexCount( numCrowdMembers*12 );
for ( uint32_t personIdx = 0; personIdx < numCrowdMembers; personIdx++ )
{
CrowdMember& crowdMember = mCrowdMembers[ personIdx ];
float startV = (float)crowdMember.mFrameIdx/(float)NUM_FRAMES_TO_RECORD;
float endV = (float)(crowdMember.mFrameIdx+1)/(float)NUM_FRAMES_TO_RECORD;
mpCrowdObject->begin( crowdMember.mMaterialName, Ogre::RenderOperation::OT_TRIANGLE_LIST );
//float startV = 0.0; //(float)crowdMember.mFrameIdx/(float)NUM_FRAMES_TO_RECORD;
//float endV = 1.0;// (float)(crowdMember.mFrameIdx+1)/(float)NUM_FRAMES_TO_RECORD;
//mpCrowdObject->begin( "Template/CutOut", Ogre::RenderOperation::OT_TRIANGLE_LIST );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( -0.5f, -0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 0.0, startV );
mpCrowdObject->colour( COLOURS[ crowdMember.mColourIdx ][ 0 ],
COLOURS[ crowdMember.mColourIdx ][ 1 ], COLOURS[ crowdMember.mColourIdx ][ 2 ], 1.0 );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( 0.5f, -0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 1.0, startV );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( 0.5f, 0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 1.0, endV );
mpCrowdObject->position( crowdMember.mPos + Ogre::Vector3( -0.5f, 0.375f, 0.0f ) );
mpCrowdObject->textureCoord( 0.0, endV );
//mpCrowdObject->quad( 0, 1, 2, 3 );
mpCrowdObject->quad( 3, 2, 1, 0 );
mpCrowdObject->end();
// Move to the next frame
if ( crowdMember.mbReversing )
{
crowdMember.mFrameIdx--;
if ( crowdMember.mFrameIdx < 0 )
{
crowdMember.mFrameIdx = 1;
crowdMember.mbReversing = false;
}
}
else
{
crowdMember.mFrameIdx++;
if ( crowdMember.mFrameIdx >= NUM_FRAMES_TO_RECORD )
{
crowdMember.mFrameIdx = NUM_FRAMES_TO_RECORD-1;
crowdMember.mbReversing = true;
}
}
}
// Check to see if we can stop recording
if ( mbRecording )
{
mRecordingFrameIdx++;
if ( mRecordingFrameIdx >= NUM_FRAMES_TO_RECORD )
{
// Create a new crowd member
Ogre::Image image;
image.loadDynamicImage(
mpImageData, SMALL_FRAME_WIDTH, NUM_FRAMES_TO_RECORD*SMALL_FRAME_HEIGHT, 1, Ogre::PF_A4L4 );
std::stringstream ss;
ss << "RecordedSequenceTex_" << numCrowdMembers;
Ogre::String texName = ss.str();
Ogre::TextureManager* pTextureMgr = Ogre::TextureManager::getSingletonPtr();
Ogre::TexturePtr pTexture = pTextureMgr->loadImage( texName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, image );
ss.clear();
ss << "RecordedSequenceMat_" << numCrowdMembers;
Ogre::String matName = ss.str();
Ogre::MaterialManager* pMatMgr = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialPtr pSrcMat = (Ogre::MaterialPtr)pMatMgr->getByName( "Template/CutOut", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
Ogre::MaterialPtr pMat = pSrcMat->clone( matName ); // (Ogre::MaterialPtr)pMatMgr->create( matName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
pMat->getTechnique( 0 )->getPass( 0 )->removeAllTextureUnitStates();
Ogre::TextureUnitState* pTex = pMat->getTechnique( 0 )->getPass( 0 )->createTextureUnitState( texName, 0 );
pMat->getTechnique( 0 )->getPass( 0 )->addTextureUnitState( pTex );
/*Ogre::Technique* pTech = pMat->getTechnique( 0 );
pTech->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
Ogre::Pass *pPass = pTech->createPass();
pPass->setLightingEnabled( false );
pPass->setAmbient( 1.0, 1.0, 1.0 );
pPass->setDiffuse( 1.0, 1.0, 1.0, 1.0 );
pPass->setSpecular( 0.0, 0.0, 0.0, 0.0 );
Ogre::ColourValue val(0.0f, 0.0f, 0.0f, 1.0f);
pPass->setSelfIllumination(val);
//pPass->setE ( 0.0, 0.0, 0.0, 0.0 );
pPass->setSceneBlending( Ogre::SBT_TRANSPARENT_ALPHA );
pPass->setDepthWriteEnabled( false );
Ogre::TextureUnitState* pTex = pPass->createTextureUnitState( texName, 0 );
pPass->addTextureUnitState( pTex );
pTex->setColourOperation( Ogre::LBO_MODULATE );*/
pMat->setCullingMode( Ogre::CULL_NONE );
pMat->compile();
CrowdMember crowdMember;
crowdMember.mMaterialName = matName;
crowdMember.mFrameIdx = 0;
crowdMember.mColourIdx = rand()%NUM_COLOURS;
crowdMember.mbReversing = false;
int32_t rowIdx = rand()%NUM_ROWS;
float angle = MIN_CROWD_ANGLE + ((float)rand()/(float)RAND_MAX)*(MAX_CROWD_ANGLE-MIN_CROWD_ANGLE);
float x = ROW_DEPTHS[ rowIdx ]*sin( angle );
float z = ROW_DEPTHS[ rowIdx ]*cos( angle );
crowdMember.mPos = Ogre::Vector3( x, ROW_HEIGHTS[ rowIdx ], z );
mCrowdMembers.push_back( crowdMember );
mbRecording = false;
mRecordingGapTimer.reset(); // Reset time so that there's a gap between recording
printf( "Got frame\n" );
}
}
return true;
}
void TerrainGeometryManager::initBlendMaps(int x, int z, Ogre::Terrain* terrain )
{
bool debugBlendMaps = BOPT("DebugBlendMaps", false);
int layerCount = terrain->getLayerCount();
for (int i = 1; i < layerCount; i++)
{
blendLayerInfo_t &bi = blendInfo[i];
if(bi.blendMapTextureFilename.empty()) continue;
Ogre::Image img;
//std::pair<uint8,uint8> textureIndex = terrain->getLayerBlendTextureIndex(i);
//uint8 bti = terrain->getBlendTextureIndex(i);
try
{
img.load(bi.blendMapTextureFilename, ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
} catch(Exception &e)
{
LOG("Error loading blendmap: " + bi.blendMapTextureFilename + " : " + e.getFullDescription());
continue;
}
TerrainLayerBlendMap *blendmap = terrain->getLayerBlendMap(i);
// resize that blending map so it will fit
Ogre::uint32 blendmapSize = terrain->getLayerBlendMapSize();
if (img.getWidth() != blendmapSize)
img.resize(blendmapSize, blendmapSize);
// now to the ugly part
float* ptr = blendmap->getBlendPointer();
for (Ogre::uint32 z = 0; z != blendmapSize; z++)
{
for (Ogre::uint32 x = 0; x != blendmapSize; x++)
{
Ogre::ColourValue c = img.getColourAt(x, z, 0);
float alpha = bi.alpha;
if (bi.blendMode == 'R')
*ptr++ = c.r * alpha;
else if (bi.blendMode == 'G')
*ptr++ = c.g * alpha;
else if (bi.blendMode == 'B')
*ptr++ = c.b * alpha;
else if (bi.blendMode == 'A')
*ptr++ = c.a * alpha;
}
}
blendmap->dirty();
blendmap->update();
}
if (debugBlendMaps)
{
for (int i = 1; i < layerCount; i++)
{
Ogre::TerrainLayerBlendMap* blendMap = terrain->getLayerBlendMap(i);
Ogre::uint32 blendmapSize = terrain->getLayerBlendMapSize();
Ogre::Image img;
unsigned short *idata = OGRE_ALLOC_T(unsigned short, blendmapSize * blendmapSize, Ogre::MEMCATEGORY_RESOURCE);
float scale = 65535.0f;
for (unsigned int x = 0; x < blendmapSize; x++)
for (unsigned int z = 0; z < blendmapSize; z++)
idata[x + z * blendmapSize] = (unsigned short)(blendMap->getBlendValue(x, blendmapSize - z) * scale);
img.loadDynamicImage((Ogre::uchar*)(idata), blendmapSize, blendmapSize, Ogre::PF_L16);
std::string fileName = "blendmap_layer_" + Ogre::StringConverter::toString(i) + ".png";
img.save(fileName);
OGRE_FREE(idata, Ogre::MEMCATEGORY_RESOURCE);
}
}
}
bool MiniMapMaker::outputTextures(void)
{
// 如果需要（纹理大小改变了或第一次输出文件时），就重建render texture
if (mNeedRecreate)
{
destroy();
init();
}
mTempOutputFileNames.clear();
static const String TEMP_GROUP_NAME = "#TEMP#";
// 创建临时的资源组
Ogre::ResourceGroupManager& rgm = Ogre::ResourceGroupManager::getSingleton();
rgm.addResourceLocation(mPath, "FileSystem", TEMP_GROUP_NAME, false);
// 合并所有物体的包围盒
Ogre::AxisAlignedBox aabb;
Ogre::SceneManager::MovableObjectIterator itm =
mManipulator->getSceneManager()->getMovableObjectIterator(Ogre::EntityFactory::FACTORY_TYPE_NAME);
while (itm.hasMoreElements())
{
Ogre::MovableObject* movable = itm.getNext();
aabb.merge(movable->getWorldBoundingBox(true));
}
mCamera->setFarClipDistance(mCamera->getNearClipDistance() + 2 * (aabb.getMaximum().y - aabb.getMinimum().y ));
mCamera->setNearClipDistance(mTileSize/2);
// 设置摄像机的高度
Real yPos = mCamera->getNearClipDistance() + aabb.getMaximum().y;
TerrainData* terrainData = mManipulator->getTerrainData();
assert (terrainData);
float terrainHeight = terrainData->mMaxZ - terrainData->mMinZ;
float terrainWidth = terrainData->mMaxX - terrainData->mMinX;
// 投影的真正面积
Real projectSize = 0.0f;
// 最终切割成小块纹理的块数
int xIndex = 0;
int zIndex = 0;
Ogre::Vector3 originPoint(Ogre::Vector3::ZERO);
if (mUseRealCameraAngle)
{
float outerSquareWidth = 0.0f;
float outerSquareHeight = 0.0f;
Ogre::Radian alphaAngle = Ogre::Math::ATan( Ogre::Math::Abs(mMoveZDir.z / mMoveZDir.x) );
switch (mCameraDirQuadrant)
{
case WestNorth :
{
float leftWidth = Ogre::Math::Sin(alphaAngle) * terrainHeight;
float rightWidth = Ogre::Math::Cos(alphaAngle) * terrainWidth;
outerSquareWidth = leftWidth + rightWidth;
float topHeight = Ogre::Math::Cos(alphaAngle) * terrainHeight;
float bottomHeight = Ogre::Math::Sin(alphaAngle) * terrainWidth;
outerSquareHeight = topHeight + bottomHeight;
originPoint = Ogre::Vector3(terrainData->mMinX,0,terrainData->mMinZ) +
(-mMoveZDir * leftWidth);
float projectOffset = yPos / Ogre::Math::Tan(mCamDirAngle);
originPoint.x += (mInvertCameraDir * projectOffset ).x;
originPoint.z += (mInvertCameraDir * projectOffset ).z;
break;
}
case EastNorth :
{
float leftWidth = Ogre::Math::Cos(alphaAngle) * terrainWidth;
float rightWidth = Ogre::Math::Sin(alphaAngle) * terrainHeight;
outerSquareWidth = leftWidth + rightWidth;
float topHeight = Ogre::Math::Cos(alphaAngle) * terrainHeight;
float bottomHeight = Ogre::Math::Sin(alphaAngle) * terrainWidth;
outerSquareHeight = topHeight + bottomHeight;
originPoint = Ogre::Vector3(terrainData->mMaxX,0,terrainData->mMinZ) +
(-mMoveZDir * leftWidth);
float projectOffset = yPos / Ogre::Math::Tan(mCamDirAngle);
originPoint.x += (mInvertCameraDir * projectOffset ).x;
originPoint.z += (mInvertCameraDir * projectOffset ).z;
break;
}
case EastSouth :
{
float leftWidth = Ogre::Math::Sin(alphaAngle) * terrainHeight;
float rightWidth = Ogre::Math::Cos(alphaAngle) * terrainWidth;
outerSquareWidth = leftWidth + rightWidth;
float topHeight = Ogre::Math::Sin(alphaAngle) * terrainWidth;
float bottomHeight = Ogre::Math::Cos(alphaAngle) * terrainHeight;
outerSquareHeight = topHeight + bottomHeight;
originPoint = Ogre::Vector3(terrainData->mMaxX,0,terrainData->mMaxZ) +
(-mMoveZDir * topHeight);
float projectOffset = yPos / Ogre::Math::Tan(mCamDirAngle);
originPoint.x += (mInvertCameraDir * projectOffset ).x;
originPoint.z += (mInvertCameraDir * projectOffset ).z;
break;
}
case WestSouth :
{
float leftWidth = Ogre::Math::Sin(alphaAngle) * terrainHeight;
float rightWidth = Ogre::Math::Cos(alphaAngle) * terrainWidth;
outerSquareWidth = leftWidth + rightWidth;
float topHeight = Ogre::Math::Sin(alphaAngle) * terrainWidth;
float bottomHeight = Ogre::Math::Cos(alphaAngle) * terrainHeight;
outerSquareHeight = topHeight + bottomHeight;
originPoint = Ogre::Vector3(terrainData->mMinX,0,terrainData->mMaxZ) +
(-mMoveZDir * rightWidth);
float projectOffset = yPos / Ogre::Math::Tan(mCamDirAngle);
originPoint.x += (mInvertCameraDir * projectOffset ).x;
originPoint.z += (mInvertCameraDir * projectOffset ).z;
break;
}
default:
{
OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR,
" wrong camera dir " + Ogre::StringConverter::toString(mCameraDir),
"MiniMapMaker::outputTextures");
break;
}
}
// 计算投影的长度
Real factor = Ogre::Math::Sin(mCamDirAngle);
if (factor > 0.0f && factor != 1.0f)
projectSize = mTileSize / factor;
// 根据当前场景的大小，计算需要的分块数
xIndex = Ogre::Math::Ceil( (outerSquareWidth) / mTileSize ) + 1;
zIndex = Ogre::Math::Ceil( (outerSquareHeight) / projectSize ) + 1;
}
else
{
xIndex = Ogre::Math::Ceil( (terrainData->mMaxX - terrainData->mMinX) / mTileSize ) + 1;
zIndex = Ogre::Math::Ceil( (terrainData->mMaxZ - terrainData->mMinZ) / mTileSize ) + 1;
originPoint.x = terrainData->mMinX;
originPoint.z = terrainData->mMinZ;
}
// 计算最终的mini map的大小
uint miniMapWidth = xIndex * mTexWidth;
uint miniMapHeight = zIndex * mTexHeight;
if ( miniMapWidth > 10000 || miniMapHeight > 10000 )
{
mLastErrorString = "texture size is out of range!";
return false;
}
// 创建mini map所需的内存空间
uchar* miniMapData = new uchar[miniMapWidth * miniMapHeight * Ogre::PixelUtil::getNumElemBytes(mOutPutFormat)];
//// 初始的摄像机位置
Real xPos = originPoint.x;
Real zPos = originPoint.z;
for ( int i=0; i<xIndex; ++i )
{
for ( int j=0; j<zIndex; ++j )
{
// 设置摄像机位置，并更新render texture的内容
mCamera->setPosition(xPos, yPos, zPos);
mRenderTexture->update();
String fileName = mPath + mSceneBaseName + Ogre::StringConverter::toString(i)
+ "_" + Ogre::StringConverter::toString(j) + "." + mTexExtension;
// 输出小纹理文件
mRenderTexture->writeContentsToFile(fileName);
mTempOutputFileNames.push_back(fileName);
// 读取刚创建的纹理
Ogre::Image* tempImage = new Ogre::Image;
tempImage->load(mSceneBaseName + Ogre::StringConverter::toString(i)
+ "_" + Ogre::StringConverter::toString(j) + "." + mTexExtension, TEMP_GROUP_NAME);
// 获取render texture中的内容
uchar* tempImageData = tempImage->getData();
// 定位在mini map中的左上角
uint miniMapIndex = ( j * mTexHeight * miniMapWidth + i * mTexWidth ) * Ogre::PixelUtil::getNumElemBytes(mOutPutFormat);
uchar* startData = miniMapData + miniMapIndex;
for ( size_t height = 0; height < tempImage->getHeight(); ++height )
{
for ( size_t width = 0; width < tempImage->getWidth(); ++width )
{
memcpy(startData, tempImageData, Ogre::PixelUtil::getNumElemBytes(mOutPutFormat));
startData += Ogre::PixelUtil::getNumElemBytes(mOutPutFormat);
tempImageData += Ogre::PixelUtil::getNumElemBytes( tempImage->getFormat() );
}
startData += (miniMapWidth - tempImage->getWidth()) * Ogre::PixelUtil::getNumElemBytes(mOutPutFormat);
}
delete tempImage;
// 移动摄像机的z坐标
if (mUseRealCameraAngle)
{
zPos += (mInvertCameraDir * (projectSize)).z;
xPos += (mInvertCameraDir * (projectSize)).x;
}
else
zPos += mTileSize;
}
if (mUseRealCameraAngle)
{
xPos = originPoint.x;
zPos = originPoint.z;
xPos += (mMoveZDir * (mTileSize) * (i+1)).x;
zPos += (mMoveZDir * (mTileSize) * (i+1)).z;
}
else
{
// 操作完每一列之后，重置摄像机的z坐标
zPos = terrainData->mMinZ;
// 移动摄像机的x坐标
xPos += mTileSize;
}
}
// 保存mini map并输出
Ogre::Image* miniMapImage = new Ogre::Image;
miniMapImage->loadDynamicImage(miniMapData, miniMapWidth, miniMapHeight, 1, mOutPutFormat, true);
miniMapImage->save(mPath + mOutFileName + "." + mTexExtension);
delete miniMapImage;
rgm.destroyResourceGroup(TEMP_GROUP_NAME);
return true;
}
// void TerrainPageSurfaceCompiler::addTextureUnitsToPass(Ogre::Pass* pass, const Ogre::String& splatTextureName) {
//
// if (getMaxTextureUnits() - pass->getNumTextureUnitStates() < 2 || pass->getParent()->getNumPasses() > 1) {
// addPassToTechnique(pass->getParent(), splatTextureName);
// // S_LOG_WARNING("Trying to add texture units to pass with too few available texture unit states.");
// return;
// }
//
// S_LOG_VERBOSE("Adding new texture unit (detailtexture: " << mTextureName << " alphatexture: " << splatTextureName << ") to pass nr " << pass->getIndex() << " in technique for material " << pass->getParent()->getParent()->getName());
//
// /* pass->setSelfIllumination(Ogre::ColourValue(1,1,1));
// pass->setAmbient(Ogre::ColourValue(1,1,1));
// pass->setDiffuse(Ogre::ColourValue(1,1,1));
// pass->setLightingEnabled(true);*/
// Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
// textureUnitStateSplat->setTextureName(splatTextureName);
//
// textureUnitStateSplat->setTextureCoordSet(0);
// textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
// textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
// // textureUnitStateSplat->setColourOperationEx(Ogre::LBX_BLEND_TEXTURE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
// Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
// textureUnitState->setTextureName(mTextureName);
// textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// /* textureUnitState->setTextureCoordSet(0);*/
// textureUnitState->setTextureScale(0.025, 0.025);
// textureUnitState->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
//
// /* Ogre::TextureUnitState * alphaTextureState= pass->createTextureUnitState();
// alphaTextureState->setTextureName(mTextureName);
// // alphaTextureState->setTextureName(splatTextureName);
// alphaTextureState->setTextureCoordSet(0);
// alphaTextureState->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// alphaTextureState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
// alphaTextureState->setColourOperationEx(Ogre::LBX_BLEND_DIFFUSE_ALPHA, Ogre::LBS_CURRENT, Ogre::LBS_TEXTURE);
//
//
//
// // detailTextureState->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
// // detailTextureState->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
//
// Ogre::TextureUnitState * detailTextureState = pass->createTextureUnitState();
// detailTextureState ->setTextureName(splatTextureName);
// // detailTextureState ->setTextureName(mTextureName);
// detailTextureState ->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
// detailTextureState ->setTextureCoordSet(0);
// detailTextureState ->setTextureScale(0.01, 0.01);
// //detailTextureState ->setColourOperationEx(Ogre::LBX_BLEND_CURRENT_ALPHA, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);*/
//
// }
//
Ogre::Pass* Simple::addPassToTechnique(const TerrainPageGeometry& geometry, Ogre::Technique* technique, const Layer& layer, std::set<std::string>& managedTextures) const
{
//check if we instead can reuse the existing pass
// if (technique->getNumPasses() != 0) {
// Ogre::Pass* pass = technique->getPass(technique->getNumPasses() - 1);
// if (4 - pass->getNumTextureUnitStates() >= 2) {
// //there's more than two texture units available, use those instead of creating a new pass
// S_LOG_VERBOSE("Reusing existing pass. ("<< pass->getNumTextureUnitStates() << " of "<< mNumberOfTextureUnitsOnCard << " texture unit used)");
// addTextureUnitsToPass(pass, splatTextureName);
// return pass;
// }
//
// }
const OgreImage& ogreImage = *layer.blendMap;
Ogre::Image image;
image.loadDynamicImage(const_cast<unsigned char*>(ogreImage.getData()), ogreImage.getResolution(), ogreImage.getResolution(), 1, Ogre::PF_A8);
std::stringstream splatTextureNameSS;
splatTextureNameSS << "terrain_" << mPage.getWFPosition().x() << "_" << mPage.getWFPosition().y() << "_" << technique->getNumPasses();
const Ogre::String splatTextureName(splatTextureNameSS.str());
Ogre::TexturePtr blendMapTexture;
if (Ogre::Root::getSingletonPtr()->getTextureManager()->resourceExists(splatTextureName)) {
blendMapTexture = static_cast<Ogre::TexturePtr>(Ogre::Root::getSingletonPtr()->getTextureManager()->getByName(splatTextureName));
blendMapTexture->loadImage(image);
Ogre::HardwarePixelBufferSharedPtr hardwareBuffer(blendMapTexture->getBuffer());
//blit the whole image to the hardware buffer
Ogre::PixelBox sourceBox(image.getPixelBox());
hardwareBuffer->blitFromMemory(sourceBox);
} else {
blendMapTexture = Ogre::Root::getSingletonPtr()->getTextureManager()->loadImage(splatTextureName, "General", image, Ogre::TEX_TYPE_2D, 0);
managedTextures.insert(blendMapTexture->getName());
}
//we need to create the image, update it and then destroy it again (to keep the memory usage down)
// if (layer->getBlendMapTextureName() == "") {
// //no texture yet; let's create one
// layer->createBlendMapImage();
// layer->updateBlendMapImage(geometry);
// layer->createTexture();
// } else {
// //a texture exists, so we just need to update the image
// layer->updateBlendMapImage(geometry); //calling this will also update the texture since the method will blit the image onto it
// }
Ogre::Pass* pass = technique->createPass();
pass->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
pass->setAmbient(1, 1, 1);
pass->setDiffuse(1, 1, 1, 1);
pass->setLightingEnabled(false);
Ogre::TextureUnitState * textureUnitState = pass->createTextureUnitState();
textureUnitState->setTextureName(layer.surfaceLayer.getDiffuseTextureName());
textureUnitState->setTextureAddressingMode(Ogre::TextureUnitState::TAM_WRAP);
textureUnitState->setTextureCoordSet(0);
textureUnitState->setTextureScale(1.0f / layer.surfaceLayer.getScale(), 1.0f / layer.surfaceLayer.getScale());
Ogre::TextureUnitState * textureUnitStateSplat = pass->createTextureUnitState();
textureUnitStateSplat->setTextureName(blendMapTexture->getName());
textureUnitStateSplat->setTextureCoordSet(0);
textureUnitStateSplat->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP);
textureUnitStateSplat->setTextureFiltering(Ogre::TFO_ANISOTROPIC);
// textureUnitStateSplat->setAlphaOperation(Ogre::LBX_SOURCE1, Ogre::LBS_TEXTURE, Ogre::LBS_TEXTURE);
textureUnitStateSplat->setAlphaOperation(Ogre::LBX_BLEND_DIFFUSE_COLOUR, Ogre::LBS_TEXTURE, Ogre::LBS_CURRENT);
textureUnitStateSplat->setColourOperationEx(Ogre::LBX_SOURCE1, Ogre::LBS_CURRENT, Ogre::LBS_CURRENT);
return pass;
}
void
MaterialPreviewDialog::buildPreviewBitmap( const Ogre::String &texName )
{
const Ogre::uchar BytePerPixel = 8;
// 读取原始image
Ogre::Image *oriImage = getPreviewImage(texName);
// 源大纹理的大小
size_t oriImageHeight = oriImage->getHeight();
size_t oriImageWidth = oriImage->getWidth();
Ogre::uchar *oriImageData = oriImage->getData();
// 分配一个足够大的空间来保存新建的image的数据
size_t newImagegetRowSpan = oriImageWidth*oriImage->getBPP()/BytePerPixel; // 新建的image的行宽（单位为字节）
Ogre::uchar *newImageData = OGRE_ALLOC_T(Ogre::uchar, oriImageHeight*newImagegetRowSpan, Ogre::MEMCATEGORY_GENERAL);//new Ogre::uchar[oriImageHeight*newImagegetRowSpan];
Ogre::uchar *newImageDataPointer = newImageData;
Ogre::uchar *oriImagedataPointer = oriImageData;
// 把所选的纹理的数据提取出来，并创建一个新的image
for ( Ogre::uint i=0; i<oriImageHeight; ++i )
{
memcpy(newImageDataPointer, oriImagedataPointer, newImagegetRowSpan);
newImageDataPointer += newImagegetRowSpan;
oriImagedataPointer += oriImage->getRowSpan();
}
Ogre::Image newImage;
newImage.loadDynamicImage(newImageData,oriImageWidth,oriImageHeight,1,oriImage->getFormat(),true);
// 如果所选纹理大于64*64，就先resize
if ( oriImageWidth > mPreviewImageWidth || oriImageHeight > mPreviewImageHeight )
newImage.resize(mPreviewImageWidth, mPreviewImageHeight);
// 如果有alpha，要与黑白图进行混合
if ( newImage.getHasAlpha() )
{
Ogre::ColourValue col;
for ( int i=0; i<mPreviewImageWidth; ++i )
{
for ( int j=0; j<mPreviewImageWidth; ++j )
{
col = newImage.getColourAt(j,i,0);
float alphaValue = col.a;
unsigned char r = col.r*255 * alphaValue;
unsigned char g = col.g*255 * alphaValue;
unsigned char b = col.b*255 * alphaValue;
// 设置到image中
mCurrentPreviewImage.SetRGB(j,i,r,g,b);
}
}
}
// 没有alpha，就直接拷贝数据
else
{
Ogre::ColourValue col;
for ( int i=0; i<mPreviewImageWidth; ++i )
{
for ( int j=0; j<mPreviewImageWidth; ++j )
{
col = newImage.getColourAt(j,i,0);
unsigned char r = col.r*255;
unsigned char g = col.g*255;
unsigned char b = col.b*255;
// 设置到image中
mCurrentPreviewImage.SetRGB(j,i,r,g,b);
}
}
}
}
Surface*
FontFile::GetSurface(void)
{
int width = 512;
int height = 4096;
int chars = 0;
int char_num = 6165;
Surface* ret = CreateSurface(width, height);
int x_16 = 0;
int y_16 = 0;
struct ClutColor
{
u8 r; /**< @brief red color in CLUT */
u8 g; /**< @brief green color in CLUT */
u8 b; /**< @brief blue color in CLUT */
u8 a; /**< @brief alpha in CLUT */
};
ClutColor color;
color.r = 0;
color.g = 0;
color.b = 0;
color.a = 255;
u8 data = 0;
for (int chars = 0; chars < char_num; ++chars)
{
Surface* glyth = CreateSurface(16, 16);
for (int y = 0; y < 16; ++y)
{
data = (y < 11) ? GetU8(0xE + chars * 22 + y * 2 + 0) : 0;
//LOGGER->Log(LOGGER_INFO, "%x, %02x", y, data);
int j = 0;
for (int i = 7; i >= 0; --i)
{
color.r = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.g = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.b = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.a = ((data >> i) & 0x01 == 1) ? 255 : 255;
memcpy(glyth->pixels + 64 * y + j, &color, sizeof(ClutColor));
j += 4;
}
data = (y < 11) ? GetU8(0xE + chars * 22 + y * 2 + 1) : 0;
//LOGGER->Log(LOGGER_INFO, "%02x", data);
for (int i = 7; i >= 0; --i)
{
color.r = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.g = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.b = ((data >> i) & 0x01 == 1) ? 0 : 255;
color.a = ((data >> i) & 0x01 == 1) ? 255 : 255;
memcpy(glyth->pixels + 64 * y + j, &color, sizeof(ClutColor));
j += 4;
}
}
CopyToSurface(ret, x_16, y_16, glyth);
delete glyth;
x_16 += 16;
if (x_16 == ret->width)
{
y_16 += 16;
x_16 = 0;
}
}
Ogre::TexturePtr ptex;
Ogre::HardwarePixelBufferSharedPtr buffer;
ptex = Ogre::TextureManager::getSingleton().createManual("DynaTex", "General", Ogre::TEX_TYPE_2D, ret->width, ret->height, 0, Ogre::PF_R8G8B8A8, Ogre::TU_STATIC);
buffer = ptex->getBuffer(0, 0);
buffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
const Ogre::PixelBox& pb = buffer->getCurrentLock();
for (Uint32 y = 0; y < ret->height; ++y)
{
Uint32* data = static_cast<Uint32*>(pb.data) + y * pb.rowPitch;
for (Uint32 x = 0; x < ret->width; ++x)
{
Uint32 clut = ret->pixels[y * ret->width * 4 + x * 4 + 3] | (ret->pixels[y * ret->width * 4 + x * 4 + 2] << 8) | (ret->pixels[y * ret->width * 4 + x * 4 + 1] << 16) | (ret->pixels[y * ret->width * 4 + x * 4 + 0] << 24);
data[x] = clut;
}
}
Ogre::Image image;
image.loadDynamicImage((Ogre::uchar*)pb.data, ret->width, ret->height, Ogre::PF_R8G8B8A8);
image.save("font.png");
buffer->unlock();
Ogre::TextureManager::getSingleton().remove("DynaTex");
return ret;
}
void OgreCPP::createNewCrowdMember( float animationTime )
{
char buffer[ 512 ];
uint32_t numCrowdMembers = mCrowdMembers.size();
// Create a new crowd member
Ogre::TextureManager* pTextureMgr = Ogre::TextureManager::getSingletonPtr();
Ogre::String frameTexNames[ 2*NUM_FRAMES_TO_RECORD ];
Ogre::String lowResFrameTexNames[ 2*NUM_FRAMES_TO_RECORD ];
for ( uint32_t frameIdx = 0; frameIdx < NUM_FRAMES_TO_RECORD; frameIdx++ )
{
Ogre::Image image;
image.loadDynamicImage( mpImageData + frameIdx*SMALL_FRAME_WIDTH*SMALL_FRAME_HEIGHT,
SMALL_FRAME_WIDTH, SMALL_FRAME_HEIGHT, 1, Ogre::PF_A4L4 );
sprintf( buffer, "RecordedSequenceTex_%i_%i", numCrowdMembers, frameIdx );
frameTexNames[ frameIdx ] = buffer;
Ogre::TexturePtr pTexture = pTextureMgr->loadImage( frameTexNames[ frameIdx ],
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, image );
sprintf( buffer, "LowResRecordedSequenceTex_%i_%i", numCrowdMembers, frameIdx );
lowResFrameTexNames[ frameIdx ] = buffer;
Ogre::Image lowResImage;
lowResImage.loadDynamicImage( mpLowResImageData + frameIdx*LOW_RES_SMALL_FRAME_WIDTH*LOW_RES_SMALL_FRAME_HEIGHT,
LOW_RES_SMALL_FRAME_WIDTH, LOW_RES_SMALL_FRAME_HEIGHT, 1, Ogre::PF_A4L4 );
pTextureMgr->loadImage( lowResFrameTexNames[ frameIdx ],
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, lowResImage );
}
for ( uint32_t frameIdx = 0; frameIdx < NUM_FRAMES_TO_RECORD; frameIdx++ )
{
frameTexNames[ (2*NUM_FRAMES_TO_RECORD - 1) - frameIdx ] = frameTexNames[ frameIdx ];
lowResFrameTexNames[ (2*NUM_FRAMES_TO_RECORD - 1) - frameIdx ] = lowResFrameTexNames[ frameIdx ];
}
// Create materials for the crowd member
sprintf( buffer, "RecordedSequenceMat_%i", numCrowdMembers );
Ogre::String matName = buffer;
Ogre::MaterialManager* pMatMgr = Ogre::MaterialManager::getSingletonPtr();
Ogre::MaterialPtr pSrcMat = (Ogre::MaterialPtr)pMatMgr->getByName( "Template/CutOut",
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME );
Ogre::MaterialPtr pMat = pSrcMat->clone( matName );
pMat->getTechnique( 0 )->getPass( 0 )->removeAllTextureUnitStates();
Ogre::TextureUnitState* pTex = pMat->getTechnique( 0 )->getPass( 0 )->createTextureUnitState();
pMat->getTechnique( 0 )->getPass( 0 )->addTextureUnitState( pTex );
pTex->setAnimatedTextureName( frameTexNames, 2*NUM_FRAMES_TO_RECORD, 2.0*animationTime );
pMat->setCullingMode( Ogre::CULL_NONE );
pMat->compile();
sprintf( buffer, "LowResRecordedSequenceMat_%i", numCrowdMembers );
Ogre::String lowResMatName = buffer;
pMat = pSrcMat->clone( lowResMatName );
pMat->getTechnique( 0 )->getPass( 0 )->removeAllTextureUnitStates();
pTex = pMat->getTechnique( 0 )->getPass( 0 )->createTextureUnitState();
pMat->getTechnique( 0 )->getPass( 0 )->addTextureUnitState( pTex );
pTex->setAnimatedTextureName( lowResFrameTexNames, 2*NUM_FRAMES_TO_RECORD, 2.0*animationTime );
pMat->setCullingMode( Ogre::CULL_NONE );
pMat->compile();
CrowdMember newCrowdMember;
newCrowdMember.mMaterialName = matName;
newCrowdMember.mLowResMaterialName = lowResMatName;
newCrowdMember.mFrameIdx = 0;
newCrowdMember.mColourIdx = rand()%NUM_COLOURS;
newCrowdMember.mbReversing = false;
num = mCrowdMembers.size()%11;
/** POSITION CROWD MEMBER HERE **/
float x = (num*(5.0/11.0))-2.25;
float y = 1.5;
/* centre is 0,0, extremes are -3,+3 */
newCrowdMember.mPos = Ogre::Vector3( x, y, 5.0 );
newCrowdMember.mRow = 0;
newCrowdMember.mpBillboard = OGRE_NEW PersonBillboard();
newCrowdMember.mpBillboard->setMaterial( newCrowdMember.mMaterialName );
newCrowdMember.mpBillboard->setCorners(
Ogre::Vector3( -0.5f, -0.375f, 0.0f ),
Ogre::Vector3( 0.5f, -0.375f, 0.0f ),
Ogre::Vector3( -0.5f, 0.375f, 0.0f ),
Ogre::Vector3( 0.5f, 0.375f, 0.0f )
);
// Make sure that the front row is drawn in front of everything else
newCrowdMember.mpBillboard->setRenderQueueGroup( CROWD_FRONT_RENDER_QUEUE );
newCrowdMember.mpSceneNode = mpDiscoNode->createChildSceneNode(
newCrowdMember.mPos, Ogre::Quaternion::IDENTITY );
newCrowdMember.mpSceneNode->attachObject( newCrowdMember.mpBillboard );
mCrowdMembers.push_back( newCrowdMember );
/* PLACING RT USER IN CROWD HERE */
if(USER_IN_CROWD){
float userX = (((num+1)%CROWD_WIDTH)*(12.0/(float)CROWD_WIDTH))-5.5;
mUserNode->setPosition(userX,3.45,9.5);
}
/** PUSH ROW UP **/
if (num >= CROWD_WIDTH-1) {
// push last row up
for(int j = 0; j < mCrowdMembers.size(); j++)
{
mCrowdMembers[j].mPos.z += CROWD_PUSH_BACK;
mCrowdMembers[j].mPos.y += CROWD_PUSH_UP;
mCrowdMembers[j].mpSceneNode->setPosition( mCrowdMembers[j].mPos );
mCrowdMembers[j].mRow++;
if ( FIRST_LOW_RES_ROW_IDX == mCrowdMembers[j].mRow )
{
mCrowdMembers[j].mpBillboard->setMaterial( mCrowdMembers[j].mLowResMaterialName );
}
if ( mCrowdMembers[j].mRow > MAX_VISIBLE_ROW_IDX )
{
mCrowdMembers[j].mpBillboard->setVisible( false );
mCrowdMembers[j].mpBillboard->setMaterial( "BaseWhiteNoLighting" );
}
else
{
mCrowdMembers[j].mpBillboard->setRenderQueueGroup( CROWD_FRONT_RENDER_QUEUE - mCrowdMembers[j].mRow );
}
}
}
}
//-----------------------------------------------------------------------
void AtlasImageTool::process (void)
{
Ogre::Root root("", "", "atlas.log");
Ogre::ResourceGroupManager::getSingleton().addResourceLocation(mImagePath, "FileSystem");
Ogre::StringVector::iterator itInputFileName;
Ogre::StringVector::iterator itFrame;
Ogre::StringVector::iterator itAlpha;
itAlpha = mAlpha.begin();
if (mInputFrames.empty() || mInputFrames[0] == Ogre::StringUtil::BLANK)
{
// No Frames are assigned so just add them
for (itInputFileName = mInputFileNames.begin(); itInputFileName != mInputFileNames.end(); ++itInputFileName)
{
Ogre::String imageFileName = *itInputFileName;
Ogre::Image image;
image.load(imageFileName, "General");
if (itAlpha != mAlpha.end() && *itAlpha != Ogre::StringUtil::BLANK)
{
Ogre::Real alpha = Ogre::StringConverter::parseReal(*itAlpha);
correctAlpha(image, alpha);
itAlpha++;
}
mAtlasImage.addImage(&image);
}
}
else
{
// Frames are assigned, so generate intermediate images
itInputFileName = mInputFileNames.begin();
Ogre::Real alpha = 1.0f;
Ogre::String nextImageFileName = *itInputFileName;
Ogre::Image nextImage;
itFrame = mInputFrames.begin();
size_t nextFrame = Ogre::StringConverter::parseUnsignedInt(*itFrame);
nextImage.load(nextImageFileName, "General");
size_t frameCounter = 0;
if (!mAlpha.empty() && mAlpha[0] != Ogre::StringUtil::BLANK)
{
itAlpha = mAlpha.begin();
Ogre::Real alpha = Ogre::StringConverter::parseReal(*itAlpha);
correctAlpha(nextImage, alpha);
itAlpha++;
}
mAtlasImage.addImage(&nextImage);
frameCounter++;
itInputFileName++;
itFrame++;
while (itInputFileName != mInputFileNames.end())
{
// Get the next filename
Ogre::Image firstImage(nextImage);
nextImageFileName = *itInputFileName;
nextImage.load(nextImageFileName, "General");
if (itAlpha != mAlpha.end() && *itAlpha != Ogre::StringUtil::BLANK)
{
Ogre::Real alpha = Ogre::StringConverter::parseReal(*itAlpha);
correctAlpha(nextImage, alpha);
itAlpha++;
}
if (itFrame != mInputFrames.end())
{
size_t firstFrame = nextFrame;
nextFrame = Ogre::StringConverter::parseUnsignedInt(*itFrame);
itFrame++;
frameCounter++;
// Generate and add interpolated images to the atlas image
size_t numberOfFrames = nextFrame - firstFrame;
for (size_t i = 1; i < numberOfFrames; ++i)
{
Ogre::Real fraction = (Ogre::Real)i / (Ogre::Real)numberOfFrames;
Ogre::Image interpolatedImage;
size_t pixelSize = Ogre::PixelUtil::getNumElemBytes(firstImage.getFormat());
size_t bufferSize = firstImage.getWidth() * firstImage.getHeight() * pixelSize;
Ogre::uchar* data = OGRE_ALLOC_T(Ogre::uchar, bufferSize, Ogre::MEMCATEGORY_GENERAL);
interpolatedImage.loadDynamicImage(data, firstImage.getWidth(), firstImage.getHeight(), 1, firstImage.getFormat(), true);
interpolate (interpolatedImage, firstImage, nextImage, fraction);
mAtlasImage.addImage(&interpolatedImage);
frameCounter++;
}
}
mAtlasImage.addImage(&nextImage);
frameCounter++;
itInputFileName++;
}
}
mAtlasImage._compile();
mAtlasImage.save(mImagePath + "//" + mOutputImage);
}
void
BrushSelector::buildPreviewBitmap( const Fairy::TextureInfo texInfo )
{
const Ogre::uchar BytePerPixel = 8;
// 读取原始image
Ogre::Image *oriImage = GetSceneManipulator()->getPreviewImage(texInfo.ownerTextureName);
// 源大纹理的大小
size_t oriImageHeight = oriImage->getHeight();
size_t oriImageWidth = oriImage->getWidth();
Ogre::uchar *oriImageData = oriImage->getData();
// 所选纹理的大小
size_t newImageWidth = texInfo.width*TexTileSize;
size_t newImageHeight = texInfo.height*TexTileSize;
// 分配一个足够大的空间来保存新建的image的数据
size_t newImagegetRowSpan = newImageWidth*oriImage->getBPP()/BytePerPixel; // 新建的image的行宽（单位为字节）
Ogre::uchar *newImageData = OGRE_ALLOC_T(Ogre::uchar, oriImageHeight*newImagegetRowSpan, Ogre::MEMCATEGORY_GENERAL);//new Ogre::uchar[newImageHeight*newImagegetRowSpan];
Ogre::uchar *newImageDataPointer = newImageData;
// 得知起始像素点
size_t startPoint = ( oriImageWidth * texInfo.topCorner + texInfo.leftCorner )
* TexTileSize * oriImage->getBPP()/BytePerPixel;
Ogre::uchar *oriImagedataPointer = oriImageData + startPoint;
// 把所选的纹理的数据提取出来，并创建一个新的image
for ( Ogre::uint i=0; i<newImageHeight; ++i )
{
memcpy(newImageDataPointer, oriImagedataPointer, newImagegetRowSpan);
newImageDataPointer += newImagegetRowSpan;
oriImagedataPointer += oriImage->getRowSpan();
}
Ogre::Image newImage;
newImage.loadDynamicImage(newImageData,newImageWidth,newImageHeight,1,oriImage->getFormat(),true);
// 如果所选纹理大于64*64，就先resize
if ( texInfo.width > 1 || texInfo.height > 1 )
newImage.resize(mPreviewImageWidth, mPreviewImageHeight);
// 如果有alpha，要与黑白图进行混合
if ( newImage.getHasAlpha() )
{
Ogre::ColourValue col;
for ( int i=0; i<mPreviewImageWidth; ++i )
{
for ( int j=0; j<mPreviewImageWidth; ++j )
{
col = newImage.getColourAt(j,i,0);
float alphaValue = col.a;
unsigned char r = col.r*255 * alphaValue + mBlackWhitePreviewImage.GetRed(i,j) * ( 1.0f - alphaValue);
unsigned char g = col.g*255 * alphaValue + mBlackWhitePreviewImage.GetGreen(i,j) * ( 1.0f - alphaValue);
unsigned char b = col.b*255 * alphaValue + mBlackWhitePreviewImage.GetBlue(i,j) * ( 1.0f - alphaValue);
// 设置到image中
mCurrentPreviewImage.SetRGB(j,i,r,g,b);
}
}
// 设置到缩略图控件中
mBrushesPreview->SetBitmap(mCurrentPreviewImage);
}
// 没有alpha，就直接拷贝数据
else
{
Ogre::ColourValue col;
for ( int i=0; i<mPreviewImageWidth; ++i )
{
for ( int j=0; j<mPreviewImageWidth; ++j )
{
col = newImage.getColourAt(j,i,0);
unsigned char r = col.r*255;
unsigned char g = col.g*255;
unsigned char b = col.b*255;
// 设置到image中
mCurrentPreviewImage.SetRGB(j,i,r,g,b);
}
}
mBrushesPreview->SetBitmap(mCurrentPreviewImage);
}
}
void FontLoader::loadFont(const std::string &fileName, bool exportToFile)
{
Ogre::DataStreamPtr file = Ogre::ResourceGroupManager::getSingleton().openResource(fileName);
float fontSize;
int one;
file->read(&fontSize, sizeof(fontSize));
file->read(&one, sizeof(int));
assert(one == 1);
file->read(&one, sizeof(int));
assert(one == 1);
char name_[284];
file->read(name_, sizeof(name_));
std::string name(name_);
GlyphInfo data[256];
file->read(data, sizeof(data));
file->close();
// Create the font texture
std::string bitmapFilename = "Fonts/" + std::string(name) + ".tex";
Ogre::DataStreamPtr bitmapFile = Ogre::ResourceGroupManager::getSingleton().openResource(bitmapFilename);
int width, height;
bitmapFile->read(&width, sizeof(int));
bitmapFile->read(&height, sizeof(int));
std::vector<Ogre::uchar> textureData;
textureData.resize(width*height*4);
bitmapFile->read(&textureData[0], width*height*4);
bitmapFile->close();
std::string resourceName;
if (name.size() >= 5 && Misc::StringUtils::ciEqual(name.substr(0, 5), "magic"))
resourceName = "Magic Cards";
else if (name.size() >= 7 && Misc::StringUtils::ciEqual(name.substr(0, 7), "century"))
resourceName = "Century Gothic";
else if (name.size() >= 7 && Misc::StringUtils::ciEqual(name.substr(0, 7), "daedric"))
resourceName = "Daedric";
else
return; // no point in loading it, since there is no way of using additional fonts
std::string textureName = name;
Ogre::Image image;
image.loadDynamicImage(&textureData[0], width, height, Ogre::PF_BYTE_RGBA);
Ogre::TexturePtr texture = Ogre::TextureManager::getSingleton().createManual(textureName,
Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
Ogre::TEX_TYPE_2D,
width, height, 0, Ogre::PF_BYTE_RGBA);
texture->loadImage(image);
if (exportToFile)
image.save(resourceName + ".png");
// Register the font with MyGUI
MyGUI::ResourceManualFont* font = static_cast<MyGUI::ResourceManualFont*>(
MyGUI::FactoryManager::getInstance().createObject("Resource", "ResourceManualFont"));
// We need to emulate loading from XML because the data members are private as of mygui 3.2.0
MyGUI::xml::Document xmlDocument;
MyGUI::xml::ElementPtr root = xmlDocument.createRoot("ResourceManualFont");
root->addAttribute("name", resourceName);
MyGUI::xml::ElementPtr defaultHeight = root->createChild("Property");
defaultHeight->addAttribute("key", "DefaultHeight");
defaultHeight->addAttribute("value", fontSize);
MyGUI::xml::ElementPtr source = root->createChild("Property");
source->addAttribute("key", "Source");
source->addAttribute("value", std::string(textureName));
MyGUI::xml::ElementPtr codes = root->createChild("Codes");
for(int i = 0; i < 256; i++)
{
float x1 = data[i].top_left.x*width;
float y1 = data[i].top_left.y*height;
float w = data[i].top_right.x*width - x1;
float h = data[i].bottom_left.y*height - y1;
ToUTF8::Utf8Encoder encoder(mEncoding);
unsigned long unicodeVal = utf8ToUnicode(getUtf8(i, encoder, mEncoding));
MyGUI::xml::ElementPtr code = codes->createChild("Code");
code->addAttribute("index", unicodeVal);
code->addAttribute("coord", MyGUI::utility::toString(x1) + " "
+ MyGUI::utility::toString(y1) + " "
+ MyGUI::utility::toString(w) + " "
+ MyGUI::utility::toString(h));
code->addAttribute("advance", data[i].width);
code->addAttribute("bearing", MyGUI::utility::toString(data[i].kerning) + " "
+ MyGUI::utility::toString((fontSize-data[i].ascent)));
code->addAttribute("size", MyGUI::IntSize(data[i].width, data[i].height));
// More hacks! The french game uses several win1252 characters that are not included
// in the cp437 encoding of the font. Fall back to similar available characters.
if (mEncoding == ToUTF8::CP437)
{
std::multimap<int, int> additional; // <cp437, unicode>
additional.insert(std::make_pair(39, 0x2019)); // apostrophe
additional.insert(std::make_pair(45, 0x2013)); // dash
additional.insert(std::make_pair(45, 0x2014)); // dash
additional.insert(std::make_pair(34, 0x201D)); // right double quotation mark
additional.insert(std::make_pair(34, 0x201C)); // left double quotation mark
additional.insert(std::make_pair(44, 0x201A));
additional.insert(std::make_pair(44, 0x201E));
additional.insert(std::make_pair(43, 0x2020));
additional.insert(std::make_pair(94, 0x02C6));
additional.insert(std::make_pair(37, 0x2030));
additional.insert(std::make_pair(83, 0x0160));
additional.insert(std::make_pair(60, 0x2039));
additional.insert(std::make_pair(79, 0x0152));
additional.insert(std::make_pair(90, 0x017D));
additional.insert(std::make_pair(39, 0x2019));
additional.insert(std::make_pair(126, 0x02DC));
additional.insert(std::make_pair(84, 0x2122));
additional.insert(std::make_pair(83, 0x0161));
additional.insert(std::make_pair(62, 0x203A));
additional.insert(std::make_pair(111, 0x0153));
additional.insert(std::make_pair(122, 0x017E));
additional.insert(std::make_pair(89, 0x0178));
additional.insert(std::make_pair(156, 0x00A2));
additional.insert(std::make_pair(46, 0x2026));
for (std::multimap<int, int>::iterator it = additional.begin(); it != additional.end(); ++it)
{
if (it->first != i)
continue;
MyGUI::xml::ElementPtr code = codes->createChild("Code");
code->addAttribute("index", it->second);
code->addAttribute("coord", MyGUI::utility::toString(x1) + " "
+ MyGUI::utility::toString(y1) + " "
+ MyGUI::utility::toString(w) + " "
+ MyGUI::utility::toString(h));
code->addAttribute("advance", data[i].width);
code->addAttribute("bearing", MyGUI::utility::toString(data[i].kerning) + " "
+ MyGUI::utility::toString((fontSize-data[i].ascent)));
code->addAttribute("size", MyGUI::IntSize(data[i].width, data[i].height));
}
}
// ASCII vertical bar, use this as text input cursor
if (i == 124)
{
MyGUI::xml::ElementPtr cursorCode = codes->createChild("Code");
cursorCode->addAttribute("index", MyGUI::FontCodeType::Cursor);
cursorCode->addAttribute("coord", MyGUI::utility::toString(x1) + " "
+ MyGUI::utility::toString(y1) + " "
+ MyGUI::utility::toString(w) + " "
+ MyGUI::utility::toString(h));
cursorCode->addAttribute("advance", data[i].width);
cursorCode->addAttribute("bearing", MyGUI::utility::toString(data[i].kerning) + " "
+ MyGUI::utility::toString((fontSize-data[i].ascent)));
cursorCode->addAttribute("size", MyGUI::IntSize(data[i].width, data[i].height));
}
// Question mark, use for NotDefined marker (used for glyphs not existing in the font)
if (i == 63)
{
MyGUI::xml::ElementPtr cursorCode = codes->createChild("Code");
cursorCode->addAttribute("index", MyGUI::FontCodeType::NotDefined);
cursorCode->addAttribute("coord", MyGUI::utility::toString(x1) + " "
+ MyGUI::utility::toString(y1) + " "
+ MyGUI::utility::toString(w) + " "
+ MyGUI::utility::toString(h));
cursorCode->addAttribute("advance", data[i].width);
cursorCode->addAttribute("bearing", MyGUI::utility::toString(data[i].kerning) + " "
+ MyGUI::utility::toString((fontSize-data[i].ascent)));
cursorCode->addAttribute("size", MyGUI::IntSize(data[i].width, data[i].height));
}
}
// These are required as well, but the fonts don't provide them
for (int i=0; i<2; ++i)
{
MyGUI::FontCodeType::Enum type;
if(i == 0)
type = MyGUI::FontCodeType::Selected;
else if (i == 1)
type = MyGUI::FontCodeType::SelectedBack;
MyGUI::xml::ElementPtr cursorCode = codes->createChild("Code");
cursorCode->addAttribute("index", type);
cursorCode->addAttribute("coord", "0 0 0 0");
cursorCode->addAttribute("advance", "0");
cursorCode->addAttribute("bearing", "0 0");
cursorCode->addAttribute("size", "0 0");
}
if (exportToFile)
{
xmlDocument.createDeclaration();
xmlDocument.save(resourceName + ".xml");
}
font->deserialization(root, MyGUI::Version(3,2,0));
MyGUI::ResourceManager::getInstance().removeByName(font->getResourceName());
MyGUI::ResourceManager::getInstance().addResource(font);
}
void
MaterialPreviewDialog::buildPreviewBitmap( const Ogre::String &texName )
{
const Ogre::uchar BytePerPixel = 8;
// 读取原始image
Ogre::Image *oriImage = getPreviewImage(texName);
// 源大纹理的大小
size_t oriImageHeight = oriImage->getHeight();
size_t oriImageWidth = oriImage->getWidth();
Ogre::uchar *oriImageData = oriImage->getData();
// 分配一个足够大的空间来保存新建的image的数据
size_t newImagegetRowSpan = oriImageWidth*oriImage->getBPP()/BytePerPixel; // 新建的image的行宽（单位为字节）
Ogre::uchar *newImageData = new Ogre::uchar[oriImageHeight*newImagegetRowSpan];
Ogre::uchar *newImageDataPointer = newImageData;
Ogre::uchar *oriImagedataPointer = oriImageData;
// 把所选的纹理的数据提取出来，并创建一个新的image
for ( Ogre::uint i=0; i<oriImageHeight; ++i )
{
memcpy(newImageDataPointer, oriImagedataPointer, newImagegetRowSpan);
newImageDataPointer += newImagegetRowSpan;
oriImagedataPointer += oriImage->getRowSpan();
}
Ogre::Image newImage;
newImage.loadDynamicImage(newImageData,oriImageWidth,oriImageHeight,1,oriImage->getFormat(),true);
// 如果所选纹理大于64*64，就先resize
if ( oriImageWidth > mPreviewImageWidth || oriImageHeight > mPreviewImageHeight )
newImage.resize(mPreviewImageWidth, mPreviewImageHeight);
// 如果有alpha，要与黑白图进行混合
if ( newImage.getHasAlpha() )
{
Ogre::uchar *tempPtr = newImage.getData();
assert (tempPtr);
for ( size_t i=0; i<mPreviewImageHeight; ++i )
for ( size_t j=0; j<mPreviewImageWidth; ++j )
{
// 取出alpha值
float alphaValue = (float)tempPtr[3] / 255.0f;
// 计算出经过alpha混合后的颜色值
unsigned char r = tempPtr[2] * alphaValue;
unsigned char g = tempPtr[1] * alphaValue;
unsigned char b = tempPtr[0] * alphaValue;
// 设置到image中
mCurrentPreviewImage.SetRGB(j,i,r,g,b);
tempPtr += 4;
}
// 要把指针移回到图片数据的
tempPtr -= mPreviewImageHeight * mPreviewImageWidth * 4;
// 设置到缩略图控件中
}
// 没有alpha，就直接拷贝数据
else
{
memcpy ( mCurrentPreviewImage.GetData(), newImage.getData(), newImage.getSize() );
}
}
void TerrainPageShadow::loadIntoImage(Ogre::Image& ogreImage) const
{
ogreImage.loadDynamicImage(mImage->getData(), mImage->getResolution(), mImage->getResolution(), 1, Ogre::PF_L8);
}
int
main( int argc, char *argv[] )
{
Ogre::Root* root;
Ogre::RenderWindow* window;
root = new Ogre::Root( "", "" );
#ifndef _DEBUG
root->loadPlugin( "RenderSystem_GL.dll" );
#else
root->loadPlugin( "RenderSystem_GL_d.dll" );
#endif
root->setRenderSystem( root->getAvailableRenderers()[ 0 ] );
root->initialise( false );
Ogre::NameValuePairList misc;
misc[ "title" ] = "FFVII Exporter";
window = root->createRenderWindow( "QGearsWindow", 800, 600, false, &misc );
FILESYSTEM = new FileSystem();
LOGGER = new Logger( "game.log" );
state = GAME;
{
BinGZipFile* file = new BinGZipFile( "data/en/WINDOW.BIN" );
File* font_graf = file->ExtractGZip( 1 );
File* font_padding = file->ExtractGZip( 2 );
FontFile font( font_padding );
font.Export( "export_en/ui/fonts/ffvii_en.xml", true );
//font_graf->WriteFile( "font.tim" );
Vram* vram = new Vram();
LoadTimFileToVram( font_graf, 0, vram );
//vram->Save( "text" );
Ogre::TexturePtr ptex;
Ogre::HardwarePixelBufferSharedPtr buffer;
ptex = Ogre::TextureManager::getSingleton().createManual( "DynaTex", "General", Ogre::TEX_TYPE_2D, 256, 256, 0, Ogre::PF_R8G8B8A8, Ogre::TU_STATIC );
buffer = ptex->getBuffer( 0, 0 );
buffer->lock( Ogre::HardwareBuffer::HBL_DISCARD );
const Ogre::PixelBox& pb = buffer->getCurrentLock();
CreateTextureFromVram( pb, vram, 0, 0, 0x80, 0x1f7, 0x380, 0x100, BPP_4 , false );
Ogre::Image image;
image.loadDynamicImage( ( Ogre::uchar* )pb.data, 256, 256, Ogre::PF_R8G8B8A8 );
image.save( "export_en/ui/fonts/ffvii_en.png" );
buffer->unlock();
delete vram;
delete file;
}
{
BinGZipFile* file = new BinGZipFile( "data/jp/WINDOW.BIN" );
File* font_graf = file->ExtractGZip( 1 );
File* font_graf2 = file->ExtractGZip( 2 );
File* font_padding = file->ExtractGZip( 3 );
font_padding->WriteFile( "font_padding.dat" );
FontFile font( font_padding );
font.Export( "export_jp/ui/fonts/ffvii_jp.xml", false );
font_graf->WriteFile( "font.tim" );
font_graf2->WriteFile( "font2.tim" );
Vram* vram = new Vram();
LoadTimFileToVram( font_graf, 0, vram );
LoadTimFileToVram( font_graf2, 0, vram );
//vram->Save( "text" );
Ogre::TexturePtr ptex;
Ogre::HardwarePixelBufferSharedPtr buffer;
ptex = Ogre::TextureManager::getSingleton().createManual( "DynaTex", "General", Ogre::TEX_TYPE_2D, 512, 256, 0, Ogre::PF_R8G8B8A8, Ogre::TU_STATIC );
buffer = ptex->getBuffer( 0, 0 );
buffer->lock( Ogre::HardwareBuffer::HBL_DISCARD );
const Ogre::PixelBox& pb = buffer->getCurrentLock();
CreateTextureFromVram( pb, vram, 0, 0, 0x80, 0x1f7, 0x380, 0x100, BPP_4 , false );
CreateTextureFromVram( pb, vram, 256, 0, 0x90, 0x1f7, 0x380, 0x100, BPP_4 , false );
Ogre::Image image;
image.loadDynamicImage( ( Ogre::uchar* )pb.data, 512, 256, Ogre::PF_R8G8B8A8 );
image.save( "export_jp/ui/fonts/ffvii_jp.png" );
buffer->unlock();
delete vram;
delete file;
}
{
File sword( "sword.tim" );
Vram* vram = new Vram();
LoadTimFileToVram( &sword, 0, vram );
//vram->Save( "sword" );
Ogre::TexturePtr ptex;
Ogre::HardwarePixelBufferSharedPtr buffer;
ptex = Ogre::TextureManager::getSingleton().createManual( "DynaTex", "General", Ogre::TEX_TYPE_2D, 256, 256, 0, Ogre::PF_R8G8B8A8, Ogre::TU_STATIC );
buffer = ptex->getBuffer( 0, 0 );
buffer->lock( Ogre::HardwareBuffer::HBL_DISCARD );
const Ogre::PixelBox& pb = buffer->getCurrentLock();
CreateTextureFromVram( pb, vram, 0, 0, 0x0, 0x1e0, 0x0, 0x0, BPP_8 , false );
Ogre::Image image;
image.loadDynamicImage( ( Ogre::uchar* )pb.data, 256, 256, Ogre::PF_R8G8B8A8 );
image.save( "sword.png" );
buffer->unlock();
delete vram;
}
LOGGER->Log("===================== Stop the game!!!");
delete FILESYSTEM;
delete LOGGER;
delete root;
return 0;
}