void j1Map::Draw()
{
if(map_loaded == false)
return;
// TODO 6: Iterate all tilesets and draw all their
// images in 0,0 (you should have only one tileset for now)
gameArtTiles = LoadRootTileGraphics(gameArtTiles);
for (int i = 0; i < map.numLayers; i++)
{
for (int j = 0; j < map.height; j++)
{
for (int k = 0; k < map.width ; k++)
{
App->render->Blit(gameArtTiles, k*map.tileWidth, j*map.tileHeigth, &GetTileRect(Get(k,j)));
}
}
}
}
// get the coordinates of a specific tile
static RectI GetTileRectDevice(BaseEngine* engine, int pageNo, int rotation, float zoom, TilePosition tile) {
RectD mediabox = engine->PageMediabox(pageNo);
if (tile.res > 0 && tile.res != INVALID_TILE_RES)
mediabox = GetTileRect(mediabox, tile);
RectD pixelbox = engine->Transform(mediabox, pageNo, zoom, rotation);
return pixelbox.Round();
}
gfx::IntRect TiledTextureImage::GetSrcTileRect()
{
gfx::IntRect rect = GetTileRect();
const bool needsYFlip = mFlags & OriginBottomLeft;
unsigned int srcY = needsYFlip ? mSize.height - rect.height - rect.y
: rect.y;
return gfx::IntRect(rect.x, srcY, rect.width, rect.height);
}
IntSize
DeprecatedTextureHostShmemD3D11::GetSize() const
{
if (mIterating) {
gfx::IntRect rect = GetTileRect(mCurrentTile);
return gfx::IntSize(rect.width, rect.height);
}
return TextureSourceD3D11::GetSize();
}
// marks all tiles containing rect of pageNo as out of date
void RenderCache::Invalidate(DisplayModel* dm, int pageNo, RectD rect) {
ScopedCritSec scopeReq(&requestAccess);
ClearQueueForDisplayModel(dm, pageNo);
if (curReq && curReq->dm == dm && curReq->pageNo == pageNo)
AbortCurrentRequest();
ScopedCritSec scopeCache(&cacheAccess);
RectD mediabox = dm->GetEngine()->PageMediabox(pageNo);
for (int i = 0; i < cacheCount; i++) {
if (cache[i]->dm == dm && cache[i]->pageNo == pageNo &&
!GetTileRect(mediabox, cache[i]->tile).Intersect(rect).IsEmpty()) {
cache[i]->zoom = INVALID_ZOOM;
cache[i]->outOfDate = true;
}
}
}
void
DeprecatedTextureHostShmemD3D11::UpdateImpl(const SurfaceDescriptor& aImage,
nsIntRegion* aRegion,
nsIntPoint* aOffset)
{
MOZ_ASSERT(aImage.type() == SurfaceDescriptor::TShmem ||
aImage.type() == SurfaceDescriptor::TMemoryImage);
AutoOpenSurface openSurf(OPEN_READ_ONLY, aImage);
nsRefPtr<gfxImageSurface> surf = openSurf.GetAsImage();
gfxIntSize size = surf->GetSize();
uint32_t bpp = 0;
DXGI_FORMAT dxgiFormat;
switch (surf->Format()) {
case gfxImageSurface::ImageFormatRGB24:
mFormat = FORMAT_B8G8R8X8;
dxgiFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
bpp = 4;
break;
case gfxImageSurface::ImageFormatARGB32:
mFormat = FORMAT_B8G8R8A8;
dxgiFormat = DXGI_FORMAT_B8G8R8A8_UNORM;
bpp = 4;
break;
case gfxImageSurface::ImageFormatA8:
mFormat = FORMAT_A8;
dxgiFormat = DXGI_FORMAT_A8_UNORM;
bpp = 1;
break;
}
mSize = IntSize(size.width, size.height);
CD3D11_TEXTURE2D_DESC desc(dxgiFormat, size.width, size.height,
1, 1, D3D11_BIND_SHADER_RESOURCE,
D3D11_USAGE_IMMUTABLE);
int32_t maxSize = GetMaxTextureSizeForFeatureLevel(mDevice->GetFeatureLevel());
if (size.width <= maxSize && size.height <= maxSize) {
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = surf->Data();
initData.SysMemPitch = surf->Stride();
mDevice->CreateTexture2D(&desc, &initData, byRef(mTextures[0]));
mIsTiled = false;
} else {
mIsTiled = true;
uint32_t tileCount = GetRequiredTiles(size.width, maxSize) *
GetRequiredTiles(size.height, maxSize);
mTileTextures.resize(tileCount);
for (uint32_t i = 0; i < tileCount; i++) {
IntRect tileRect = GetTileRect(i);
desc.Width = tileRect.width;
desc.Height = tileRect.height;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = surf->Data() +
tileRect.y * surf->Stride() +
tileRect.x * bpp;
initData.SysMemPitch = surf->Stride();
mDevice->CreateTexture2D(&desc, &initData, byRef(mTileTextures[i]));
}
}
}
nsIntRect
DeprecatedTextureHostShmemD3D11::GetTileRect()
{
IntRect rect = GetTileRect(mCurrentTile);
return nsIntRect(rect.x, rect.y, rect.width, rect.height);
}
nsIntRect
DataTextureSourceD3D11::GetTileRect()
{
IntRect rect = GetTileRect(mCurrentTile);
return nsIntRect(rect.x, rect.y, rect.width, rect.height);
}
bool
DataTextureSourceD3D11::Update(DataSourceSurface* aSurface,
nsIntRegion* aDestRegion,
IntPoint* aSrcOffset)
{
// Incremental update with a source offset is only used on Mac so it is not
// clear that we ever will need to support it for D3D.
MOZ_ASSERT(!aSrcOffset);
MOZ_ASSERT(aSurface);
HRESULT hr;
if (!mCompositor || !mCompositor->GetDevice()) {
return false;
}
uint32_t bpp = BytesPerPixel(aSurface->GetFormat());
DXGI_FORMAT dxgiFormat = SurfaceFormatToDXGIFormat(aSurface->GetFormat());
mSize = aSurface->GetSize();
mFormat = aSurface->GetFormat();
CD3D11_TEXTURE2D_DESC desc(dxgiFormat, mSize.width, mSize.height, 1, 1);
int32_t maxSize = mCompositor->GetMaxTextureSize();
if ((mSize.width <= maxSize && mSize.height <= maxSize) ||
(mFlags & TextureFlags::DISALLOW_BIGIMAGE)) {
if (mTexture) {
D3D11_TEXTURE2D_DESC currentDesc;
mTexture->GetDesc(¤tDesc);
// Make sure there's no size mismatch, if there is, recreate.
if (currentDesc.Width != mSize.width || currentDesc.Height != mSize.height ||
currentDesc.Format != dxgiFormat) {
mTexture = nullptr;
// Make sure we upload the whole surface.
aDestRegion = nullptr;
}
}
if (!mTexture) {
hr = mCompositor->GetDevice()->CreateTexture2D(&desc, nullptr, byRef(mTexture));
mIsTiled = false;
if (FAILED(hr) || !mTexture) {
Reset();
return false;
}
}
DataSourceSurface::MappedSurface map;
aSurface->Map(DataSourceSurface::MapType::READ, &map);
if (aDestRegion) {
nsIntRegionRectIterator iter(*aDestRegion);
const nsIntRect *iterRect;
while ((iterRect = iter.Next())) {
D3D11_BOX box;
box.front = 0;
box.back = 1;
box.left = iterRect->x;
box.top = iterRect->y;
box.right = iterRect->XMost();
box.bottom = iterRect->YMost();
void* data = map.mData + map.mStride * iterRect->y + BytesPerPixel(aSurface->GetFormat()) * iterRect->x;
mCompositor->GetDC()->UpdateSubresource(mTexture, 0, &box, data, map.mStride, map.mStride * mSize.height);
}
} else {
mCompositor->GetDC()->UpdateSubresource(mTexture, 0, nullptr, aSurface->GetData(),
aSurface->Stride(), aSurface->Stride() * mSize.height);
}
aSurface->Unmap();
} else {
mIsTiled = true;
uint32_t tileCount = GetRequiredTilesD3D11(mSize.width, maxSize) *
GetRequiredTilesD3D11(mSize.height, maxSize);
mTileTextures.resize(tileCount);
mTexture = nullptr;
for (uint32_t i = 0; i < tileCount; i++) {
IntRect tileRect = GetTileRect(i);
desc.Width = tileRect.width;
desc.Height = tileRect.height;
desc.Usage = D3D11_USAGE_IMMUTABLE;
D3D11_SUBRESOURCE_DATA initData;
initData.pSysMem = aSurface->GetData() +
tileRect.y * aSurface->Stride() +
tileRect.x * bpp;
initData.SysMemPitch = aSurface->Stride();
hr = mCompositor->GetDevice()->CreateTexture2D(&desc, &initData, byRef(mTileTextures[i]));
if (FAILED(hr) || !mTileTextures[i]) {
Reset();
return false;
}
}
}
return true;
}
gfx::IntRect TextureImage::GetSrcTileRect() {
return GetTileRect();
}
