com.hikky.vketcloudsdk 3.2.4

package/PackageResources/tools/VRMScrambler/Source/Independent/GraphCommon/CSurface.cpp

@@ -0,0 +1,698 @@
+///////////////////////////////////////////////////////////////////////////////
+//  CSurface.cpp
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <algorithm>
+
+#ifndef __EMSCRIPTEN__
+#include "../../Independent/CGDecoder/CDecodePNG.h"
+#endif
+
+#include "../../Independent/CGDecoder/ECGFormat.h"
+#include "../../Independent/Memory/PointerAlignment.h"
+#include "../../Specific/Debug/LMsg.h"
+#include "../../Specific/FileSystem/CFile.h"
+#include "../../Library/libpng/png.h"
+#include "CSurface.h"
+
+namespace gcommon {
+
+CSurface::CSurface(void) :
+m_nWidth(0),
+m_nHeight(0),
+m_nBpp(0),
+m_nBypp(0),
+m_nPitch(0),
+m_bExistPixel(false),
+m_bExistAlpha(false),
+m_pPixel(nullptr)
+{
+}
+
+CSurface::~CSurface()
+{
+	Free();
+}
+
+// IInterface
+int CSurface::AddRef(void)
+{
+	return m_RefCounter.AddRef();
+}
+
+int CSurface::Release(void)
+{
+	const int Result = m_RefCounter.Release();
+	if (Result <= 0) delete this;
+	return Result;
+}
+
+// ISurface
+unsigned char* CSurface::GetPixel(int nX, int nY)
+{
+	return m_pPixel + nY * m_nPitch + nX * m_nBypp;
+}
+
+unsigned char* CSurface::GetAlpha(int nX, int nY)
+{
+	return nullptr;
+}
+
+int CSurface::GetWidth(void)
+{
+	return m_nWidth;
+}
+
+int CSurface::GetHeight(void)
+{
+	return m_nHeight;
+}
+
+int CSurface::GetBpp(void)
+{
+	return m_nBpp;
+}
+
+int CSurface::GetPitch(void)
+{
+	return m_nPitch;
+}
+
+int CSurface::GetAlphaPitch(void)
+{
+	return 0;
+}
+
+bool CSurface::ExistPixel(void)
+{
+	return m_bExistPixel;
+}
+
+bool CSurface::ExistAlpha(void)
+{
+	return m_bExistAlpha;
+}
+
+// �쐬
+bool CSurface::Create(int nWidth, int nHeight, int nBpp)
+{
+	if (nBpp != 8 && nBpp != 16 && nBpp != 32 && nBpp != 64) return false;
+	if (nWidth <= 0 || nHeight <= 0) return false;
+
+	// 16�o�C�g���E�ɍ��킹��
+	m_nPitch = static_cast<int>(memory::AlignSize16byte(nWidth * (nBpp / 8)));
+
+	// �s�N�Z���������̊m��
+	const int nPadding = 16 + 8 + 16;		// �A�h���X���E���킹���l�l�w�I�[�o�[�����p
+
+	m_PixelMemory.resize(m_nPitch * nHeight + nPadding);
+
+	// �A�h���X���E���킹
+	m_pPixel = reinterpret_cast<unsigned char*>(memory::AlignPointer8byte(&m_PixelMemory[0]));
+
+	//
+	m_nWidth = nWidth;
+	m_nHeight = nHeight;
+	m_nBpp = nBpp;
+	m_nBypp = nBpp / 8;
+
+	m_bExistPixel = true;
+	m_bExistAlpha = ((nBpp == 32) || (nBpp == 64));
+
+	return true;
+}
+
+bool CSurface::CreatePixelOnly(int nWidth, int nHeight, int nBpp)
+{
+	if (nBpp != 8 && nBpp != 16 && nBpp != 32 && nBpp != 64) return false;
+	if (nWidth <= 0 || nHeight <= 0) return false;
+
+	// 16�o�C�g���E�ɍ��킹��
+	m_nPitch = static_cast<int>(memory::AlignSize16byte(nWidth * (nBpp / 8)));
+
+	// �s�N�Z���������̊m��
+	const int nPadding = 16 + 8 + 16;		// �A�h���X���E���킹���l�l�w�I�[�o�[�����p
+
+	m_PixelMemory.resize(m_nPitch * nHeight + nPadding);
+
+	// �A�h���X���E���킹
+	m_pPixel = reinterpret_cast<unsigned char*>(memory::AlignPointer8byte(&m_PixelMemory[0]));
+
+	//
+	m_nWidth = nWidth;
+	m_nHeight = nHeight;
+	m_nBpp = nBpp;
+	m_nBypp = nBpp / 8;
+
+	m_bExistPixel = true;
+	m_bExistAlpha = false;
+
+	return true;
+}
+
+bool CSurface::CreateAlphaOnly(int nWidth, int nHeight)
+{
+	if (nWidth <= 0 || nHeight <= 0) return false;
+
+	const int nBpp = 32;
+
+	// 16�o�C�g���E�ɍ��킹��
+	m_nPitch = static_cast<int>(memory::AlignSize16byte(nWidth * (nBpp / 8)));
+
+	// �s�N�Z���������̊m��
+	const int nPadding = 16 + 8 + 16;		// �A�h���X���E���킹���l�l�w�I�[�o�[�����p
+
+	m_PixelMemory.resize(m_nPitch * nHeight + nPadding);
+
+	// �A�h���X���E���킹
+	m_pPixel = reinterpret_cast<unsigned char*>(memory::AlignPointer8byte(&m_PixelMemory[0]));
+
+	//
+	m_nWidth = nWidth;
+	m_nHeight = nHeight;
+	m_nBpp = nBpp;
+	m_nBypp = nBpp / 8;
+
+	m_bExistPixel = false;
+	m_bExistAlpha = true;
+
+	return true;
+}
+
+//
+void CSurface::Free()
+{
+	m_PixelMemory.clear();
+	m_PixelMemory.shrink_to_fit();
+
+	m_nWidth = 0;
+	m_nHeight = 0;
+	m_nBpp = 0;
+	m_nBypp = 0;
+	m_nPitch = 0;
+	m_bExistPixel = false;
+	m_bExistAlpha = false;
+	m_pPixel = nullptr;
+}
+
+// �ǂݍ���
+ISurface* CSurface::LoadCG(const std::string& FileName)
+{
+#ifdef __EMSCRIPTEN__
+	return nullptr;
+#else
+	// �t�@�C���ǂݍ���
+	std::string Path = FileName;
+	std::replace(Path.begin(), Path.end(), '/', '\\');
+
+	std::vector<unsigned char> Data;
+	if (!filesystem::CFile::ReadImage(Data, Path)) return nullptr;
+	if (Data.empty()) return nullptr;
+
+	//
+	return LoadCGFromMemory(&Data[0], static_cast<unsigned int>(Data.size()));
+#endif
+}
+
+ISurface* CSurface::LoadCG(const std::string& PixelFileName, const std::string& AlphaFileName)
+{
+	ISurface* pIPixelSurface = LoadCG(PixelFileName);
+	if (!pIPixelSurface) return nullptr;
+
+	ISurface* pIAlphaSurface = LoadCG(AlphaFileName);
+	if (!pIAlphaSurface) {
+		pIPixelSurface->Release();
+		return nullptr;
+	}
+
+	if (!pIPixelSurface->ExistPixel() || !pIAlphaSurface->ExistPixel() ||
+		(pIPixelSurface->GetWidth() != pIAlphaSurface->GetWidth()) ||
+		(pIPixelSurface->GetHeight() != pIAlphaSurface->GetHeight()))
+	{
+		pIAlphaSurface->Release();
+		pIPixelSurface->Release();
+		return nullptr;
+	}
+
+	const int Width = pIPixelSurface->GetWidth();
+	const int Height = pIPixelSurface->GetHeight();
+
+	CSurface* pSurface = new CSurface();
+	if (!pSurface->Create(Width, Height, 32)) {
+		pIAlphaSurface->Release();
+		pIPixelSurface->Release();
+		return nullptr;
+	}
+
+	unsigned char* pDest = pSurface->GetPixel(0, 0);
+	const int DestNextLine = pSurface->GetPitch() - Width * 4;
+
+	const unsigned char* pPixel = pIPixelSurface->GetPixel(0, 0);
+	const int PixelNextLine = pIPixelSurface->GetPitch() - Width * 4;
+
+	const unsigned char* pAlpha = pIAlphaSurface->GetPixel(0, 0);
+	const int AlphaNextLine = pIAlphaSurface->GetPitch() - Width * 4;
+
+	for (int Y = 0; Y < Height; Y++) {
+		for (int X = 0; X < Width; X++) {
+			pDest[0] = pPixel[0];
+			pDest[1] = pPixel[1];
+			pDest[2] = pPixel[2];
+			pDest[3] = pAlpha[0];
+
+			pDest += 4;
+			pPixel += 4;
+			pAlpha += 4;
+		}
+
+		pDest += DestNextLine;
+		pPixel += PixelNextLine;
+		pAlpha += AlphaNextLine;
+	}
+
+	pIAlphaSurface->Release();
+	pIPixelSurface->Release();
+
+	return static_cast<ISurface*>(pSurface);
+}
+
+ISurface* CSurface::LoadCGFromMemory(const unsigned char* pData, unsigned int Size)
+{
+#ifdef __EMSCRIPTEN__
+	return nullptr;
+#else
+	// �t�@�C���t�H�[�}�b�g����
+	const cgdecoder::ECGFormat CGFormat = AnalyzeFormat(pData, static_cast<int>(Size));
+
+	switch (CGFormat) {
+	case cgdecoder::CGFORMAT_PNG:
+		return cgdecoder::CDecodePNG().Decode(pData, static_cast<int>(Size));
+
+	default:
+		debug::Output("unsupported cg format\n");
+		return nullptr;
+	}
+#endif
+}
+
+//
+bool CSurface::SaveBMP(const std::string& FileName) const
+{
+#ifdef WIN32
+	const int SizeImage = m_nPitch * m_nHeight * 3;
+
+	std::vector<unsigned char> FileImage(sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + SizeImage);
+
+	// BITMAPFILEHADER
+	BITMAPFILEHEADER* pBitmapFileHeader = reinterpret_cast<BITMAPFILEHEADER*>(&FileImage[0]);
+
+	pBitmapFileHeader->bfType = MAKEWORD(BYTE('B'), BYTE('M'));
+	pBitmapFileHeader->bfSize = static_cast<DWORD>(FileImage.size());
+	pBitmapFileHeader->bfReserved1 = 0;
+	pBitmapFileHeader->bfReserved2 = 0;
+	pBitmapFileHeader->bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+
+	// BITMAPINFOHEADER
+	BITMAPINFOHEADER* pBitmapInfoHeader = reinterpret_cast<BITMAPINFOHEADER*>(&FileImage[0] + sizeof(BITMAPFILEHEADER));
+
+	pBitmapInfoHeader->biSize = sizeof(BITMAPINFOHEADER);
+	pBitmapInfoHeader->biWidth = m_nWidth;
+	pBitmapInfoHeader->biHeight = m_nHeight;
+	pBitmapInfoHeader->biPlanes = 1;
+	pBitmapInfoHeader->biBitCount = 24;
+	pBitmapInfoHeader->biCompression = BI_RGB;
+	pBitmapInfoHeader->biSizeImage = SizeImage;
+	pBitmapInfoHeader->biXPelsPerMeter = 0;
+	pBitmapInfoHeader->biYPelsPerMeter = 0;
+	pBitmapInfoHeader->biClrUsed = 0;
+	pBitmapInfoHeader->biClrImportant = 0;
+
+	//
+	unsigned char* pDest = &FileImage[0] + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
+	const int DestNextLine = 0;
+
+	if (m_nBpp == 32) {
+		const unsigned char* pSrc = m_pPixel + (m_nHeight - 1) * m_nPitch;
+		const int SrcNextLine = -m_nPitch - m_nWidth * m_nBpp / 8;
+
+		for (int Y = 0; Y < m_nHeight; Y++) {
+			for (int X = 0; X < m_nWidth; X++) {
+				pDest[0] = pSrc[2];
+				pDest[1] = pSrc[1];
+				pDest[2] = pSrc[0];
+
+				pDest += 3;
+				pSrc += 4;
+			}
+
+			pDest += DestNextLine;
+			pSrc += SrcNextLine;
+		}
+	}
+	else if (m_nBpp == 64) {
+		const unsigned char* pSrc = m_pPixel + (m_nHeight - 1) * m_nPitch;
+		const int SrcNextLine = -m_nPitch - m_nWidth * m_nBpp / 8;
+
+		for (int Y = 0; Y < m_nHeight; Y++) {
+			for (int X = 0; X < m_nWidth; X++) {
+				const unsigned int Depth = ((static_cast<unsigned int>(pSrc[1]) << 24) | (static_cast<unsigned int>(pSrc[0]) << 16));
+//				float DepthF = *reinterpret_cast<const float*>(&Depth);
+//				const unsigned char Depth8 = static_cast<unsigned char>(DepthF * 255.0f);
+
+				const unsigned char Depth8 = static_cast<unsigned char>(255 * (Depth >> 16) / 65535);
+
+				pDest[0] = Depth8;
+				pDest[1] = Depth8;
+				pDest[2] = Depth8;
+
+				pDest += 3;
+				pSrc += 8;
+			}
+
+			pDest += DestNextLine;
+			pSrc += SrcNextLine;
+		}
+	}
+
+	//
+	if (!filesystem::CFile::WriteImage(FileImage, FileName)) return false;
+#else
+	return false;
+#endif
+	return true;
+}
+
+bool CSurface::SavePNG(const std::string& FileName) const
+{
+	int row_size;
+	int color_type;
+	png_structp png = NULL;
+	png_infop info = NULL;
+	png_bytepp rows = NULL;
+	//	png_colorp palette = NULL;
+
+	color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+	row_size = sizeof(png_byte) * m_nWidth * 4;
+
+	png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+	if (!png) return false;
+
+	info = png_create_info_struct(png);
+	if (!info) return false;
+
+	setjmp(png_jmpbuf(png));
+
+	FILE* fp = fopen(FileName.c_str(), "wb");
+	if (!fp) return false;
+
+	png_init_io(png, fp);
+
+	png_set_IHDR(png, info, m_nWidth, m_nHeight, 8,
+		color_type, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
+		PNG_FILTER_TYPE_DEFAULT);
+
+	rows = reinterpret_cast<png_bytepp>(png_malloc(png, sizeof(png_bytep) * m_nHeight));
+
+	png_set_rows(png, info, rows);
+	memset(rows, 0, sizeof(png_bytep) * m_nHeight);
+
+	for (int y = 0; y < m_nHeight; y++) {
+		if ((rows[y] = reinterpret_cast<png_bytep>(png_malloc(png, row_size))) == NULL) {
+			return false;
+		}
+	}
+
+	for (int y = 0; y < m_nHeight; y++) {
+		png_bytep row = rows[y];
+		for (int x = 0; x < m_nWidth; x++) {
+			*row++ = GetPixel(x, y)[0];
+			*row++ = GetPixel(x, y)[1];
+			*row++ = GetPixel(x, y)[2];
+			*row++ = GetPixel(x, y)[3];
+		}
+	}
+
+	png_write_png(png, info, PNG_TRANSFORM_IDENTITY, NULL);
+
+	if (rows != NULL) {
+		for (int y = 0; y < m_nHeight; y++) {
+			png_free(png, rows[y]);
+		}
+		png_free(png, rows);
+	}
+	png_destroy_write_struct(&png, &info);
+
+	fclose(fp);
+
+	return true;
+}
+
+//
+void CSurface::Fill(int R, int G, int B, int A)
+{
+	if (!ExistPixel()) return;
+	if (GetBpp() != 32) return;
+
+	const unsigned char ColorB = static_cast<unsigned char>(B);
+	const unsigned char ColorG = static_cast<unsigned char>(G);
+	const unsigned char ColorR = static_cast<unsigned char>(R);
+	const unsigned char ColorA = static_cast<unsigned char>(A);
+
+	unsigned char* pDest = GetPixel(0, 0);
+	const int DestNextLine = GetPitch() - m_nWidth * 4;
+
+	for (int Y = 0; Y < m_nHeight; Y++) {
+		for (int X = 0; X < m_nWidth; X++) {
+			pDest[0] = ColorB;
+			pDest[1] = ColorG;
+			pDest[2] = ColorR;
+			pDest[3] = ColorA;
+
+			pDest += 4;
+		}
+
+		pDest += DestNextLine;
+	}
+}
+
+void CSurface::MakeGrayscaleFromA()
+{
+	if (!ExistPixel()) return;
+	if (GetBpp() != 32) return;
+
+	unsigned char* pDest = GetPixel(0, 0);
+	const int DestNextLine = GetPitch() - m_nWidth * 4;
+
+	for (int Y = 0; Y < m_nHeight; Y++) {
+		for (int X = 0; X < m_nWidth; X++) {
+			pDest[0] = pDest[3];
+			pDest[1] = pDest[3];
+			pDest[2] = pDest[3];
+
+			pDest += 4;
+		}
+
+		pDest += DestNextLine;
+	}
+}
+
+//
+void CSurface::Copy(ISurface* pDestSurface, int nDx, int nDy, ISurface* pSrcSurface, int nSx, int nSy, int nWidth, int nHeight)
+{
+	unsigned char* pbyDest = pDestSurface->GetPixel(nDx, nDy);
+	const unsigned char* pbySrc = pSrcSurface->GetPixel(nSx, nSy);
+
+	const int nDestNextLine = pDestSurface->GetPitch() - nWidth * 4;
+	const int nSrcNextLine = pSrcSurface->GetPitch() - nWidth * 4;
+
+	for (int nY = 0; nY < nHeight; nY++) {
+		for (int nX = 0; nX < nWidth; nX++) {
+			pbyDest[0] = pbySrc[0];
+			pbyDest[1] = pbySrc[1];
+			pbyDest[2] = pbySrc[2];
+
+			pbyDest += 4;
+			pbySrc += 4;
+		}
+
+		pbyDest += nDestNextLine;
+		pbySrc += nSrcNextLine;
+	}
+}
+
+void CSurface::CopyReduceWithAlphaMap(ISurface* pDestSurface, int nDx, int nDy, int nDWidth, int nDHeight, ISurface* pSrcSurface,
+	int nSx, int nSy, int nSWidth, int nSHeight)
+{
+	if (pDestSurface->GetBpp() != 32) return;
+	if (pSrcSurface->GetBpp() != 32) return;
+
+	unsigned char* pbyDest = pDestSurface->GetPixel(nDx, nDy);
+	unsigned char* pbySrc = pSrcSurface->GetPixel(nSx, nSy);
+	int nDestNextLine = pDestSurface->GetPitch() - nDWidth * 4;
+	int nSrcPitch = pSrcSurface->GetPitch();
+
+	int nPixelSize = nSWidth * nSHeight;
+
+	const int nWidth0 = nSWidth;
+	const int nHeight0 = nSHeight;
+
+	// �e�[�u��
+	std::vector<int> anStarti(nDWidth);
+	for (int i = 0; i < static_cast<int>(anStarti.size()); i++) {
+		anStarti[i] = i * nSWidth / nDWidth;
+	}
+
+	std::vector<int> anEndi(nDWidth);
+	for (int i = 0; i < static_cast<int>(anEndi.size()); i++) {
+		anEndi[i] = (i * nSWidth + nWidth0) / nDWidth + 1;
+	}
+
+	for (int nY = 0; nY < nDHeight; nY++) {
+		const int nY0 = nY * nSHeight;
+		const int nStartj = nY0 / nDHeight;
+		const int nEndj = (nY0 + nHeight0) / nDHeight + 1;
+
+		const int nStartY1_ = nStartj * nDHeight;
+		const unsigned char* pbyStartSrc0 = pbySrc + nStartj * nSrcPitch;
+
+		for (int nX = 0; nX < nDWidth; nX++) {
+			int nB = 0,
+				nG = 0,
+				nR = 0,
+				nA = 0;
+
+			// �`���`
+			int nX0 = nX * nSWidth;
+			//			const int nStarti = nX0 / nDWidth;
+			//			const int nStarti = (nX * nSWidth) / nDWidth;
+			const int nStarti = anStarti[nX];
+			//			const int nEndi = (nX0 + nWidth0) / nDWidth + 1;
+			//			const int nEndi = (nX * nSWidth + nWidth0) / nDWidth + 1;
+			const int nEndi = anEndi[nX];
+
+			//			int nY1_ = nStartj * nDHeight;
+			int nY1_ = nStartY1_;
+
+			//			unsigned char* pbySrc0 = pbySrc + nStartj * nSrcPitch;
+			const unsigned char* pbySrc0 = pbyStartSrc0;
+
+			for (int j = nStartj; j < nEndj; j++) {
+				int nY1 = nY1_;
+				int nHeight1 = nDHeight;
+				nY1_ += nDHeight;
+
+				// �N���b�s���O
+				if (nY1 < nY0) {
+					nHeight1 -= nY0 - nY1;
+					nY1 = nY0;
+				}
+				if (nY1 + nHeight1 > nY0 + nHeight0) {
+					nHeight1 = nY0 + nHeight0 - nY1;
+					if (nHeight1 <= 0) continue;
+				}
+
+				const unsigned char* pbySrc0Temp = pbySrc0;
+				pbySrc0 += nStarti * 4;
+
+				int nX1_ = nStarti * nDWidth;
+				for (int i = nStarti; i < nEndi; i++) {
+					int nX1 = nX1_;
+					int nWidth1 = nDWidth;
+					nX1_ += nDWidth;
+
+					// �N���b�s���O
+					if (nX1 < nX0) {
+						nWidth1 -= nX0 - nX1;
+						nX1 = nX0;
+					}
+					if (nX1 + nWidth1 > nX0 + nWidth0) {
+						nWidth1 = nX0 + nWidth0 - nX1;
+						if (nWidth1 <= 0) break;
+					}
+
+					// �ʐ�
+					int nSize = nWidth1 * nHeight1;
+
+					nR += static_cast<int>(pbySrc0[0]) * nSize;
+					nG += static_cast<int>(pbySrc0[1]) * nSize;
+					nB += static_cast<int>(pbySrc0[2]) * nSize;
+					nA += static_cast<int>(pbySrc0[3]) * nSize;
+
+					pbySrc0 += 4;
+				}
+
+				pbySrc0 = pbySrc0Temp + nSrcPitch;
+			}
+
+			// ISurface��RGBA��
+			pbyDest[0] = static_cast<unsigned char>(nR / nPixelSize);
+			pbyDest[1] = static_cast<unsigned char>(nG / nPixelSize);
+			pbyDest[2] = static_cast<unsigned char>(nB / nPixelSize);
+			pbyDest[3] = static_cast<unsigned char>(nA / nPixelSize);
+
+			pbyDest += 4;
+		}
+
+		pbyDest += nDestNextLine;
+	}
+}
+
+//
+cgdecoder::ECGFormat CSurface::AnalyzeFormat(const unsigned char* pData, int Size)
+{
+	if (!pData || Size < 3) {
+		return cgdecoder::CGFORMAT_NONE;
+	}
+
+	// BMP
+	if (pData[0] == 'B' && pData[1] == 'M') return cgdecoder::CGFORMAT_BMP;
+
+	// JPEG
+	if (Size > 3) {
+		if (pData[0] == 0xff && pData[1] == 0xd8 && pData[2] == 0xff) {
+			return cgdecoder::CGFORMAT_JPG;
+		}
+	}
+
+	// PNG
+	if (Size > 8) {
+		const unsigned char PNGHeader[] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+
+		int n;
+		for (n = 0; n < 8; n++) {
+			if (pData[n] != PNGHeader[n]) break;
+		}
+
+		if (n >= 8) return cgdecoder::CGFORMAT_PNG;
+	}
+
+	// DDS
+	if (Size >= 4) {
+		if (pData[0] == 'D' && pData[1] == 'D' && pData[2] == 'S' && pData[3] == 0x20) {
+			return cgdecoder::CGFORMAT_DDS;
+		}
+	}
+
+	// TGA
+	if (pData[Size - 1] == 0x0 && Size >= 18) {
+		const std::string Text = reinterpret_cast<const char*>(&pData[Size - 18]);
+		if (Text == "TRUEVISION-TARGA" ||
+			Text == "TRUEVISION-XFILE.")
+		{
+			return cgdecoder::CGFORMAT_TGA;
+		}
+	}
+
+	return cgdecoder::CGFORMAT_NONE;
+}
+
+const unsigned char* CSurface::GetPixel(int nX, int nY) const
+{
+	return m_pPixel + nY * m_nPitch + nX * m_nBypp;
+}
+
+}
+

package/PackageResources/tools/VRMScrambler/Source/Independent/GraphCommon/CSurface.cpp.meta

@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 4d239f8fbf771354ba0ae3509d0a6d42
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: