void EC_ChatBubble::Refresh() { if (renderer_.expired() ||!billboardSet_ || !billboard_) return; // If no messages in the log, hide the chat bubble. if (messages_.size() == 0) { billboardSet_->setVisible(false); return; } else billboardSet_->setVisible(true); // Get pixmap with chat bubble and text rendered to it. QPixmap pixmap = GetChatBubblePixmap(); if (pixmap.isNull()) return; // Create texture QImage img = pixmap.toImage(); Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream((void*)img.bits(), img.byteCount())); std::string tex_name("ChatBubbleTexture" + renderer_.lock()->GetUniqueObjectName()); Ogre::TextureManager &manager = Ogre::TextureManager::getSingleton(); Ogre::Texture *tex = dynamic_cast<Ogre::Texture *>(manager.create(tex_name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME).get()); assert(tex); tex->loadRawData(stream, img.width(), img.height(), Ogre::PF_A8R8G8B8); // Set new material with the new texture name in it. std::string newMatName = std::string("material") + renderer_.lock()->GetUniqueObjectName(); Ogre::MaterialPtr material = OgreRenderer::CloneMaterial("UnlitTexturedSoftAlpha", newMatName); OgreRenderer::SetTextureUnitOnMaterial(material, tex_name); billboardSet_->setMaterialName(newMatName); }
void GlobalMap::loadResource(Ogre::Resource *resource) { Ogre::Texture* tex = static_cast<Ogre::Texture*>(resource); Ogre::ConstImagePtrList list; list.push_back(&mOverlayImage); tex->_loadImages(list); }
void gkTextureLoader::loadResource(Ogre::Resource* resource) { Ogre::Texture* texture = static_cast<Ogre::Texture*>(resource); if (!m_stream) { gkPrintf("Warning: Skipping image %s no packed file information is present!", texture->getName().c_str()); return; } Ogre::DataStreamPtr stream(OGRE_NEW Ogre::MemoryDataStream(m_stream->ptr(), m_stream->size())); Ogre::Image ima; ima.load(stream); texture->setUsage(Ogre::TU_DEFAULT); texture->setTextureType(Ogre::TEX_TYPE_2D); texture->setNumMipmaps(gkEngine::getSingleton().getUserDefs().defaultMipMap); texture->setWidth(ima.getWidth()); texture->setHeight(ima.getHeight()); texture->setDepth(ima.getDepth()); texture->setFormat(ima.getFormat()); Ogre::ConstImagePtrList ptrs; ptrs.push_back(&ima); texture->_loadImages(ptrs); }
void CharacterPreview::loadResource(Ogre::Resource *resource) { Ogre::Texture* tex = dynamic_cast<Ogre::Texture*>(resource); if (!tex) return; tex->createInternalResources(); mRenderTarget = NULL; mViewport = NULL; mRecover = true; }
void OnePixelMaterialGenerator::loadResource(Ogre::Resource* resource) { Ogre::Texture* texture = static_cast<Ogre::Texture*>(resource); static Ogre::uchar data[3] = {0xFF, 0x7F, 0x7F}; Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(&data, 3, false, true)); Ogre::Image image; image.loadRawData(stream, 1,1,1, Ogre::PF_R8G8B8); Ogre::ConstImagePtrList images({&image}); texture->_loadImages(images); }
void TexturePreviewEditor::OpenOgreTexture(const QString& name) { if (name.contains(".dds")) { LogWarning("currently cannot show .dds files. "); // Set black background image that will be replaced once the real image has been received. QImage emptyImage = QImage(QSize(256, 256), QImage::Format_ARGB32); emptyImage.fill(qRgba(0,0,0,0)); if ( imageLabel_ != 0) imageLabel_->setPixmap(QPixmap::fromImage(emptyImage)); return; } Ogre::ResourcePtr res = Ogre::TextureManager::getSingleton().getByName(name.toStdString().c_str()); Ogre::Texture* tex = static_cast<Ogre::Texture* >(res.get()); if (!tex) { LogWarning("Failed to open Ogre texture " + name.toStdString() + " ."); return; } int width = tex->getWidth(); int height = tex->getHeight(); Ogre::Box bounds(0, 0, width, height); Ogre::uchar* pixelData = new Ogre::uchar[width * height * 4]; Ogre::PixelBox pixels(bounds, Ogre::PF_A8R8G8B8, pixelData); tex->getBuffer()->blitToMemory(pixels); // Create image of texture, and show it into label. u8* p = static_cast<u8 *>(pixels.data); int widthPixels = pixels.getWidth(); int heightPixels= pixels.getHeight(); QImage img = ConvertToQImage(p, widthPixels, heightPixels, 4); if(!img.isNull() && imageLabel_ != 0) { imageLabel_->setPixmap(QPixmap::fromImage(img)); imageLabel_->show(); } delete[] pixelData; }
void TestGame::DrawPlanetMap(Logic::PlanetJustGenerateEvent *evnt){ std::map<Logic::BaseCountry*,std::vector<Logic::CountryTile>>::iterator CntrItr; std::vector<Logic::CountryTile>::iterator TileItr; int tilesize=TILESIZE; bool why; Ogre::Vector3 tempVect; int maxX = (int)Logic::BaseAsset::GetSigleton("MAP_X"),maxY=(int)Logic::BaseAsset::GetSigleton("MAP_Y"); Ogre::SceneNode* node,*capitalNode,*mapnode =mSceneMgr->getRootSceneNode()->createChildSceneNode("Map"); mapnode->translate(-maxX/2*tilesize,-maxY/2*tilesize,0); Ogre::Entity* entNinja = 0; Ogre::FontPtr font = Ogre::FontManager::getSingleton().getResourceIterator().begin()->second; // Make sure the texture is not WRITE_ONLY, we need to read the buffer to do the blending with the font (get the alpha for example) int j =0; for(CntrItr=evnt->allTiles.begin();CntrItr!=evnt->allTiles.end(); CntrItr++){ Ogre::ManualObject* manual = mSceneMgr->createManualObject("CountryObject"+CntrItr->first->mName); Ogre::Texture* texture = Ogre::TextureManager::getSingleton().createManual("CountryText"+CntrItr->first->mName,"General",Ogre::TEX_TYPE_2D,512, 512, 0, Ogre::PF_FLOAT32_RGBA , Ogre::TU_DEFAULT).getPointer(); Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("CountryMaterial"+CntrItr->first->mName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); //Draw the background to the new texture Ogre::HardwarePixelBufferSharedPtr pixelBuffer = texture->getBuffer(); // Lock the pixel buffer and get a pixel box pixelBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL); // for best performance use HBL_DISCARD! const Ogre::PixelBox& pixelBox = pixelBuffer->getCurrentLock(); float *pDest = static_cast<float*>(pixelBox.data); Ogre::ColourValue *temp = &CntrItr->first->mColor; // Fill in some pixel data. This will give a semi-transparent blue, // but this is of course dependent on the chosen pixel format. for (size_t k = 0; k < 512; k++) for(size_t q = 0; q < 512; q++) { *pDest++ =temp->b; // B *pDest++ = temp->g; *pDest++ =temp->r; *pDest++ = 0; // A*/ /* *pDest++ = 255; // B *pDest++ = 0; // G *pDest++ = 0; // R *pDest++ = 127; // A*/ } // Unlock the pixel buffer pixelBuffer->unlock(); ///WriteToTexture(Logic::LogicStd::IntToString(j),Ogre::TexturePtr(texture),Ogre::Image::Box(25,275,370,500),font,Ogre::ColourValue(1.0,1.0,1.0,1.0),'c'); mat->getTechnique(0)->getPass(0)->createTextureUnitState("CountryText"+CntrItr->first->mName); // mat->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA); j++; // specify the material (by name) and rendering type manual->begin("CountryMaterial"+CntrItr->first->mName, Ogre::RenderOperation::OT_TRIANGLE_LIST); int i=0; for(TileItr= CntrItr->second.begin();TileItr!= CntrItr->second.end();TileItr++){ tempVect = calculateActualPointFromCenter(CntrItr->first->mCapital.mPosition,(*TileItr).mPosition); tempVect =tempVect*tilesize; manual->position(tempVect.x-tilesize/2,tempVect.y+tilesize/2,tempVect.z); //manual->colour(CntrItr->first->mColor); manual->position(tempVect.x+tilesize/2,tempVect.y+tilesize/2,tempVect.z); //manual->colour(CntrItr->first->mColor); manual->position(tempVect.x+tilesize/2,tempVect.y-tilesize/2,tempVect.z); //manual->colour(CntrItr->first->mColor); manual->position(tempVect.x-tilesize/2,tempVect.y-tilesize/2,tempVect.z); //manual->colour(CntrItr->first->mColor); manual->triangle(i*4+0,i*4+2,i*4+1); manual->triangle(i*4+0,i*4+3,i*4+2); //manual->quad(i*4+0,i*4+2,i*4+3,i*4+1); i++; } // tell Ogre, your definition has finished manual->end(); // add ManualObject to the RootSceneNode (so it will be visible) node =mapnode->createChildSceneNode(); entNinja= mSceneMgr->createEntity("Capital/"+CntrItr->first->mName, "capital.mesh"); entNinja->setCastShadows(true); entNinja->setMaterialName("CountryMaterial"+CntrItr->first->mName); Control::ClickHelper* helpr = new Control::ClickHelper(Logic::CHT_COUNTRY); helpr->target = CntrItr->first; entNinja->setUserAny(Ogre::Any(helpr)); CntrItr->first->mNode = node; capitalNode = node->createChildSceneNode(); capitalNode->attachObject(entNinja); capitalNode->pitch(Ogre::Degree(90)); node->attachObject(manual); // I move the SceneNode so that it is visible to the camera. tempVect = Ogre::Vector3(CntrItr->first->mCapital.mPosition.x*tilesize,CntrItr->first->mCapital.mPosition.y*tilesize,-10); node->translate(tempVect); } mapnode->pitch(Ogre::Degree(-45)); }
void Terrain::loadResource(Ogre::Resource* resource) { const Ogre::String& name = resource->getName(); if (name.find("<Lightmap>") !=Ogre::String::npos) { Ogre::String::size_type left_parentheses = name.find_first_of('('); Ogre::String::size_type right_parentheses = name.find_last_of(')'); if (left_parentheses ==Ogre::String::npos || right_parentheses ==Ogre::String::npos) { OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Unorganised lightmap texture name '" + name + "'", "Terrain::loadResource"); } Ogre::StringVector vec = Ogre::StringUtil::split( name.substr(left_parentheses + 1, right_parentheses - left_parentheses - 1), ",", 2); if (vec.size() != 2) { OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Unorganised lightmap texture name '" + name + "'", "Terrain::loadResource"); } int nPosX = Ogre::StringConverter::parseInt(vec[0]); int nPosZ = Ogre::StringConverter::parseInt(vec[1]); if (nPosX < 0 || nPosX >= mData->mNumTilePerX || nPosZ < 0 || nPosZ >= mData->mNumTilePerZ) { OGRE_EXCEPT(Ogre::Exception::ERR_INTERNAL_ERROR, "Unorganised lightmap texture name '" + name + "'", "Terrain::loadResource"); } Ogre::uint uWidth, uHeight; if (getLightmapQuality() == LMQ_LOW) { uWidth = mData->mTileSize * 2; uHeight = mData->mTileSize * 2; } else { uWidth = mData->mTileSize * 8; uHeight = mData->mTileSize * 8; } Ogre::Texture* pTexture = static_cast<Ogre::Texture*>(resource); if (pTexture->getWidth() != uWidth || pTexture->getHeight() != uHeight) { pTexture->freeInternalResources(); pTexture->setWidth(uWidth); pTexture->setHeight(uHeight); } pTexture->createInternalResources(); Ogre::HardwarePixelBufferSharedPtr bufferPtr = pTexture->getBuffer(); size_t l = nPosX * mData->mTileSize * 8; size_t t = nPosZ * mData->mTileSize * 8; size_t r = l + mData->mTileSize * 8; size_t b = t + mData->mTileSize * 8; if (r > mData->mLightmapImage->getWidth()) r = mData->mLightmapImage->getWidth(); if (b > mData->mLightmapImage->getHeight()) b = mData->mLightmapImage->getHeight(); bufferPtr->blitFromMemory( mData->mLightmapImage->getPixelBox().getSubVolume(Ogre::Box(l, t, r, b))); } else { for (AtlasArray::const_iterator it = mAtlases.begin(); it != mAtlases.end(); ++it) { if (it->texture.get() == resource) { assert(!it->image.isNull()); it->texture->loadImage(*it->image); break; } } } }
void saveAsDotScene(const QString& path, QFile& file, Ogre::SceneManager* sceneManager) { Ogre::MeshSerializer* mMeshSerializer = new Ogre::MeshSerializer(); Ogre::MaterialSerializer* mMaterialSerializer = new Ogre::MaterialSerializer(); int idCounter = 3; if (!file.open(QIODevice::WriteOnly)) { /* show wrror message if not able to open file */ QMessageBox::warning(0, "Read only", "The file is in read only mode"); } else { Ogre::SceneManager::MovableObjectIterator iterator = sceneManager->getMovableObjectIterator("Entity"); QXmlStreamWriter* xmlWriter = new QXmlStreamWriter(); xmlWriter->setAutoFormatting(true); xmlWriter->setDevice(&file); xmlWriter->writeStartElement("scene"); xmlWriter->writeAttribute("formatVersion",""); xmlWriter->writeStartElement("nodes"); while(iterator.hasMoreElements()) { Ogre::Entity* e = static_cast<Ogre::Entity*>(iterator.getNext()); Ogre::Any any = e->getParentNode()->getUserAny(); Ogre::String widgetType(""); if(!any.isEmpty()){ widgetType = any_cast<Ogre::String>(any); } Ogre::String tmp(widgetType + ":" + e->getParentNode()->getName()); QString nodeName(tmp.c_str()); xmlWriter->writeStartElement("node"); xmlWriter->writeAttribute("name", nodeName); xmlWriter->writeAttribute("id", QString::number(idCounter++)); xmlWriter->writeStartElement("position"); xmlWriter->writeAttribute("x", QString::number(e->getParentNode()->getPosition().x)); xmlWriter->writeAttribute("y", QString::number(e->getParentNode()->getPosition().y)); xmlWriter->writeAttribute("z", QString::number(e->getParentNode()->getPosition().z)); xmlWriter->writeEndElement(); xmlWriter->writeStartElement("scale"); xmlWriter->writeAttribute("x", QString::number(e->getParentNode()->getScale().x)); xmlWriter->writeAttribute("y", QString::number(e->getParentNode()->getScale().y)); xmlWriter->writeAttribute("z", QString::number(e->getParentNode()->getScale().z)); xmlWriter->writeEndElement(); xmlWriter->writeStartElement("entity"); xmlWriter->writeAttribute("name", nodeName); xmlWriter->writeAttribute("meshFile", nodeName.toLower() + QString(".mesh") ); xmlWriter->writeAttribute("static", QString("false")); xmlWriter->writeEndElement(); const Mesh* mesh = e->getMesh().getPointer(); mMeshSerializer->exportMesh(mesh,String(path.toStdString() + nodeName.toLower().toStdString() + ".mesh" )); std::cout << "numeber" << mesh->getNumSubMeshes() << std::endl; for(int i = 0; i < e->getNumSubEntities(); i++){ Ogre::Material *mat = static_cast<Ogre::Material*> (Ogre::MaterialManager::getSingletonPtr()->getByName(e->getSubEntity(i)->getMaterialName()).getPointer()); //e->getMesh().get()->getSubMesh() if(mat->getTechnique(0)->getPass(0)->getNumTextureUnitStates() !=0){ Ogre::String str = mat->getTechnique(0)->getPass(0)->getTextureUnitState(0)->getTextureName(); Ogre::MaterialPtr mMatPtr =e->getSubEntity(i)->getMaterial() ; mMaterialSerializer->exportMaterial(mMatPtr , String(path.toStdString() + nodeName.toLower().toStdString() + QString::number(i).toStdString() + ".material" )); Ogre::TexturePtr* mTexPtr = new Ogre::TexturePtr(Ogre::TextureManager::getSingletonPtr()->getByName(str)); Ogre::Texture* mTex = mTexPtr->getPointer(); Ogre::PixelFormat pxf = mTex->getFormat(); Ogre::Image mImage; mTex->convertToImage(mImage); std::cout << str << std::endl; mImage.save(String(path.toStdString() + str)); } } //material file merge for(int i = 0; i < e->getNumSubEntities(); i++){ Ogre::Material *mat = static_cast<Ogre::Material*> (Ogre::MaterialManager::getSingletonPtr()->getByName(e->getSubEntity(i)->getMaterialName()).getPointer()); QString mMatFilePath = QString((path.toStdString() + nodeName.toLower().toStdString() + ".material").c_str()) ; QFile mFile(mMatFilePath); if (!mFile.open(QIODevice::Append)) { /* show wrror message if not able to open file */ QMessageBox::warning(0, "Read only", "The file is in read only mode"); } else{ QTextStream out(&mFile); QString mTempMatPath = QString((path + nodeName.toLower() + QString::number(i) + ".material")); QFile mTempMatFile(mTempMatPath); mTempMatFile.open(QIODevice::ReadOnly); QTextStream src(&mTempMatFile); mFile.write(src.readAll().toStdString().c_str()); mTempMatFile.remove(); } } xmlWriter->writeEndElement(); } xmlWriter->writeEndElement(); xmlWriter->writeEndDocument(); delete xmlWriter; } delete mMeshSerializer; delete mMaterialSerializer; }
void OgreInfo::diagnose(std::ostream& outputStream) { Ogre::SceneManagerEnumerator::SceneManagerIterator sceneManagerI = Ogre::Root::getSingleton().getSceneManagerIterator(); while (sceneManagerI.hasMoreElements()) { Ogre::SceneManager* sceneManager = sceneManagerI.getNext(); outputStream << "Scenemanager(" << sceneManager->getTypeName() << ") " << sceneManager->getName() << std::endl; outputStream << " Number of scene nodes: " << countNodes(sceneManager->getRootSceneNode()) << std::endl; outputStream << " Movable objects:" << std::endl; unsigned int movableObjectCounter = 0; Ogre::Root::MovableObjectFactoryIterator movableObjectFactoryI = Ogre::Root::getSingleton().getMovableObjectFactoryIterator(); while (movableObjectFactoryI.hasMoreElements()) { Ogre::MovableObjectFactory* factory = movableObjectFactoryI.getNext(); std::string type(factory->getType()); { Ogre::SceneManager::MovableObjectIterator I = sceneManager->getMovableObjectIterator(type); while (I.hasMoreElements()) { movableObjectCounter++; Ogre::MovableObject* movable = I.getNext(); if (movable->getMovableType() == "Light") { Ogre::Light* light = static_cast<Ogre::Light*> (movable); outputStream << " * Light " << light->getName() << "(" << (light->isInScene() ? "in scene" : "not in scene") << ")" << std::endl; outputStream << " Pos: " << light->getDerivedPosition() << std::endl; outputStream << " Direction: " << light->getDerivedDirection() << std::endl; } else { std::stringstream ssPosAndOrientation; if (movable->getParentSceneNode() && movable->isInScene()) { ssPosAndOrientation << " pos: " << movable->getParentSceneNode()->getPosition() << " orientation: " << movable->getParentSceneNode()->getOrientation(); } outputStream << " * " << type << " " << movable->getName() << "(" << (movable->isInScene() ? "in scene" : "not in scene") << ")" << ssPosAndOrientation.str() << std::endl; // outputStream << " Pos: " << light->getDerivedPosition() << std::endl; // outputStream << " Direction: " << light->getDerivedDirection() << std::endl; } } } } outputStream << " Number of movable objects: " << movableObjectCounter << std::endl; outputStream << " Cameras:" << std::endl; { Ogre::SceneManager::CameraIterator I = sceneManager->getCameraIterator(); while (I.hasMoreElements()) { Ogre::Camera* camera = I.getNext(); outputStream << " Camera " << camera->getName() << "(" << (camera->isInScene() ? "in scene" : "not in scene") << ")" << std::endl; outputStream << " Pos: " << camera->getDerivedPosition() << std::endl; outputStream << " Direction: " << camera->getDerivedDirection() << std::endl; outputStream << " Clip distances: " << camera->getNearClipDistance() << " - " << camera->getFarClipDistance() << std::endl; } } } size_t resourceMemoryUsage = 0; outputStream << "Resource Managers:" << std::endl; Ogre::ResourceGroupManager::ResourceManagerIterator I = Ogre::ResourceGroupManager::getSingleton().getResourceManagerIterator(); while (I.hasMoreElements()) { std::string name = I.peekNextKey(); Ogre::ResourceManager* manager = I.getNext(); outputStream << " Resource Manager: " << name << std::endl; if (manager->getMemoryBudget() == std::numeric_limits<size_t>::max()) { outputStream << " Memory budget: not set" << std::endl; } else { outputStream << " Memory budget: " << manager->getMemoryBudget() << " bytes" << std::endl; } outputStream << " Memory usage: " << manager->getMemoryUsage() << " bytes" << std::endl; resourceMemoryUsage += manager->getMemoryUsage(); Ogre::ResourceManager::ResourceMapIterator resourceI = manager->getResourceIterator(); if (resourceI.hasMoreElements()) { outputStream << " Resources: " << std::endl; int resourceCount = 0; int loadedResourceCount = 0; while (resourceI.hasMoreElements()) { Ogre::ResourcePtr resource = resourceI.getNext(); if (resource->isLoaded()) { std::string reloadable = resource->isReloadable() ? " reloadable" : ""; outputStream << " " << resource->getName() << " ( " << resource->getSize() << " bytes)" << reloadable; Ogre::Texture* texture = dynamic_cast<Ogre::Texture*>(resource.get()); if (texture) { outputStream << texture->getWidth() << "x" << texture->getHeight() << " "; } outputStream << std::endl; loadedResourceCount++; } resourceCount++; } outputStream << " Total number of resources: " << resourceCount << std::endl; outputStream << " Number of loaded resources: " << loadedResourceCount << std::endl; } } outputStream << "Total memory usage for all resource manager: " << resourceMemoryUsage << " bytes" << std::endl; outputStream << std::flush; }
HCURSOR CUIIconsManager::CreateAsWinCursor(LPCTSTR szIconName) { try{ //------------------------------------------------------- //CEGUI Image const CEGUI::Image* pIconImage = GetIcon(szIconName); if(!pIconImage) return NULL; //------------------------------------------------------- //CEGUI ImageSet CEGUI::Imageset* pImageset = CEGUI::ImagesetManager::getSingleton().getImageset(pIconImage->getImagesetName()); if(!pImageset) return NULL; //------------------------------------------------------- //CEGUI Ogre Texture CEGUI::OgreCEGUITexture* pCEGUIOgreTexture = (CEGUI::OgreCEGUITexture*)(pImageset->getTexture()); if(!pCEGUIOgreTexture) return NULL; //------------------------------------------------------- //Ogre Texture Ogre::Texture* pOgreTexture = pCEGUIOgreTexture->getOgreTexture().get(); if(!pOgreTexture) return NULL; //------------------------------------------------------- //Ogre HardwarePixelBuffer Ogre::HardwarePixelBuffer* pOgreHardPixBuf = pOgreTexture->getBuffer().get(); if(!pOgreHardPixBuf) return NULL; //------------------------------------------------------- //Blt to Ogre PixelBox const static INT s_CursorWidth = 32; const static INT s_CursorHeight = 32; CEGUI::Rect rectAtImage = pIconImage->getSourceTextureArea(); const Ogre::PixelBox thePixBox(s_CursorWidth, s_CursorHeight, 1, Ogre::PF_R8G8B8A8, new char[s_CursorWidth*s_CursorHeight*Ogre::PixelUtil::getNumElemBytes(Ogre::PF_R8G8B8A8)]); pOgreHardPixBuf->blitToMemory( Ogre::Image::Box((INT)rectAtImage.d_left, (INT)rectAtImage.d_top, (INT)rectAtImage.d_right, (INT)rectAtImage.d_bottom), thePixBox); //------------------------------------------------------- //Create Windows Bitmap as XOR Mask HDC hMainDC = ::GetDC(NULL); HDC hXorMaskDC = ::CreateCompatibleDC(hMainDC); HBITMAP hXorMask = ::CreateCompatibleBitmap(hMainDC, s_CursorWidth, s_CursorHeight); ::SelectObject(hXorMaskDC, hXorMask); //------------------------------------------------------- //Get per Pixel Color to XOR Mask for(register INT x=0; x<s_CursorWidth; x++) { for(register INT y=0; y<s_CursorHeight; y++) { Ogre::ColourValue col; VOID* pColData = (thePixBox.rowPitch*y + x)* Ogre::PixelUtil::getNumElemBytes(thePixBox.format) + (unsigned char*)thePixBox.data; Ogre::PixelUtil::unpackColour( &col, thePixBox.format, pColData); ::SetPixel(hXorMaskDC, x, y, RGB(col.r*255, col.g*255, col.b*255)); } } delete[] thePixBox.data; ::DeleteDC(hXorMaskDC); hXorMaskDC = NULL; //------------------------------------------------------- //Create AND Mask HDC hAndMaskDC = ::CreateCompatibleDC(hMainDC); HBITMAP hAndMask = ::CreateCompatibleBitmap(hMainDC, s_CursorWidth, s_CursorHeight); ::SelectObject(hAndMaskDC, hAndMask); RECT rect; ::SetRect(&rect, 0, 0, s_CursorWidth, s_CursorHeight); ::FillRect(hAndMaskDC, &rect, (HBRUSH)::GetStockObject(BLACK_BRUSH)); ::DeleteDC(hAndMaskDC); hAndMaskDC = NULL; //------------------------------------------------------- //Create Crusor ICONINFO iconinfo = {0}; iconinfo.fIcon = FALSE; iconinfo.xHotspot = 0; iconinfo.yHotspot = 0; iconinfo.hbmMask = hAndMask; iconinfo.hbmColor = hXorMask; HCURSOR hRetCursor = ::CreateIconIndirect(&iconinfo); //------------------------------------------------------- //Release ::DeleteObject(hAndMask); ::DeleteObject(hXorMask); ::ReleaseDC(NULL,hMainDC); return hRetCursor; }catch(...) { return 0; } }