{

// don't do anything if the pages have already been populated

if(!pages.empty())

return;

// this only truncates on 32-bit builds, where we don't expect large resources

size_t count = (size_t)numPages;

// otherwise allocate them. If we have a single page mapping we can just duplicate and it's easy

if(singlePageReused || singleMapping.memory == ResourceId())

{

pages.fill(count, singleMapping);

}

else

{

// otherwise we need to allocate and increment

pages.reserve(count);

pages.clear();

for(uint64_t i = 0; i < numPages; i++)

{

pages.push_back(singleMapping);

singleMapping.offset += pageByteSize;

}

}

// reset the single mapping to be super clear

singleMapping = {};

singlePageReused = false;

{

m_PageByteSize = pageByteSize;

// set just in case the calling code calls getMipTailByteOffsetForSubresource

m_ArraySize = 1;

m_MipCount = 1;

m_TextureDim = {bufferByteSize, 1, 1};

m_PageTexelSize = {pageByteSize, 1, 1};

// initialise mip tail with buffer properties

m_MipTail.byteStride = 0;

m_MipTail.byteOffset = 0;

m_MipTail.firstMip = 0;

m_MipTail.totalPackedByteSize = bufferByteSize;

m_MipTail.mappings.resize(1);

m_MipTail.mappings[0].singlePageReused = false;

m_MipTail.mappings[0].singleMapping = {};

uint32_t pageByteSize, const Coord &pageTexelDim, uint32_t firstTailMip,

uint64_t mipTailOffset, uint64_t mipTailStride,

uint64_t mipTailTotalPackedSize)

{

// sanitise inputs to be safe

m_PageByteSize = RDCMAX(1U, pageByteSize);

m_ArraySize = RDCMAX(1U, numArraySlices);

m_MipCount = RDCMAX(1U, numMips);

m_PageTexelSize.x = RDCMAX((uint64_t)1ULL, pageTexelDim.x);

m_PageTexelSize.y = RDCMAX((uint64_t)1ULL, pageTexelDim.y);

m_PageTexelSize.z = RDCMAX((uint64_t)1ULL, pageTexelDim.z);

m_TextureDim.x = RDCMAX((uint64_t)1ULL, overallTexelDim.x);

m_TextureDim.y = RDCMAX((uint64_t)1ULL, overallTexelDim.y);

m_TextureDim.z = RDCMAX((uint64_t)1ULL, overallTexelDim.z);

// initialise the subresources

m_Subresources.resize(m_ArraySize * m_MipCount);

// initialise mip tail if we have one

if(firstTailMip < m_MipCount)

{

m_MipTail.byteStride = mipTailStride;

m_MipTail.byteOffset = mipTailOffset;

m_MipTail.firstMip = firstTailMip;

m_MipTail.totalPackedByteSize = mipTailTotalPackedSize;

if(m_MipTail.byteStride == 0)

{

m_MipTail.mappings.resize(1);

m_MipTail.mappings[0].singlePageReused = false;

m_MipTail.mappings[0].singleMapping = {};

}

else

{

m_MipTail.mappings.resize(m_ArraySize);

for(size_t i = 0; i < m_MipTail.mappings.size(); i++)

{

m_MipTail.mappings[i].singlePageReused = false;

m_MipTail.mappings[i].singleMapping = {};

}

}

}

else

{

m_MipTail.byteStride = 0;

m_MipTail.byteOffset = 0;

m_MipTail.firstMip = m_MipCount;

m_MipTail.totalPackedByteSize = 0;

}

uint64_t memoryByteOffset, uint64_t byteSize, bool useSinglePage)

{

// offsets should be page aligned

RDCASSERT((memoryByteOffset % m_PageByteSize) == 0, memoryByteOffset, m_PageByteSize);

RDCASSERT((resourceByteOffset % m_PageByteSize) == 0, resourceByteOffset, m_PageByteSize);

// size should either be page aligned, or should be the end of the mip tail region (for buffers

// that don't have to fill the whole thing)

RDCASSERT((byteSize % m_PageByteSize) == 0 ||

(resourceByteOffset + byteSize == m_MipTail.totalPackedByteSize),

resourceByteOffset, byteSize, m_PageByteSize, m_MipTail.totalPackedByteSize);

RDCASSERT(m_MipTail.totalPackedByteSize > 0);

// if we're setting to NULL, set the offset to 0

if(memory == ResourceId())

memoryByteOffset = 0;

// rebase the byte offset from resource-relative to miptail-relative

RDCASSERT(resourceByteOffset >= m_MipTail.byteOffset);

resourceByteOffset -= m_MipTail.byteOffset;

if(m_MipTail.mappings.empty())

{

RDCERR("Attempting to set mip tail on image with no mip region");

return m_MipTail.byteOffset + m_MipTail.totalPackedByteSize;

}

const uint64_t numTailPages =

((m_MipTail.totalPackedByteSize + m_PageByteSize - 1) / m_PageByteSize);

// if we're setting the whole mip tail at once, store it as a single page mapping

if(resourceByteOffset == 0 &&

(byteSize == m_MipTail.totalPackedByteSize || byteSize == numTailPages * m_PageByteSize))

{

for(size_t i = 0; i < m_MipTail.mappings.size(); i++)

{

m_MipTail.mappings[i].pages.clear();

m_MipTail.mappings[i].singleMapping.memory = memory;

m_MipTail.mappings[i].singleMapping.offset = memoryByteOffset;

m_MipTail.mappings[i].singlePageReused = useSinglePage;

// if we're not using a single page and we have multiple mip tails separated by a stride,

// update the memory offset for each single mapping. This implies wasted memory in between so

// I don't think apps will do this, but it may be legal so handle it here.

if(!useSinglePage)

memoryByteOffset += i * m_MipTail.byteStride;

}

// we consumed the whole mip tail by definition

return m_MipTail.byteOffset + m_MipTail.totalPackedByteSize;

}

else if(m_MipTail.mappings.size() == 1)

{

// if we only have one miptail region, this is simple. Create pages as needed and update the

// referenced pages

PageRangeMapping &mapping = m_MipTail.mappings[0];

mapping.createPages(numTailPages, m_PageByteSize);

// iterate through each referenced resource page

for(size_t

page = size_t(resourceByteOffset / m_PageByteSize),

endPage = size_t((resourceByteOffset + byteSize + m_PageByteSize - 1) / m_PageByteSize);

page < mapping.pages.size() && page < endPage; page++)

{

mapping.pages[page].memory = memory;

mapping.pages[page].offset = memoryByteOffset;

// if we're not mapping all resource pages to a single memory page, advance the offset

if(!useSinglePage && memory != ResourceId())

memoryByteOffset += m_PageByteSize;

}

mapping.simplifyUnmapped();

// return how much of the mip tail we consumed, clamped to the size. Note resourceByteOffset has

// been remapped to be mip-tail relative here

return m_MipTail.byteOffset +

RDCMIN(m_MipTail.totalPackedByteSize, resourceByteOffset + byteSize);

}

else

{

// otherwise the hard case - separate mip tails for each subresource. Figure out which

// subresource we're starting with

RDCASSERTNOTEQUAL(m_MipTail.byteStride, 0);

uint32_t sub = uint32_t(resourceByteOffset / m_MipTail.byteStride);

resourceByteOffset -= sub * m_MipTail.byteStride;

const uint64_t mipTailSubresourceByteSize =

m_MipTail.totalPackedByteSize / m_MipTail.mappings.size();

// while we have mapping bytes to consume and the subresource is in range

while(byteSize > 0 && sub < m_MipTail.mappings.size())

{

PageRangeMapping &mapping = m_MipTail.mappings[sub];

uint64_t consumedBytes = 0;

// if we're setting the whole miptail, store that concisely

if(resourceByteOffset == 0 && byteSize >= mipTailSubresourceByteSize)

{

mapping.pages.clear();

mapping.singleMapping.memory = memory;

mapping.singleMapping.offset = memoryByteOffset;

mapping.singlePageReused = useSinglePage;

if(!useSinglePage)

memoryByteOffset += m_MipTail.byteStride;

consumedBytes = mipTailSubresourceByteSize;

}

else

{

mapping.createPages(((mipTailSubresourceByteSize + m_PageByteSize - 1) / m_PageByteSize),

m_PageByteSize);

// iterate through each referenced page in this subresource's mip tail. Note we only iterate

// over as many pages as this mapping has, even if the bound region is larger.

for(size_t page = size_t(resourceByteOffset / m_PageByteSize),

endPage =

size_t((resourceByteOffset + byteSize + m_PageByteSize - 1) / m_PageByteSize);

page < mapping.pages.size() && page < endPage; page++)

{

mapping.pages[page].memory = memory;

mapping.pages[page].offset = memoryByteOffset;

// if we're not mapping all resource pages to a single memory page, advance the offset

if(!useSinglePage && memory != ResourceId())

memoryByteOffset += m_PageByteSize;

consumedBytes += m_PageByteSize;

}

memoryByteOffset += m_MipTail.byteStride - mipTailSubresourceByteSize;

}

// if we have fully set this mip tail, move to the next subresource's mip tail.

// note this covers the case where we set exactly all the bytes in the mip tail, where we set

// more bytes than exist but don't overlap into the next (based on stride), as well as the

// case where we have bytes to set in the next subresource too. In the first two cases we will

// just return, but in the last case we 'consume' the stride and get ready to continue

if(resourceByteOffset + consumedBytes >= mipTailSubresourceByteSize)

{

// we start from the first byte in the next miptail

resourceByteOffset = 0;

// advance over the consumed bytes

byteSize -= consumedBytes;

// advance over the padding bytes.

// if we don't have enough remaining to hit the stride, we just zero-out the number of bytes

// remaining

byteSize -= RDCMIN(byteSize, m_MipTail.byteStride - mipTailSubresourceByteSize);

// simplify current mapping before moving on to next subresource

mapping.simplifyUnmapped();

sub++;

}

else

{

// and consume all bytes, even if that is more than we actually used above (consider if the

// user specifies more than in the tail, but less than the stride)

byteSize = 0;

resourceByteOffset += consumedBytes;

}

}

// simplify the last tail that we touched, as long as it's still valid. If we just incremented

// past the last, we will have simplified above where sub is incremented

if(sub < m_MipTail.mappings.size())

m_MipTail.mappings[sub].simplifyUnmapped();

if(byteSize > 0)

RDCERR("Unclaimed bytes being assigned to image after iterating over all subresources");

return m_MipTail.byteOffset + sub * m_MipTail.byteStride + resourceByteOffset;

}

ResourceId memory, uint64_t memoryByteOffset, bool useSinglePage)

{

const Coord subresourcePageDim = calcSubresourcePageDim(subresource);

const Coord subresourceImgDim = getSubresourceDim(subresource);

RDCASSERT((coord.x % m_PageTexelSize.x) == 0);

RDCASSERT((coord.y % m_PageTexelSize.y) == 0);

RDCASSERT((coord.z % m_PageTexelSize.z) == 0);

// dimension may be misaligned if it's referring to part of a page on a non-page-aligned texture

// dimension

RDCASSERT((dim.x % m_PageTexelSize.x) == 0 || (coord.x + dim.x == subresourceImgDim.x),

subresource, dim.x, coord.x, m_PageTexelSize.x, m_TextureDim.x, subresourceImgDim.x);

RDCASSERT((dim.y % m_PageTexelSize.y) == 0 || (coord.y + dim.y == subresourceImgDim.y),

subresource, dim.y, coord.y, m_PageTexelSize.y, m_TextureDim.y, subresourceImgDim.y);

RDCASSERT((dim.z % m_PageTexelSize.z) == 0 || (coord.z + dim.z == subresourceImgDim.z),

subresource, dim.z, coord.z, m_PageTexelSize.z, m_TextureDim.z, subresourceImgDim.z);

// convert coords and dim to pages for ease of calculation

Coord curCoord = coord;

curCoord.x /= m_PageTexelSize.x;

curCoord.y /= m_PageTexelSize.y;

curCoord.z /= m_PageTexelSize.z;

Coord curDim = dim;

curDim.x = RDCMAX((uint64_t)1ULL, (curDim.x + m_PageTexelSize.x - 1) / m_PageTexelSize.x);

curDim.y = RDCMAX((uint64_t)1ULL, (curDim.y + m_PageTexelSize.y - 1) / m_PageTexelSize.y);

curDim.z = RDCMAX((uint64_t)1ULL, (curDim.z + m_PageTexelSize.z - 1) / m_PageTexelSize.z);

RDCASSERT(subresource < m_Subresources.size(), subresource, m_Subresources.size());

RDCASSERT(curCoord.x < subresourcePageDim.x && curCoord.y < subresourcePageDim.y &&

curCoord.z < subresourcePageDim.z);

RDCASSERT(curCoord.x + curDim.x <= subresourcePageDim.x &&

curCoord.y + curDim.y <= subresourcePageDim.y &&

curCoord.z + curDim.z <= subresourcePageDim.z);

// if we're setting to NULL, set the offset to 0

if(memory == ResourceId())

memoryByteOffset = 0;

PageRangeMapping &sub = m_Subresources[subresource];

// if we're setting the whole subresource, set it to use the optimal single mapping

if(curCoord.x == 0 && curCoord.y == 0 && curCoord.z == 0 && curDim == subresourcePageDim)

{

sub.pages.clear();

sub.singleMapping.memory = memory;

sub.singleMapping.offset = memoryByteOffset;

sub.singlePageReused = useSinglePage;

}

else

{

// either we're starting at a coord somewhere into the subresource, or we don't cover it all.

// Split the subresource into pages if needed and update.

const uint64_t numSubresourcePages =

(subresourcePageDim.x * subresourcePageDim.y * subresourcePageDim.z);

sub.createPages(numSubresourcePages, m_PageByteSize);

for(uint64_t z = curCoord.z; z < curCoord.z + curDim.z; z++)

{

for(uint64_t y = curCoord.y; y < curCoord.y + curDim.y; y++)

{

for(uint64_t x = curCoord.x; x < curCoord.x + curDim.x; x++)

{

// calculate the page

const uint64_t page = calcPageForTileCoord({x, y, z}, subresourcePageDim);

sub.accessPage(page).memory = memory;

sub.accessPage(page).offset = memoryByteOffset;

// if we're not mapping all resource pages to a single memory page, advance the offset

if(!useSinglePage && memory != ResourceId())

memoryByteOffset += m_PageByteSize;

}

}

}

sub.simplifyUnmapped();

}

const Sparse::Coord &coord,

uint64_t byteSize, ResourceId memory,

uint64_t memoryByteOffset,

bool useSinglePage, bool updateMappings)

{

const bool allBytes = (byteSize == ~0U);

if(allBytes)

byteSize -= byteSize % m_PageByteSize;

RDCASSERT((byteSize % m_PageByteSize) == 0, byteSize, m_PageByteSize);

RDCASSERT(subresource < m_Subresources.size() || isSubresourceInMipTail(subresource), subresource,

m_Subresources.size());

Sparse::Coord curCoord = coord;

// if we're setting to NULL, set the offset to 0

if(memory == ResourceId())

memoryByteOffset = 0;

// loop while we still have bytes left, to allow wrapping over subresources

while(byteSize > 0 && (isSubresourceInMipTail(subresource) || subresource < m_Subresources.size()))

{

const Coord subresourcePageDim = calcSubresourcePageDim(subresource);

const uint64_t numMipTailPages =

uint64_t((m_MipTail.totalPackedByteSize / RDCMAX(1U, (uint32_t)m_MipTail.mappings.size())) +

m_PageByteSize - 1) /

m_PageByteSize;

const uint64_t numSubresourcePages =

isSubresourceInMipTail(subresource)

? numMipTailPages

: subresourcePageDim.x * subresourcePageDim.y * subresourcePageDim.z;

PageRangeMapping &sub = isSubresourceInMipTail(subresource) ? getMipTailMapping(subresource)

: m_Subresources[subresource];

const uint64_t subresourceByteSize = numSubresourcePages * m_PageByteSize;

// if we're setting the whole subresource, set it to use the optimal single mapping

if(curCoord.x == 0 && curCoord.y == 0 && curCoord.z == 0 && byteSize >= subresourceByteSize)

{

if(updateMappings)

{

sub.pages.clear();

sub.singleMapping.memory = memory;

sub.singleMapping.offset = memoryByteOffset;

sub.singlePageReused = useSinglePage;

}

// if we're not mapping all resource pages to a single memory page, advance the offset

if(!useSinglePage && memory != ResourceId())

memoryByteOffset += numSubresourcePages * m_PageByteSize;

byteSize -= subresourceByteSize;

// continue on the next subresource at {0,0,0}. If there are bytes remaining we'll loop and

// assign them

// if we're setting in the miptail right now, continue on at the next mip 0

if(isSubresourceInMipTail(subresource))

{

const uint32_t slice = subresource / m_MipCount;

subresource = (slice + 1) * m_MipCount;

}

else

{

subresource++;

curCoord = {0, 0, 0};

}

// since we know we consumed a whole subresource above, if we're done then we can return the

// correct reference to the next subresource at 0,0,0 here

if(byteSize == 0)

return {subresource, curCoord};

}

else

{

// either we're starting at a coord somewhere into the subresource, or we don't cover it all.

// Split the subresource into pages if needed and update.

if(updateMappings)

sub.createPages(numSubresourcePages, m_PageByteSize);

// note that numPages could be more pages than in the subresource! hence below we check both

// that we haven't exhausted the incoming pages and that we haven't exhausted the pages in the

// subresource

const uint64_t numPages = byteSize / m_PageByteSize;

if(isSubresourceInMipTail(subresource))

{

curCoord.x /= m_PageTexelSize.x;

curCoord.y = 0;

curCoord.z = 0;

}

else

{

// convert current co-ord to pages for calculation. We don't have to worry about doing this

// repeatedly because if we overlap into another subresource we start at 0,0,0

curCoord.x /= m_PageTexelSize.x;

curCoord.y /= m_PageTexelSize.y;

curCoord.z /= m_PageTexelSize.z;

}

// calculate the starting page

uint64_t startingPage =

(((curCoord.z * subresourcePageDim.y) + curCoord.y) * subresourcePageDim.x) + curCoord.x;

for(uint64_t page = startingPage;

page < startingPage + numPages && page < numSubresourcePages; page++)

{

if(updateMappings)

{

sub.accessPage(page).memory = memory;

sub.accessPage(page).offset = memoryByteOffset;

}

// if we're not mapping all resource pages to a single memory page, advance the offset

if(!useSinglePage && memory != ResourceId())

memoryByteOffset += m_PageByteSize;

byteSize -= m_PageByteSize;

}

if(updateMappings)

sub.simplifyUnmapped();

// if we consumed all bytes and didn't get to the end of the subresource, calculate where we

// ended up

if(byteSize == 0 && startingPage + numPages < numSubresourcePages)

{

if(isSubresourceInMipTail(subresource))

{

curCoord.x = (curCoord.x + numPages) * m_PageTexelSize.x;

}

else

{

// X we just increment by however many pages, wrapping by the row length in pages

curCoord.x = (curCoord.x + numPages) % subresourcePageDim.x;

// for Y we increment by however many *rows*, again wrapping

curCoord.y = (curCoord.y + numPages / subresourcePageDim.x) % subresourcePageDim.y;

// similarly for Z

curCoord.z = (curCoord.z + numPages / (subresourcePageDim.x * subresourcePageDim.y)) %

subresourcePageDim.z;

}

return {subresource, curCoord};

}

// continue on the next subresource at {0,0,0}. If there are bytes remaining we'll loop and

// assign them

// if we're setting in the miptail right now, continue on at the next mip 0

if(isSubresourceInMipTail(subresource))

{

const uint32_t slice = subresource / m_MipCount;

subresource = (slice + 1) * m_MipCount;

curCoord = {0, 0, 0};

}

else

{

subresource++;

curCoord = {0, 0, 0};

}

// if we got here we consumed the whole subresource and ended, so return that

if(byteSize == 0)

return {subresource, curCoord};

}

}

if(!allBytes && byteSize > 0)

RDCERR("Unclaimed bytes being assigned to image after iterating over all subresources");

return {0, {0, 0, 0}};

const Coord &dimInTiles, const PageTable &srcPageTable,

uint32_t srcSubresource, const Coord &srcCoordInTiles)

{

// this can only be used if pages are the same size, which is always true on D3D

RDCASSERT(getPageByteSize() == srcPageTable.getPageByteSize());

const bool srcMip = srcPageTable.isSubresourceInMipTail(srcSubresource);

const bool dstMip = isSubresourceInMipTail(dstSubresource);

// if we're copying between mip tails and the copy is completely contained in the mip tail on

// both sides of the copy

if(srcMip && dstMip &&

dimInTiles.x <= srcPageTable.getMipTailSliceSize() / srcPageTable.getPageByteSize() &&

dimInTiles.x <= getMipTailSliceSize() / getPageByteSize())

{

const Sparse::PageRangeMapping &srcMapping = srcPageTable.getMipTailMapping(srcSubresource);

// if the source has a single mapping, copy it and allow setMipTailRange to figure out if this

// is a single mapping in the destination or not

if(srcMapping.hasSingleMapping())

{

setMipTailRange(

getMipTailByteOffsetForSubresource(dstSubresource) + coordInTiles.x * m_PageByteSize,

srcMapping.singleMapping.memory,

srcMapping.singleMapping.offset + srcCoordInTiles.x * m_PageByteSize,

dimInTiles.x * m_PageByteSize, srcMapping.singlePageReused);

}

// otherwise we just do a page-by-page copy

else

{

uint64_t dstStartPage = coordInTiles.x;

uint64_t srcStartPage = srcCoordInTiles.x;

for(uint64_t pageIdx = 0; pageIdx < dimInTiles.x; pageIdx++)

{

Page srcPageContents = srcMapping.getPage(srcStartPage + pageIdx, m_PageByteSize);

setMipTailRange(dstStartPage * m_PageByteSize, srcPageContents.memory,

srcPageContents.offset, m_PageByteSize, false);

}

}

return;

}

Sparse::Coord srcSubSize = srcPageTable.calcSubresourcePageDim(srcSubresource);

Sparse::Coord dstSubSize = calcSubresourcePageDim(dstSubresource);

// if the region covers the destination subresource we might be able to take a shortcut

if(dstSubSize == dimInTiles)

{

// if the subresources are identical, just copy no matter what

if(srcSubSize == dstSubSize)

{

m_Subresources[dstSubresource] = srcPageTable.getSubresource(srcSubresource);

return;

}

// one more case - if the destination is completely covered by the region and the source is at

// least as big AND the source is a single page mapping, we can copy to a single page mapping.

// That's because the pages are the same they just wrap differently (e.g. in an original 8x8

// source the pages 0..7 form the first row and in the destination 4x4 those same pages are the

// first two rows, but that's exactly what this operation wants to do).

if(srcSubSize.x >= dimInTiles.x && srcSubSize.y >= dimInTiles.y && srcSubSize.z >= dimInTiles.z &&

srcPageTable.getSubresource(srcSubresource).hasSingleMapping())

{

m_Subresources[dstSubresource] = srcPageTable.getSubresource(srcSubresource);

return;

}

}

// in all other cases we fall back to a page-by-page copy from source to dest. This case means the

// box is a subset of the destination or the source isn't a nice single mapping so we need to copy

// pages one by one

// box regions are by definition constrained within a subresource. We assume it's

// constrained within both...

RDCASSERT(srcCoordInTiles.x + dimInTiles.x <= srcSubSize.x, srcCoordInTiles.x, dimInTiles.x,

srcSubSize.x);

RDCASSERT(srcCoordInTiles.y + dimInTiles.y <= srcSubSize.y, srcCoordInTiles.y, dimInTiles.x,

srcSubSize.y);

RDCASSERT(srcCoordInTiles.z + dimInTiles.z <= srcSubSize.z, srcCoordInTiles.z, dimInTiles.x,

srcSubSize.z);

RDCASSERT(coordInTiles.x + dimInTiles.x <= dstSubSize.x, coordInTiles.x, dimInTiles.x,

dstSubSize.x);

RDCASSERT(coordInTiles.y + dimInTiles.y <= dstSubSize.y, coordInTiles.y, dimInTiles.y,

dstSubSize.y);

RDCASSERT(coordInTiles.z + dimInTiles.z <= dstSubSize.z, coordInTiles.z, dimInTiles.z,

dstSubSize.z);

Sparse::PageRangeMapping &dstSub = m_Subresources[dstSubresource];

const Sparse::PageRangeMapping &srcSub = srcPageTable.getSubresource(srcSubresource);

dstSub.createPages(dstSubSize.x * dstSubSize.y * dstSubSize.z, m_PageByteSize);

for(uint64_t z = 0; z < dimInTiles.z; z++)

{

for(uint64_t y = 0; y < dimInTiles.y; y++)

{

for(uint64_t x = 0; x < dimInTiles.x; x++)

{

const uint64_t dstPage = calcPageForTileCoord(

{coordInTiles.x + x, coordInTiles.y + y, coordInTiles.z + z}, dstSubSize);

const uint64_t srcPage = calcPageForTileCoord(

{srcCoordInTiles.x + x, srcCoordInTiles.y + y, srcCoordInTiles.z + z}, srcSubSize);

dstSub.accessPage(dstPage) = srcSub.getPage(srcPage, m_PageByteSize);

}

}

}

dstSub.simplifyUnmapped();

uint64_t numTiles, const PageTable &srcPageTable,

uint32_t srcSubresource, const Coord &srcCoordInTiles)

{

// this can only be used if pages are the same size, which is always true on D3D

RDCASSERT(getPageByteSize() == srcPageTable.getPageByteSize());

const bool srcMip = srcPageTable.isSubresourceInMipTail(srcSubresource);

const bool dstMip = isSubresourceInMipTail(dstSubresource);

// if we're copying between mip tails and the copy is completely contained in the mip tail on

// both sides of the copy

if(srcMip && dstMip &&

numTiles <= srcPageTable.getMipTailSliceSize() / srcPageTable.getPageByteSize() &&

numTiles <= getMipTailSliceSize() / getPageByteSize())

{

const Sparse::PageRangeMapping &srcMapping = srcPageTable.getMipTailMapping(srcSubresource);

// if the source has a single mapping, copy it and allow setMipTailRange to figure out if this

// is a single mapping in the destination or not

if(srcMapping.hasSingleMapping())

{

setMipTailRange(

getMipTailByteOffsetForSubresource(dstSubresource) + coordInTiles.x * m_PageByteSize,

srcMapping.singleMapping.memory,

srcMapping.singleMapping.offset + srcCoordInTiles.x * m_PageByteSize,

numTiles * m_PageByteSize, srcMapping.singlePageReused);

}

// otherwise we just do a page-by-page copy

else

{

uint64_t dstStartPage = coordInTiles.x;

uint64_t srcStartPage = srcCoordInTiles.x;

for(uint64_t pageIdx = 0; pageIdx < numTiles; pageIdx++)

{

Page srcPageContents = srcMapping.getPage(srcStartPage + pageIdx, m_PageByteSize);

setMipTailRange(dstStartPage * m_PageByteSize, srcPageContents.memory,

srcPageContents.offset, m_PageByteSize, false);

}

}

return;

}

// in all other cases we fall back to a page-by-page copy from source to dest, overlapping pages

// linearly.

Sparse::Coord srcSubSize = srcPageTable.calcSubresourcePageDim(srcSubresource);

Sparse::Coord dstSubSize = calcSubresourcePageDim(dstSubresource);

const Sparse::PageRangeMapping *srcMapping = &srcPageTable.getSubresource(srcSubresource);

Sparse::PageRangeMapping *dstMapping = &m_Subresources[dstSubresource];

uint64_t dstPage =

calcPageForTileCoord({coordInTiles.x, coordInTiles.y, coordInTiles.z}, dstSubSize);

uint64_t srcPage =

calcPageForTileCoord({srcCoordInTiles.x, srcCoordInTiles.y, srcCoordInTiles.z}, srcSubSize);

for(uint64_t i = 0; i < numTiles;)

{

const uint64_t remainingTiles = numTiles - i;

const uint64_t dstSubTiles = (dstSubSize.x * dstSubSize.y * dstSubSize.z);

const uint64_t srcSubTiles = (srcSubSize.x * srcSubSize.y * srcSubSize.z);

// if we currently have enough tiles remaining to update the whole next resource and we're

// pointing at 0,0,0 and our source range is a single mapping, copy that single mapping.

if(dstPage == 0 && dstSubTiles <= remainingTiles && srcMapping->hasSingleMapping() &&

dstSubTiles <= srcSubTiles - srcPage)

{

// as above, the tiles may wrap differently in the destination mapping but that's how we want

// it to be

*dstMapping = *srcMapping;

// increment by how many tiles we consumed

srcPage += dstSubTiles;

dstPage += dstSubTiles;

i += dstSubTiles;

}

else

{

// otherwise just copy the current page

dstMapping->createPages(dstSubTiles, m_PageByteSize);

dstMapping->accessPage(dstPage) = srcMapping->getPage(srcPage, m_PageByteSize);

dstPage++;

srcPage++;

i++;

}

if(i >= numTiles)

break;

// wrap the destination and source to the next page in the next subresource if we've used all

// the ones up

if(srcPage >= srcSubTiles)

{

// start at page 0 in the next subresource

srcPage = 0;

// if we were in the mip tail, jump all the way to the next mip0, otherwise we just move to

// the next subresource

if(isSubresourceInMipTail(srcSubresource))

{

const uint32_t slice = srcSubresource / srcPageTable.getMipCount();

srcSubresource = (slice + 1) * srcPageTable.getMipCount();

}

else

{

srcSubresource++;

}

// update subresource properties for the new current subresource

srcSubSize = srcPageTable.calcSubresourcePageDim(srcSubresource);

srcMapping = &srcPageTable.getSubresource(srcSubresource);

}

if(dstPage >= dstSubTiles)

{

// start at page 0 in the next subresource

dstPage = 0;

// if we were in the mip tail, jump all the way to the next mip0, otherwise we just move to

// the next subresource

if(isSubresourceInMipTail(dstSubresource))

{

const uint32_t slice = dstSubresource / m_MipCount;

dstSubresource = (slice + 1) * m_MipCount;

}

else

{

dstSubresource++;

}

// simplify the mapping before we move on

dstMapping->simplifyUnmapped();

dstSubSize = calcSubresourcePageDim(dstSubresource);

dstMapping = &m_Subresources[dstSubresource];

}

if(srcSubresource >= srcPageTable.getNumSubresources())

{

dstMapping->simplifyUnmapped();

RDCERR(

"Number of tiles %u in image wrapped range copy exceeded source page table subresource "

"count %u",

numTiles, srcPageTable.getNumSubresources());

return;

}

if(dstSubresource >= getNumSubresources())

{

dstMapping->simplifyUnmapped();

RDCERR(

"Number of tiles %u in image wrapped range copy exceeded dest page table subresource "

"count %u",

numTiles, getNumSubresources());

return;

}

}

// simplify the last mapping we were working on

if(dstMapping < m_Subresources.end())

dstMapping->simplifyUnmapped();

{

const uint32_t mipLevel = subresource % m_MipCount;

return {

RDCMAX((uint64_t)1ULL, m_TextureDim.x >> mipLevel),

RDCMAX((uint64_t)1ULL, m_TextureDim.y >> mipLevel),

RDCMAX((uint64_t)1ULL, m_TextureDim.z >> mipLevel),

};

{

const Coord mipDim = getSubresourceDim(subresource);

// for each page that is fully or partially used

return {RDCMAX((uint64_t)1ULL, (mipDim.x + m_PageTexelSize.x - 1) / m_PageTexelSize.x),

RDCMAX((uint64_t)1ULL, (mipDim.y + m_PageTexelSize.y - 1) / m_PageTexelSize.y),

RDCMAX((uint64_t)1ULL, (mipDim.z + m_PageTexelSize.z - 1) / m_PageTexelSize.z)};

{

uint64_t ret = 0;

// size of the pair itself

ret += sizeof(*this);

// for each mip tail region

for(uint32_t s = 0; s < getMipTail().mappings.size(); s++)

{

ret += sizeof(Sparse::PageRangeMapping);

// and the size of each page if the range mapping is expanded

if(!getMipTail().mappings[s].hasSingleMapping())

ret += sizeof(Sparse::Page) * getMipTail().mappings[s].pages.size();

}

// for each subresource the size of it

for(uint32_t s = 0; s < getNumSubresources(); s++)

{

ret += sizeof(Sparse::PageRangeMapping);

// and the size of each page if the range mapping is expanded

if(!getSubresource(s).hasSingleMapping())

ret += sizeof(Sparse::Page) * getSubresource(s).pages.size();

}

return ret;

{

if(ser.VersionAtLeast(0x20))

{

SERIALISE_MEMBER(x);

SERIALISE_MEMBER(y);

SERIALISE_MEMBER(z);

}

else

{

// older co-ords were 32-bit.

RDCASSERT(ser.IsReading());

SERIALISE_ELEMENT_LOCAL(x, uint32_t(0));

SERIALISE_ELEMENT_LOCAL(y, uint32_t(0));

SERIALISE_ELEMENT_LOCAL(z, uint32_t(0));

el.x = x;

el.y = y;

el.z = z;

}

{

SERIALISE_MEMBER(memory);

SERIALISE_MEMBER(offset).OffsetOrSize();

{

SERIALISE_MEMBER(singleMapping);

SERIALISE_MEMBER(pages);

{

SERIALISE_MEMBER(firstMip);

SERIALISE_MEMBER(byteOffset).OffsetOrSize();

SERIALISE_MEMBER(byteStride).OffsetOrSize();

SERIALISE_MEMBER(totalPackedByteSize).OffsetOrSize();

SERIALISE_MEMBER(mappings);

{

SERIALISE_MEMBER(m_TextureDim);

SERIALISE_MEMBER(m_MipCount);

SERIALISE_MEMBER(m_ArraySize);

SERIALISE_MEMBER(m_PageByteSize).OffsetOrSize();

SERIALISE_MEMBER(m_PageTexelSize);

SERIALISE_MEMBER(m_Subresources);

SERIALISE_MEMBER(m_MipTail);