Mage::Mage(float xPos, float yPos, bool toEast) : f_xPos(xPos), f_yPos(yPos),
b_standToTheEast(toEast), p_mageStopped(0), p_mageAnimated(0), b_isUsingMagic(false), f_pauseUsingMagic(0.0f), f_timeToShot(0.0f)
{
mage_east = hge->Texture_Load("Resources\\mage_east.png");
f_pauseInterval = hge->Random_Float(2.0, 5.0);
if(!prepareResources())
{
release();
throw game_errors::load_mage_sources;
}
}
Packet::Packet( packet_type type, float damage, float speed, float shift, const char* packet ) :
m_ePacketType( type ), m_fDamage( damage ), m_fSpeed( speed ), m_fShift ( shift )
{
m_hPacketTex = hge->Texture_Load( packet );
m_vDir = objects->getTank( )->getCurrentWeapon( )->getDirection( );
m_vPos = objects->getTank( )->getCurrentWeapon( )->getPosition( );
m_vPos += m_vDir * m_fShift;
if( !prepareResources( ) )
{
release();
throw game_errors::LOAD_PACKET_SOURCES;
}
}
/**
* Default constructor
*
* @param vulkanDevice Pointer to a valid VulkanDevice
*/
VulkanTextOverlay(
vks::VulkanDevice *vulkanDevice,
VkQueue queue,
std::vector<VkFramebuffer> &framebuffers,
VkFormat colorformat,
VkFormat depthformat,
uint32_t *framebufferwidth,
uint32_t *framebufferheight,
std::vector<VkPipelineShaderStageCreateInfo> shaderstages)
{
this->vulkanDevice = vulkanDevice;
this->queue = queue;
this->colorFormat = colorformat;
this->depthFormat = depthformat;
this->frameBuffers.resize(framebuffers.size());
for (uint32_t i = 0; i < framebuffers.size(); i++)
{
this->frameBuffers[i] = &framebuffers[i];
}
this->shaderStages = shaderstages;
this->frameBufferWidth = framebufferwidth;
this->frameBufferHeight = framebufferheight;
#if defined(__ANDROID__)
// Scale text on Android devices with high DPI
if (vks::android::screenDensity >= ACONFIGURATION_DENSITY_XXHIGH) {
LOGD("XXHIGH");
scale = 2.0f;
}
else if (vks::android::screenDensity >= ACONFIGURATION_DENSITY_XHIGH) {
LOGD("XHIGH");
scale = 1.5f;
}
else if (vks::android::screenDensity >= ACONFIGURATION_DENSITY_HIGH) {
LOGD("HIGH");
scale = 1.25f;
};
#endif
cmdBuffers.resize(framebuffers.size());
prepareResources();
prepareRenderPass();
preparePipeline();
}
//------------------------------------------------------
void TextureAtlas::build() {
if (!mIsDirty)
return;
bool fitted;
size_t area = 0;
// build the fonts (if this didn't happen already)
// so we'll be sure the glyphs are there to be atlassed
FontSet::iterator fit = mMyFonts.begin();
while (fit != mMyFonts.end()) {
FontDrawSource* fdsp = *fit++;
if (!fdsp->isBuilt())
fdsp->build();
}
// First, we sort by size of the DrawSource
mMyDrawSources.sort(DrawSourceLess());
// now try to allocate all the draw sources. If we fail, grow and try again
do {
fitted = true;
area = 0;
// try to fit
DrawSourceList::iterator it = mMyDrawSources.begin();
while (it != mMyDrawSources.end()) {
const DrawSourcePtr& ds = *it++;
const PixelSize& ps = ds->getPixelSize();
area += ps.getPixelArea();
LOG_VERBOSE("TextureAtlas: (%s) Trying to place %d x %d (%d -> %d)", mAtlasName.c_str(), ps.width, ps.height, ps.getPixelArea(), area);
// try to allocate
FreeSpaceInfo* fsi = mAtlasAllocation->allocate(ps.width, ps.height);
if (fsi) {
ds->setPlacementPtr(fsi);
} else {
fitted = false;
break;
}
}
// fitted?
if (!fitted) // nope - Enlarge!
enlarge(area);
} while (!fitted);
LOG_INFO("TextureAtlas: (%s) Creating atlas with dimensions %d x %d", mAtlasName.c_str(), mAtlasSize.width, mAtlasSize.height);
if (mTexture.isNull())
prepareResources();
// TODO: Reallocate the texture here if needed!
Ogre::HardwarePixelBufferSharedPtr pixelBuffer = mTexture->getBuffer();
pixelBuffer->lock(Ogre::HardwareBuffer::HBL_DISCARD);
const Ogre::PixelBox& targetBox = pixelBuffer->getCurrentLock();
size_t pixelsize = Ogre::PixelUtil::getNumElemBytes(targetBox.format);
size_t rowsize = targetBox.rowPitch * pixelsize;
Ogre::uint8* dstData = static_cast<Ogre::uint8*>(targetBox.data);
// We'll iterate over all draw sources, painting the pixels onto the allocated space
DrawSourceList::iterator it = mMyDrawSources.begin();
while (it != mMyDrawSources.end()) {
const DrawSourcePtr& ds = *it++;
// render all pixels into the right place
FreeSpaceInfo* fsi = reinterpret_cast<FreeSpaceInfo*>(ds->getPlacementPtr());
assert(fsi);
// render into the specified place
unsigned char* conversionBuf = NULL;
const PixelSize& dps = ds->getPixelSize();
Ogre::Image* img = ds->getImage();
Ogre::PixelBox srcPixels = img->getPixelBox();
// convert if the source data don't match
if(img->getFormat() != Ogre::PF_BYTE_BGRA) {
conversionBuf = new unsigned char[img->getWidth() * img->getHeight() * pixelsize];
Ogre::PixelBox convPixels(Ogre::Box(0, 0, dps.width, dps.height), Ogre::PF_BYTE_BGRA, conversionBuf);
Ogre::PixelUtil::bulkPixelConversion(srcPixels, convPixels);
srcPixels = convPixels;
}
size_t srcrowsize = srcPixels.rowPitch * pixelsize;
Ogre::uint8* srcData = static_cast<Ogre::uint8*>(srcPixels.data);
// TODO: we're always handling 32bit data, so we could as well transfer 4 bytes each iteration instead of one (speedup)
for(size_t row = 0; row < dps.height; row++) {
for(size_t col = 0; col < srcrowsize; col++) {
dstData[((row + fsi->y) * rowsize) + (fsi->x * pixelsize) + col] =
srcData[(row * srcrowsize) + col];
}
}
delete[] conversionBuf;
// Convert the full draw source pixel coordinates to the atlas contained ones (initializes the texturing coordinates transform)
ds->atlas(mMaterial, fsi->x, fsi->y, mAtlasSize.width, mAtlasSize.height);
}
// for debug, write the texture to a file
/*unsigned char *readrefdata = static_cast<unsigned char*>(targetBox.data);
Ogre::Image img;
img = img.loadDynamicImage (readrefdata, mTexture->getWidth(),
mTexture->getHeight(), mTexture->getFormat());
img.save(mAtlasName + ".png");*/
// and close the pixel buffer of the atlas at the end
pixelBuffer->unlock();
mIsDirty = false;
}
