public static void WriteTexture(NvGpuVmm vmm, GalImage image, long position, byte[] data)
{
ISwizzle swizzle = TextureHelper.GetSwizzle(image);
ImageDescriptor desc = GetImageDescriptor(image.Format);
(int width, int height, int depth) = GetImageSizeInBlocks(image);
int bytesPerPixel = desc.BytesPerPixel;
int inOffs = 0;
for (int z = 0; z < depth; z++)
{
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
long offset = (uint)swizzle.GetSwizzleOffset(x, y, z);
vmm.Memory.WriteBytes(position + offset, data, inOffs, bytesPerPixel);
inOffs += bytesPerPixel;
}
}
}
}
public static int GetLayerOffset(GalImage image, int mipLevel)
{
if (mipLevel <= 0)
{
mipLevel = 1;
}
return(TextureHelper.GetSwizzle(image).GetMipOffset(mipLevel));
}
public static byte[] ReadTexture(IMemory memory, GalImage image, long position)
{
MemoryManager cpuMemory;
if (memory is NvGpuVmm vmm)
{
cpuMemory = vmm.Memory;
}
else
{
cpuMemory = (MemoryManager)memory;
}
ISwizzle swizzle = TextureHelper.GetSwizzle(image);
ImageDescriptor desc = GetImageDescriptor(image.Format);
(int width, int height, int depth) = GetImageSizeInBlocks(image);
int bytesPerPixel = desc.BytesPerPixel;
//Note: Each row of the texture needs to be aligned to 4 bytes.
int pitch = (width * bytesPerPixel + 3) & ~3;
int dataLayerSize = height * pitch * depth;
byte[] data = new byte[dataLayerSize * image.LayerCount];
int targetMipLevel = image.MaxMipmapLevel <= 1 ? 1 : image.MaxMipmapLevel - 1;
int layerOffset = GetLayerOffset(image, targetMipLevel);
for (int layer = 0; layer < image.LayerCount; layer++)
{
for (int z = 0; z < depth; z++)
{
for (int y = 0; y < height; y++)
{
int outOffs = (dataLayerSize * layer) + y * pitch + (z * width * height * bytesPerPixel);
for (int x = 0; x < width; x++)
{
long offset = (uint)swizzle.GetSwizzleOffset(x, y, z);
cpuMemory.ReadBytes(position + (layerOffset * layer) + offset, data, outOffs, bytesPerPixel);
outOffs += bytesPerPixel;
}
}
}
}
return(data);
}
public static byte[] ReadTexture(IMemory Memory, GalImage Image, long Position)
{
MemoryManager CpuMemory;
if (Memory is NvGpuVmm Vmm)
{
CpuMemory = Vmm.Memory;
}
else
{
CpuMemory = (MemoryManager)Memory;
}
ISwizzle Swizzle = TextureHelper.GetSwizzle(Image);
ImageDescriptor Desc = GetImageDescriptor(Image.Format);
(int Width, int Height) = GetImageSizeInBlocks(Image);
int BytesPerPixel = Desc.BytesPerPixel;
//Note: Each row of the texture needs to be aligned to 4 bytes.
int Pitch = (Width * BytesPerPixel + 3) & ~3;
byte[] Data = new byte[Height * Pitch];
for (int Y = 0; Y < Height; Y++)
{
int OutOffs = Y * Pitch;
for (int X = 0; X < Width; X++)
{
long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
CpuMemory.ReadBytes(Position + Offset, Data, OutOffs, BytesPerPixel);
OutOffs += BytesPerPixel;
}
}
return(Data);
}
public static bool CopyTexture(
NvGpuVmm Vmm,
GalImage SrcImage,
GalImage DstImage,
long SrcAddress,
long DstAddress,
int SrcX,
int SrcY,
int DstX,
int DstY,
int Width,
int Height)
{
ISwizzle SrcSwizzle = TextureHelper.GetSwizzle(SrcImage);
ISwizzle DstSwizzle = TextureHelper.GetSwizzle(DstImage);
ImageDescriptor Desc = GetImageDescriptor(SrcImage.Format);
if (GetImageDescriptor(DstImage.Format).BytesPerPixel != Desc.BytesPerPixel)
{
return(false);
}
int BytesPerPixel = Desc.BytesPerPixel;
for (int Y = 0; Y < Height; Y++)
{
for (int X = 0; X < Width; X++)
{
long SrcOffset = (uint)SrcSwizzle.GetSwizzleOffset(SrcX + X, SrcY + Y);
long DstOffset = (uint)DstSwizzle.GetSwizzleOffset(DstX + X, DstY + Y);
byte[] Texel = Vmm.ReadBytes(SrcAddress + SrcOffset, BytesPerPixel);
Vmm.WriteBytes(DstAddress + DstOffset, Texel);
}
}
return(true);
}
// TODO: Support non 2D
public static bool CopyTexture(
NvGpuVmm vmm,
GalImage srcImage,
GalImage dstImage,
long srcAddress,
long dstAddress,
int srcX,
int srcY,
int dstX,
int dstY,
int width,
int height)
{
ISwizzle srcSwizzle = TextureHelper.GetSwizzle(srcImage);
ISwizzle dstSwizzle = TextureHelper.GetSwizzle(dstImage);
ImageDescriptor desc = GetImageDescriptor(srcImage.Format);
if (GetImageDescriptor(dstImage.Format).BytesPerPixel != desc.BytesPerPixel)
{
return(false);
}
int bytesPerPixel = desc.BytesPerPixel;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
long srcOffset = (uint)srcSwizzle.GetSwizzleOffset(srcX + x, srcY + y, 0);
long dstOffset = (uint)dstSwizzle.GetSwizzleOffset(dstX + x, dstY + y, 0);
byte[] texel = vmm.ReadBytes(srcAddress + srcOffset, bytesPerPixel);
vmm.WriteBytes(dstAddress + dstOffset, texel);
}
}
return(true);
}
public static byte[] ReadTexture(IAMemory Memory, GalImage Image, long Position)
{
AMemory CpuMemory;
if (Memory is NvGpuVmm Vmm)
{
CpuMemory = Vmm.Memory;
}
else
{
CpuMemory = (AMemory)Memory;
}
ISwizzle Swizzle = TextureHelper.GetSwizzle(Image);
ImageDescriptor Desc = GetImageDescriptor(Image.Format);
(int Width, int Height) = GetImageSizeInBlocks(Image);
int BytesPerPixel = Desc.BytesPerPixel;
int OutOffs = 0;
byte[] Data = new byte[Width * Height * BytesPerPixel];
for (int Y = 0; Y < Height; Y++)
{
for (int X = 0; X < Width; X++)
{
long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
CpuMemory.ReadBytes(Position + Offset, Data, OutOffs, BytesPerPixel);
OutOffs += BytesPerPixel;
}
}
return(Data);
}
public static void WriteTexture(NvGpuVmm Vmm, GalImage Image, long Position, byte[] Data)
{
ISwizzle Swizzle = TextureHelper.GetSwizzle(Image);
ImageDescriptor Desc = GetImageDescriptor(Image.Format);
(int Width, int Height) = ImageUtils.GetImageSizeInBlocks(Image);
int BytesPerPixel = Desc.BytesPerPixel;
int InOffs = 0;
for (int Y = 0; Y < Height; Y++)
{
for (int X = 0; X < Width; X++)
{
long Offset = (uint)Swizzle.GetSwizzleOffset(X, Y);
Vmm.Memory.WriteBytes(Position + Offset, Data, InOffs, BytesPerPixel);
InOffs += BytesPerPixel;
}
}
}
public static int GetGpuSize(GalImage image, bool forcePitch = false)
{
return(TextureHelper.GetSwizzle(image).GetImageSize(image.MaxMipmapLevel) * image.LayerCount);
}
