2009-07-28 21:32:10 +00:00
|
|
|
// Copyright (C) 2003 Dolphin Project.
|
2008-12-08 05:30:24 +00:00
|
|
|
|
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
|
// the Free Software Foundation, version 2.0.
|
|
|
|
|
|
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
|
|
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
|
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
|
|
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
|
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
|
|
2009-05-13 23:37:26 +00:00
|
|
|
#include <cmath>
|
2008-12-08 05:30:24 +00:00
|
|
|
#include "Common.h"
|
2009-01-16 16:28:33 +00:00
|
|
|
//#include "VideoCommon.h" // to get debug logs
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-01-14 11:28:48 +00:00
|
|
|
#include "CPUDetect.h"
|
2008-12-08 05:30:24 +00:00
|
|
|
#include "TextureDecoder.h"
|
2009-10-07 21:30:36 +00:00
|
|
|
|
|
|
|
|
#include "OpenCL.h"
|
2009-09-30 12:58:02 +00:00
|
|
|
#if defined(HAVE_OPENCL) && HAVE_OPENCL
|
2009-10-07 21:30:36 +00:00
|
|
|
#include "OpenCL/OCLTextureDecoder.h"
|
2009-09-30 00:28:27 +00:00
|
|
|
#endif
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
#include "LookUpTables.h"
|
2009-02-19 01:24:33 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
bool TexFmt_Overlay_Enable=false;
|
|
|
|
|
bool TexFmt_Overlay_Center=false;
|
2009-02-23 19:47:58 +00:00
|
|
|
|
|
|
|
|
extern const char* texfmt[];
|
|
|
|
|
extern const unsigned char sfont_map[];
|
|
|
|
|
extern const unsigned char sfont_raw[][9*10];
|
2008-12-08 05:30:24 +00:00
|
|
|
|
|
|
|
|
// TRAM
|
|
|
|
|
// STATE_TO_SAVE
|
|
|
|
|
u8 texMem[TMEM_SIZE];
|
|
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
// Gamecube/Wii texture decoder
|
2009-09-02 21:00:45 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
// Decodes all known Gamecube/Wii texture formats.
|
|
|
|
|
// by ector
|
2009-09-02 21:00:45 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
int TexDecoder_GetTexelSizeInNibbles(int format)
|
|
|
|
|
{
|
|
|
|
|
switch (format & 0x3f) {
|
2009-05-09 07:55:30 +00:00
|
|
|
case GX_TF_I4: return 1;
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_I8: return 2;
|
|
|
|
|
case GX_TF_IA4: return 2;
|
|
|
|
|
case GX_TF_IA8: return 4;
|
|
|
|
|
case GX_TF_RGB565: return 4;
|
|
|
|
|
case GX_TF_RGB5A3: return 4;
|
|
|
|
|
case GX_TF_RGBA8: return 8;
|
|
|
|
|
case GX_TF_C4: return 1;
|
|
|
|
|
case GX_TF_C8: return 2;
|
|
|
|
|
case GX_TF_C14X2: return 4;
|
|
|
|
|
case GX_TF_CMPR: return 1;
|
2009-11-14 17:50:51 +00:00
|
|
|
case GX_CTF_R4: return 1;
|
|
|
|
|
case GX_CTF_RA4: return 2;
|
|
|
|
|
case GX_CTF_RA8: return 4;
|
|
|
|
|
case GX_CTF_YUVA8: return 8;
|
|
|
|
|
case GX_CTF_A8: return 2;
|
|
|
|
|
case GX_CTF_R8: return 2;
|
|
|
|
|
case GX_CTF_G8: return 2;
|
|
|
|
|
case GX_CTF_B8: return 2;
|
|
|
|
|
case GX_CTF_RG8: return 4;
|
|
|
|
|
case GX_CTF_GB8: return 4;
|
|
|
|
|
|
|
|
|
|
case GX_TF_Z8: return 2;
|
|
|
|
|
case GX_TF_Z16: return 4;
|
|
|
|
|
case GX_TF_Z24X8: return 8;
|
|
|
|
|
|
|
|
|
|
case GX_CTF_Z4: return 1;
|
|
|
|
|
case GX_CTF_Z8M: return 2;
|
|
|
|
|
case GX_CTF_Z8L: return 2;
|
|
|
|
|
case GX_CTF_Z16L: return 4;
|
2008-12-08 05:30:24 +00:00
|
|
|
default: return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int TexDecoder_GetTextureSizeInBytes(int width, int height, int format)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
return (width * height * TexDecoder_GetTexelSizeInNibbles(format)) / 2;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 TexDecoder_GetHash32(const u8 *src, int len, u32 samples)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
|
|
|
|
const u32 m = 0x5bd1e995;
|
|
|
|
|
const int r = 24;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 h = len;
|
2010-02-10 15:55:24 +00:00
|
|
|
const u32 * data = (const u32 *)src;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 Step = (len/4);
|
|
|
|
|
const u32 * End = data + Step;
|
|
|
|
|
const u8 * uEnd = (const u8 *)End;
|
|
|
|
|
if(samples == 0) samples = Step;
|
|
|
|
|
Step = Step / samples;
|
|
|
|
|
if(Step < 1) Step = 1;
|
|
|
|
|
while(data < End)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
|
|
|
|
u32 k = data[0];
|
|
|
|
|
k *= m;
|
|
|
|
|
k ^= k >> r;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
k *= m;
|
|
|
|
|
h *= m;
|
2010-02-10 15:55:24 +00:00
|
|
|
h ^= k;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
data+=Step;
|
2010-02-10 15:55:24 +00:00
|
|
|
}
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
switch(len & 3)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
case 3: h ^= u32(uEnd[2]) << 16;
|
|
|
|
|
case 2: h ^= u32(uEnd[1]) << 8;
|
|
|
|
|
case 1: h ^= u32(uEnd[0]);
|
|
|
|
|
h *= m;
|
2010-02-10 15:55:24 +00:00
|
|
|
};
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
|
2010-02-10 15:55:24 +00:00
|
|
|
h ^= h >> 13;
|
|
|
|
|
h *= m;
|
|
|
|
|
h ^= h >> 15;
|
|
|
|
|
return h;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef _M_X64
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u64 TexDecoder_GetHash64(const u8 *src, int len, u32 samples)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2010-02-08 23:23:04 +00:00
|
|
|
const u64 m = 0xc6a4a7935bd1e995;
|
|
|
|
|
const int r = 47;
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u64 h = len * m;
|
|
|
|
|
u32 Step = (len/8);
|
2010-02-10 15:55:24 +00:00
|
|
|
const u64 * data = (const u64 *)src;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
const u64 * end = data + Step;
|
|
|
|
|
if(samples == 0) samples = Step;
|
|
|
|
|
Step = Step / samples;
|
|
|
|
|
if(Step < 1) Step = 1;
|
|
|
|
|
while(data < end)
|
2010-02-08 23:23:04 +00:00
|
|
|
{
|
2010-02-10 15:55:24 +00:00
|
|
|
u64 k = data[0];
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
data+=Step;
|
2010-02-08 23:23:04 +00:00
|
|
|
k *= m;
|
|
|
|
|
k ^= k >> r;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
k *= m;
|
2010-02-08 23:23:04 +00:00
|
|
|
h ^= k;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
h *= m;
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
const u8 * data2 = (const u8*)end;
|
2010-02-08 23:23:04 +00:00
|
|
|
|
|
|
|
|
switch(len & 7)
|
|
|
|
|
{
|
|
|
|
|
case 7: h ^= u64(data2[6]) << 48;
|
|
|
|
|
case 6: h ^= u64(data2[5]) << 40;
|
|
|
|
|
case 5: h ^= u64(data2[4]) << 32;
|
|
|
|
|
case 4: h ^= u64(data2[3]) << 24;
|
|
|
|
|
case 3: h ^= u64(data2[2]) << 16;
|
|
|
|
|
case 2: h ^= u64(data2[1]) << 8;
|
|
|
|
|
case 1: h ^= u64(data2[0]);
|
|
|
|
|
h *= m;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
h ^= h >> r;
|
|
|
|
|
h *= m;
|
|
|
|
|
h ^= h >> r;
|
|
|
|
|
|
|
|
|
|
return h;
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-10 15:55:24 +00:00
|
|
|
#else
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u64 TexDecoder_GetHash64(const u8 *src, int len, u32 samples)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
|
|
|
|
const u32 m = 0x5bd1e995;
|
|
|
|
|
const int r = 24;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
|
|
|
|
|
u32 h1 = len;
|
2010-02-10 15:55:24 +00:00
|
|
|
u32 h2 = 0;
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 Step = (len / 4);
|
2010-02-10 15:55:24 +00:00
|
|
|
const u32 * data = (const u32 *)src;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
const u32 * end = data + Step;
|
|
|
|
|
const u8 * uEnd = (const u8 *)end;
|
|
|
|
|
if(samples == 0) samples = Step;
|
|
|
|
|
Step = Step / samples;
|
|
|
|
|
|
|
|
|
|
if(Step < 2) Step = 2;
|
2010-02-10 15:55:24 +00:00
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
while(data < end)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 k1 = data[0];
|
2010-02-10 15:55:24 +00:00
|
|
|
k1 *= m;
|
|
|
|
|
k1 ^= k1 >> r;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
k1 *= m;
|
|
|
|
|
h1 *= m;
|
2010-02-10 15:55:24 +00:00
|
|
|
h1 ^= k1;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
|
2010-02-10 15:55:24 +00:00
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 k2 = data[1];
|
2010-02-10 15:55:24 +00:00
|
|
|
k2 *= m;
|
|
|
|
|
k2 ^= k2 >> r;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
k2 *= m;
|
|
|
|
|
h2 *= m;
|
2010-02-10 15:55:24 +00:00
|
|
|
h2 ^= k2;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
data+=Step;
|
2010-02-10 15:55:24 +00:00
|
|
|
}
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
if(len & 7 > 3)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
u32 k1 = *(end - 1);
|
2010-02-10 15:55:24 +00:00
|
|
|
k1 *= m;
|
|
|
|
|
k1 ^= k1 >> r;
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
k1 *= m;
|
|
|
|
|
h1 *= m;
|
2010-02-10 15:55:24 +00:00
|
|
|
h1 ^= k1;
|
|
|
|
|
len -= 4;
|
|
|
|
|
}
|
|
|
|
|
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
switch(len & 3)
|
2010-02-10 15:55:24 +00:00
|
|
|
{
|
First a bugfix:
fixed a misbehavior in the clear code that causes depth clear problems in reference hardware (Intel as example).
add 6 parameters to optimize Safe Texture Cache:
SafeTextureCacheColorSamples, SafeTextureCacheIndexedSamples, SafeTextureCacheTlutSamples:
this 3 parameters gives the number of samples taken to calculate the final hash value, less samples = more speed, more samples = more accuracy
if 0 is specified the hash is calculated using all the data in the texture.
SafeTextureCacheColorMaxSize, SafeTextureCacheIndexedMaxSize, SafeTextureCacheTlutMaxSize:
this parameters limits the amount of data used for the hash calculation, it could appear as redundant but in some games is better to make a full hash of the first bytes instead of some samples of all the texture.
color, indexed, tlut : define the texture type, full color data, indexed, and the tlut memory.
the parameters are available in the config , no GUI at this time, if the test are OK will add it to the GUI.
if someone needs it will give more examples on how to configure the values for specific games.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5116 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-02-23 21:52:12 +00:00
|
|
|
case 3: h2 ^= uEnd[2] << 16;
|
|
|
|
|
case 2: h2 ^= uEnd[1] << 8;
|
|
|
|
|
case 1: h2 ^= uEnd[0];
|
2010-02-10 15:55:24 +00:00
|
|
|
h2 *= m;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
h1 ^= h2 >> 18; h1 *= m;
|
|
|
|
|
h2 ^= h1 >> 22; h2 *= m;
|
|
|
|
|
h1 ^= h2 >> 17; h1 *= m;
|
|
|
|
|
h2 ^= h1 >> 19; h2 *= m;
|
|
|
|
|
|
|
|
|
|
u64 h = h1;
|
|
|
|
|
|
|
|
|
|
h = (h << 32) | h2;
|
|
|
|
|
|
|
|
|
|
return h;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2009-08-11 20:36:13 +00:00
|
|
|
int TexDecoder_GetBlockWidthInTexels(u32 format)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
switch (format)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
case GX_TF_I4: return 8;
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_I8: return 8;
|
|
|
|
|
case GX_TF_IA4: return 8;
|
|
|
|
|
case GX_TF_IA8: return 4;
|
|
|
|
|
case GX_TF_RGB565: return 4;
|
|
|
|
|
case GX_TF_RGB5A3: return 4;
|
|
|
|
|
case GX_TF_RGBA8: return 4;
|
|
|
|
|
case GX_TF_C4: return 8;
|
|
|
|
|
case GX_TF_C8: return 8;
|
|
|
|
|
case GX_TF_C14X2: return 4;
|
|
|
|
|
case GX_TF_CMPR: return 8;
|
2009-08-11 20:36:13 +00:00
|
|
|
case GX_CTF_R4: return 8;
|
|
|
|
|
case GX_CTF_RA4: return 8;
|
|
|
|
|
case GX_CTF_RA8: return 4;
|
|
|
|
|
case GX_CTF_A8: return 8;
|
|
|
|
|
case GX_CTF_R8: return 8;
|
|
|
|
|
case GX_CTF_G8: return 8;
|
|
|
|
|
case GX_CTF_B8: return 8;
|
|
|
|
|
case GX_CTF_RG8: return 4;
|
|
|
|
|
case GX_CTF_GB8: return 4;
|
|
|
|
|
case GX_TF_Z8: return 8;
|
|
|
|
|
case GX_TF_Z16: return 4;
|
|
|
|
|
case GX_TF_Z24X8: return 4;
|
|
|
|
|
case GX_CTF_Z4: return 8;
|
|
|
|
|
case GX_CTF_Z8M: return 8;
|
|
|
|
|
case GX_CTF_Z8L: return 8;
|
|
|
|
|
case GX_CTF_Z16L: return 4;
|
2009-08-11 13:58:35 +00:00
|
|
|
default:
|
|
|
|
|
ERROR_LOG(VIDEO, "Unsupported Texture Format (%08x)! (GetBlockWidthInTexels)", format);
|
|
|
|
|
return 8;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-11 20:36:13 +00:00
|
|
|
int TexDecoder_GetBlockHeightInTexels(u32 format)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2009-08-11 13:58:35 +00:00
|
|
|
switch (format)
|
2009-07-26 09:52:35 +00:00
|
|
|
{
|
2009-08-11 13:58:35 +00:00
|
|
|
case GX_TF_I4: return 8;
|
|
|
|
|
case GX_TF_I8: return 4;
|
|
|
|
|
case GX_TF_IA4: return 4;
|
|
|
|
|
case GX_TF_IA8: return 4;
|
|
|
|
|
case GX_TF_RGB565: return 4;
|
|
|
|
|
case GX_TF_RGB5A3: return 4;
|
|
|
|
|
case GX_TF_RGBA8: return 4;
|
|
|
|
|
case GX_TF_C4: return 8;
|
|
|
|
|
case GX_TF_C8: return 4;
|
|
|
|
|
case GX_TF_C14X2: return 4;
|
|
|
|
|
case GX_TF_CMPR: return 4;
|
2009-08-11 20:36:13 +00:00
|
|
|
case GX_CTF_R4: return 8;
|
|
|
|
|
case GX_CTF_RA4: return 4;
|
2009-11-15 20:14:03 +00:00
|
|
|
case GX_CTF_RA8: return 4;
|
2009-08-11 20:36:13 +00:00
|
|
|
case GX_CTF_A8: return 4;
|
|
|
|
|
case GX_CTF_R8: return 4;
|
|
|
|
|
case GX_CTF_G8: return 4;
|
|
|
|
|
case GX_CTF_B8: return 4;
|
2009-11-15 20:14:03 +00:00
|
|
|
case GX_CTF_RG8: return 4;
|
|
|
|
|
case GX_CTF_GB8: return 4;
|
2009-08-11 20:36:13 +00:00
|
|
|
case GX_TF_Z8: return 4;
|
2009-11-15 20:14:03 +00:00
|
|
|
case GX_TF_Z16: return 4;
|
2009-12-02 04:17:18 +00:00
|
|
|
case GX_TF_Z24X8: return 4;
|
2009-08-11 20:36:13 +00:00
|
|
|
case GX_CTF_Z4: return 8;
|
|
|
|
|
case GX_CTF_Z8M: return 4;
|
|
|
|
|
case GX_CTF_Z8L: return 4;
|
2009-11-15 20:14:03 +00:00
|
|
|
case GX_CTF_Z16L: return 4;
|
2009-08-11 13:58:35 +00:00
|
|
|
default:
|
|
|
|
|
ERROR_LOG(VIDEO, "Unsupported Texture Format (%08x)! (GetBlockHeightInTexels)", format);
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
//returns bytes
|
|
|
|
|
int TexDecoder_GetPaletteSize(int format)
|
|
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
switch (format)
|
|
|
|
|
{
|
|
|
|
|
case GX_TF_C4: return 16 * 2;
|
|
|
|
|
case GX_TF_C8: return 256 * 2;
|
|
|
|
|
case GX_TF_C14X2: return 16384 * 2;
|
2008-12-08 05:30:24 +00:00
|
|
|
default:
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline u32 decodeIA8(u16 val)
|
|
|
|
|
{
|
2009-03-20 18:13:31 +00:00
|
|
|
int a = val >> 8;
|
|
|
|
|
int i = val & 0xFF;
|
2009-07-26 09:52:35 +00:00
|
|
|
return (a << 24) | (i << 16) | (i << 8) | i;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline u32 decode5A3(u16 val)
|
|
|
|
|
{
|
|
|
|
|
int r,g,b,a;
|
2009-07-26 09:52:35 +00:00
|
|
|
if ((val & 0x8000))
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-07-30 20:29:52 +00:00
|
|
|
a = 0xFF;
|
|
|
|
|
r = Convert5To8((val >> 10) & 0x1F);
|
|
|
|
|
g = Convert5To8((val >> 5) & 0x1F);
|
|
|
|
|
b = Convert5To8(val & 0x1F);
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
else
|
|
|
|
|
{
|
2009-07-30 20:29:52 +00:00
|
|
|
a = Convert3To8((val >> 12) & 0x7);
|
|
|
|
|
r = Convert4To8((val >> 8) & 0xF);
|
|
|
|
|
g = Convert4To8((val >> 4) & 0xF);
|
|
|
|
|
b = Convert4To8(val & 0xF);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-07-26 09:52:35 +00:00
|
|
|
return (a << 24) | (r << 16) | (g << 8) | b;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct DXTBlock
|
|
|
|
|
{
|
|
|
|
|
u16 color1;
|
|
|
|
|
u16 color2;
|
|
|
|
|
u8 lines[4];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
//inline void decodebytesC4(u32 *dst, const u8 *src, int numbytes, int tlutaddr, int tlutfmt)
|
2009-05-13 02:06:02 +00:00
|
|
|
inline void decodebytesC4_5A3_To_BGRA32(u32 *dst, const u8 *src, int tlutaddr)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
u8 val = src[x];
|
|
|
|
|
*dst++ = decode5A3(Common::swap16(tlut[val >> 4]));
|
|
|
|
|
*dst++ = decode5A3(Common::swap16(tlut[val & 0xF]));
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-13 02:06:02 +00:00
|
|
|
inline void decodebytesC4_To_Raw16(u16* dst, const u8* src, int tlutaddr)
|
|
|
|
|
{
|
|
|
|
|
u16* tlut = (u16*)(texMem+tlutaddr);
|
|
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[x];
|
|
|
|
|
*dst++ = Common::swap16(tlut[val >> 4]);
|
|
|
|
|
*dst++ = Common::swap16(tlut[val & 0xF]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
//inline void decodebytesC8(u32 *dst, const u8 *src, int numbytes, int tlutaddr, int tlutfmt)
|
2009-05-13 02:06:02 +00:00
|
|
|
inline void decodebytesC8_5A3_To_BGRA32(u32 *dst, const u8 *src, int tlutaddr)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int x = 0; x < 8; x++)
|
|
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
u8 val = src[x];
|
|
|
|
|
*dst++ = decode5A3(Common::swap16(tlut[val]));
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-02-24 23:58:48 +00:00
|
|
|
inline void decodebytesC8_To_Raw16(u16* dst, const u8* src, int tlutaddr)
|
2009-05-13 02:06:02 +00:00
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
u16* tlut = (u16*)(texMem + tlutaddr);
|
2009-05-13 02:06:02 +00:00
|
|
|
for (int x = 0; x < 8; x++)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[x];
|
|
|
|
|
*dst++ = Common::swap16(tlut[val]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-05-13 02:06:02 +00:00
|
|
|
inline void decodebytesC14X2_5A3_To_BGRA32(u32 *dst, const u16 *src, int tlutaddr)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
u16 val = Common::swap16(src[x]);
|
2009-07-26 09:52:35 +00:00
|
|
|
*dst++ = decode5A3(Common::swap16(tlut[(val & 0x3FFF)]));
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-13 02:06:02 +00:00
|
|
|
inline void decodebytesC14X2_To_Raw16(u16* dst, const u16* src, int tlutaddr)
|
|
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
u16* tlut = (u16*)(texMem + tlutaddr);
|
2009-05-13 02:06:02 +00:00
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
{
|
|
|
|
|
u16 val = Common::swap16(src[x]);
|
2009-07-26 09:52:35 +00:00
|
|
|
*dst++ = Common::swap16(tlut[(val & 0x3FFF)]);
|
2009-05-13 02:06:02 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2010-01-19 19:28:27 +00:00
|
|
|
// Needs more speed.
|
2009-02-14 09:04:40 +00:00
|
|
|
inline void decodebytesIA4(u16 *dst, const u8 *src)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-07-30 20:29:52 +00:00
|
|
|
for (int x = 0; x < 8; x++)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
const u8 val = src[x];
|
2009-07-30 20:29:52 +00:00
|
|
|
u8 a = Convert4To8(val >> 4);
|
|
|
|
|
u8 l = Convert4To8(val & 0xF);
|
|
|
|
|
dst[x] = (a << 8) | l;
|
|
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline void decodebytesRGB5A3(u32 *dst, const u16 *src)
|
|
|
|
|
{
|
|
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
dst[x] = decode5A3(Common::swap16(src[x]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// This one is used by many video formats. It'd therefore be good if it was fast.
|
2010-01-19 19:28:27 +00:00
|
|
|
// Needs more speed.
|
2008-12-08 05:30:24 +00:00
|
|
|
inline void decodebytesARGB8_4(u32 *dst, const u16 *src, const u16 *src2)
|
|
|
|
|
{
|
|
|
|
|
for (int x = 0; x < 4; x++) {
|
|
|
|
|
dst[x] = Common::swap32((src2[x] << 16) | src[x]);
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-09 07:55:30 +00:00
|
|
|
// This can probably be done in a few SSE pack/unpack instructions + pshufb
|
|
|
|
|
// some unpack instruction x2:
|
|
|
|
|
// ABABABABABABABAB 1212121212121212 ->
|
|
|
|
|
// AB12AB12AB12AB12 AB12AB12AB12AB12
|
|
|
|
|
// 2x pshufb->
|
|
|
|
|
// 21BA21BA21BA21BA 21BA21BA21BA21BA
|
|
|
|
|
// and we are done.
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline u32 makecol(int r, int g, int b, int a)
|
|
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
return (a << 24)|(r << 16)|(g << 8)|b;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
2009-10-10 21:19:39 +00:00
|
|
|
inline u32 makeRGBA(int r, int g, int b, int a)
|
|
|
|
|
{
|
|
|
|
|
return (a<<24)|(b<<16)|(g<<8)|r;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
void decodeDXTBlock(u32 *dst, const DXTBlock *src, int pitch)
|
|
|
|
|
{
|
2009-09-02 18:55:36 +00:00
|
|
|
// S3TC Decoder (Note: GCN decodes differently from PC so we can't use native support)
|
2010-01-19 19:28:27 +00:00
|
|
|
// Needs more speed.
|
2008-12-08 05:30:24 +00:00
|
|
|
u16 c1 = Common::swap16(src->color1);
|
|
|
|
|
u16 c2 = Common::swap16(src->color2);
|
2009-09-02 21:30:54 +00:00
|
|
|
int blue1 = Convert5To8(c1 & 0x1F);
|
|
|
|
|
int blue2 = Convert5To8(c2 & 0x1F);
|
|
|
|
|
int green1 = Convert6To8((c1 >> 5) & 0x3F);
|
|
|
|
|
int green2 = Convert6To8((c2 >> 5) & 0x3F);
|
|
|
|
|
int red1 = Convert5To8((c1 >> 11) & 0x1F);
|
|
|
|
|
int red2 = Convert5To8((c2 >> 11) & 0x1F);
|
2008-12-08 05:30:24 +00:00
|
|
|
int colors[4];
|
2010-02-03 03:52:50 +00:00
|
|
|
colors[0] = makecol(red1, green1, blue1, 255);
|
|
|
|
|
colors[1] = makecol(red2, green2, blue2, 255);
|
2008-12-08 05:30:24 +00:00
|
|
|
if (c1 > c2)
|
|
|
|
|
{
|
2009-09-02 21:30:54 +00:00
|
|
|
int blue3 = ((blue2 - blue1) >> 1) - ((blue2 - blue1) >> 3);
|
|
|
|
|
int green3 = ((green2 - green1) >> 1) - ((green2 - green1) >> 3);
|
2010-02-03 03:52:50 +00:00
|
|
|
int red3 = ((red2 - red1) >> 1) - ((red2 - red1) >> 3);
|
2009-09-02 21:30:54 +00:00
|
|
|
colors[2] = makecol(red1 + red3, green1 + green3, blue1 + blue3, 255);
|
|
|
|
|
colors[3] = makecol(red2 - red3, green2 - green3, blue2 - blue3, 255);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2009-09-02 21:30:54 +00:00
|
|
|
colors[2] = makecol((red1 + red2 + 1) / 2, // Average
|
|
|
|
|
(green1 + green2 + 1) / 2,
|
|
|
|
|
(blue1 + blue2 + 1) / 2, 255);
|
2009-05-13 23:37:26 +00:00
|
|
|
colors[3] = makecol(red2, green2, blue2, 0); // Color2 but transparent
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int y = 0; y < 4; y++)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2008-12-08 05:30:24 +00:00
|
|
|
int val = src->lines[y];
|
|
|
|
|
for (int x = 0; x < 4; x++)
|
|
|
|
|
{
|
|
|
|
|
dst[x] = colors[(val >> 6) & 3];
|
|
|
|
|
val <<= 2;
|
|
|
|
|
}
|
|
|
|
|
dst += pitch;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-05-06 02:10:07 +00:00
|
|
|
static void copyDXTBlock(u8* dst, const u8* src)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
((u16*)dst)[0] = Common::swap16(((u16*)src)[0]);
|
|
|
|
|
((u16*)dst)[1] = Common::swap16(((u16*)src)[1]);
|
|
|
|
|
u32 pixels = ((u32*)src)[1];
|
|
|
|
|
// A bit of trickiness here: the row are in the same order
|
|
|
|
|
// between the two formats, but the ordering within the rows
|
|
|
|
|
// is reversed.
|
|
|
|
|
pixels = ((pixels >> 4) & 0x0F0F0F0F) | ((pixels << 4) & 0xF0F0F0F0);
|
|
|
|
|
pixels = ((pixels >> 2) & 0x33333333) | ((pixels << 2) & 0xCCCCCCCC);
|
|
|
|
|
((u32*)dst)[1] = pixels;
|
2009-05-06 02:10:07 +00:00
|
|
|
}
|
|
|
|
|
|
2009-05-13 02:06:02 +00:00
|
|
|
static PC_TexFormat GetPCFormatFromTLUTFormat(int tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
switch (tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
case 0: return PC_TEX_FMT_IA8; // IA8
|
|
|
|
|
case 1: return PC_TEX_FMT_RGB565; // RGB565
|
|
|
|
|
case 2: return PC_TEX_FMT_BGRA32; // RGB5A3: This TLUT format requires
|
|
|
|
|
// extra work to decode.
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_NONE; // Error
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-07 18:48:31 +00:00
|
|
|
PC_TexFormat GetPC_TexFormat(int texformat, int tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
switch (texformat)
|
|
|
|
|
{
|
|
|
|
|
case GX_TF_C4:
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_I4:
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
return PC_TEX_FMT_IA8;
|
2009-12-07 18:48:31 +00:00
|
|
|
case GX_TF_I8: // speed critical
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
return PC_TEX_FMT_IA8;
|
2009-12-07 18:48:31 +00:00
|
|
|
case GX_TF_C8:
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_IA4:
|
|
|
|
|
return PC_TEX_FMT_IA4_AS_IA8;
|
|
|
|
|
case GX_TF_IA8:
|
|
|
|
|
return PC_TEX_FMT_IA8;
|
|
|
|
|
case GX_TF_C14X2:
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_RGB565:
|
|
|
|
|
return PC_TEX_FMT_RGB565;
|
|
|
|
|
case GX_TF_RGB5A3:
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
case GX_TF_RGBA8: // speed critical
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
case GX_TF_CMPR: // speed critical
|
|
|
|
|
// The metroid games use this format almost exclusively.
|
|
|
|
|
{
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// The "copy" texture formats, too?
|
|
|
|
|
return PC_TEX_FMT_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
PC_TexFormat TexDecoder_DirectDecode_real(u8 *dst, const u8 *src, int width, int height,int Pitch, int texformat, int tlutaddr, int tlutfmt)
|
|
|
|
|
{
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
int TexLen = height * Pitch;
|
2009-12-07 18:48:31 +00:00
|
|
|
switch (texformat)
|
|
|
|
|
{
|
|
|
|
|
case GX_TF_C4:
|
|
|
|
|
if (tlutfmt == 2)
|
|
|
|
|
{
|
|
|
|
|
// Special decoding is required for TLUT format 5A3
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 8; iy++, src += 4)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC4_5A3_To_BGRA32(((u32*)((u8*)dst + (y + iy) * Pitch)) + x, src, tlutaddr);
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix * 2) * 4;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[ix];
|
|
|
|
|
((u32*)(dst+stride))[0] = decode5A3(Common::swap16(tlut[val >> 4]));
|
|
|
|
|
((u32*)(dst+stride))[1] = decode5A3(Common::swap16(tlut[val & 0xF]));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 8; iy++, src += 4)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC4_To_Raw16(((u16*)((u8*)dst + (y + iy) * Pitch)) + x, src, tlutaddr);
|
|
|
|
|
u16* tlut = (u16*)(texMem+tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix * 2) * 2;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[ix];
|
|
|
|
|
((u16*)(dst+stride))[0] = Common::swap16(tlut[val >> 4]);
|
|
|
|
|
((u16*)(dst+stride))[1] = Common::swap16(tlut[val & 0xF]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_I4:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int iy = 0; iy < 8 && (y + iy) < height ; iy++, src += 4)
|
2009-12-07 18:48:31 +00:00
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int val = src[ix];
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
int stride = (y + iy) * Pitch + (x + ix * 2) * 2;
|
|
|
|
|
dst[stride] = Convert4To8(val >> 4);
|
|
|
|
|
dst[stride + 1] = dst[stride];
|
|
|
|
|
dst[stride + 2] = Convert4To8(val & 0xF);
|
|
|
|
|
dst[stride + 3] = dst[stride + 2];
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
}
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
return PC_TEX_FMT_IA8;
|
2010-01-19 19:28:27 +00:00
|
|
|
case GX_TF_I8: // speed critical. Needs speed.
|
2009-12-07 18:48:31 +00:00
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int iy = 0; iy < 4 && (y + iy) < height; iy++)
|
|
|
|
|
for (int ix = 0; ix < 8; ix++,src++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy)*Pitch+(x + ix) * 2;
|
2010-01-19 19:28:27 +00:00
|
|
|
if (stride < TexLen)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
dst[stride] = src[0];
|
|
|
|
|
dst[stride + 1] = src[0];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
return PC_TEX_FMT_IA8;
|
2009-12-07 18:48:31 +00:00
|
|
|
case GX_TF_C8:
|
|
|
|
|
if (tlutfmt == 2)
|
|
|
|
|
{
|
|
|
|
|
// Special decoding is required for TLUT format 5A3
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC8_5A3_To_BGRA32(((u32*)((u8*)dst + (y + iy) * Pitch)) + x, src, tlutaddr);
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 8; ix++)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[ix];
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix) * 4;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
((u32*)(dst+stride))[0] = decode5A3(Common::swap16(tlut[val]));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC8_To_Raw16(((u16*)((u8*)dst + (y + iy) * Pitch)) + x, src, tlutaddr);
|
|
|
|
|
u16* tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 8; ix++)
|
|
|
|
|
{
|
|
|
|
|
u8 val = src[ix];
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix) * 2;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
((u16*)(dst+stride))[0] = Common::swap16(tlut[val]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_IA4:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesIA4(((u16*)((u8*)dst + (y + iy) * Pitch)) + x, src);
|
|
|
|
|
for (int ix = 0; ix < 8; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix) * 2;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
const u8 val = src[ix];
|
|
|
|
|
u8 a = Convert4To8(val >> 4);
|
|
|
|
|
u8 l = Convert4To8(val & 0xF);
|
|
|
|
|
((u16*)(dst+stride))[0] = (a << 8) | l;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_IA4_AS_IA8;
|
|
|
|
|
case GX_TF_IA8:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
{
|
|
|
|
|
u16 *s = (u16 *)src;
|
|
|
|
|
for(int j = 0; j < 4; j++)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + j) * 2;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
((u16*)(dst+stride))[0] = Common::swap16(*s++);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_IA8;
|
|
|
|
|
case GX_TF_C14X2:
|
|
|
|
|
if (tlutfmt == 2)
|
|
|
|
|
{
|
|
|
|
|
// Special decoding is required for TLUT format 5A3
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC14X2_5A3_To_BGRA32(((u32*)((u8*)dst + (y + iy) * Pitch)) + x, (u16*)src, tlutaddr);
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch +( x + ix) * 4;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
u16 val = Common::swap16(src[ix]);
|
|
|
|
|
((u32*)(dst+stride))[0] = decode5A3(Common::swap16(tlut[(val & 0x3FFF)]));
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
//decodebytesC14X2_To_Raw16(((u16*)((u8*)dst + (y + iy) * Pitch)) + x, (u16*)src, tlutaddr);
|
|
|
|
|
u16* tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + ix) * 2;
|
|
|
|
|
if(stride < TexLen)
|
|
|
|
|
{
|
|
|
|
|
u16 val = Common::swap16(src[ix]);
|
|
|
|
|
((u16*)(dst+stride))[0] = Common::swap16(tlut[(val & 0x3FFF)]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
|
|
|
|
case GX_TF_RGB565:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int iy = 0; iy < 4 && (y + iy) < height; iy++, src += 8)
|
2009-12-07 18:48:31 +00:00
|
|
|
{
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
//u16 *ptr = ((u16 *)(dst + (y + iy) * Pitch)) + x;
|
2009-12-07 18:48:31 +00:00
|
|
|
u16 *s = (u16 *)src;
|
|
|
|
|
for(int j = 0; j < 4; j++)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
{
|
|
|
|
|
int stride = (y + iy) * Pitch + (x + j) * 2;
|
|
|
|
|
if(stride < height * Pitch)
|
|
|
|
|
{
|
|
|
|
|
((u16*)(dst+stride))[0] = Common::swap16(*s++);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_RGB565;
|
|
|
|
|
case GX_TF_RGB5A3:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y+iy)*Pitch + (x + ix) * 4;
|
|
|
|
|
if(stride < height * Pitch)
|
|
|
|
|
((u32*)(dst+stride))[0] = decode5A3(Common::swap16(((u16 *)src)[ix]));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
case GX_TF_RGBA8: // speed critical
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
2010-01-19 19:28:27 +00:00
|
|
|
{
|
2009-12-07 18:48:31 +00:00
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
{
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int iy = 0; iy < 4 && (y + iy) < height; iy++)
|
|
|
|
|
{
|
|
|
|
|
//decodebytesARGB8_4(((u32*)((u8*)dst + (y+iy)*Pitch)) + x, (u16*)src + 4 * iy, (u16*)src + 4 * iy + 16);
|
2010-01-19 19:28:27 +00:00
|
|
|
u16 *src1 = (u16*)src + 4 * iy;
|
|
|
|
|
u16 *src2 = (u16*)src + 4 * iy + 16;
|
ok big changes here:
in videocommon little fix for the alpha test values, return to the original values as they are more accurate.
in D3D:
huge change in state management, now all the state management is centralized and redundant state changes are eliminated.
Fixed the overlapped viewport error in non ati cards:
the error was caused by this: when a viewport is defined larger than the current rendertarget, an error is thrown and the last valid viewport is used, this is the reference behavior, in ati cards if a larger viewport is defined, no eror is returned, the rendering is valid and is rendered using the projection defined by the viewport but limited to the rendertarget are, exactly like opengl or the GC hardware.
to solve this in reference drivers defined a large rendertarget (2x the size of the original) and proceed to render in a centered quad insithe the larger rendertarget, in this way larger viewports always falls inside a valid rendertarget size, the drawback of this is the waste of resources. it can be dynamized, depending or games or changed at runtime when a oversized viewport is detected, but i live that to future commits.
please test this and let me know the results.
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@4841 8ced0084-cf51-0410-be5f-012b33b47a6e
2010-01-15 15:52:08 +00:00
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int stride = (y+iy)*Pitch + (x + ix) * 4;
|
|
|
|
|
if(stride < height * Pitch)
|
|
|
|
|
{
|
|
|
|
|
((u32*)(dst+ stride))[0] = Common::swap32((src2[ix] << 16) | src1[ix]);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
src += 64;
|
|
|
|
|
}
|
2010-01-19 19:28:27 +00:00
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
2010-01-19 19:28:27 +00:00
|
|
|
|
2009-12-07 18:48:31 +00:00
|
|
|
case GX_TF_CMPR: // speed critical
|
|
|
|
|
// The metroid games use this format almost exclusively.
|
|
|
|
|
{
|
|
|
|
|
#if 0 // TODO - currently does not handle transparency correctly and causes problems when texture dimensions are not multiples of 8
|
|
|
|
|
// 11111111 22222222 55555555 66666666
|
|
|
|
|
// 33333333 44444444 77777777 88888888
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
{
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
{
|
|
|
|
|
copyDXTBlock(dst+(y/2)*width+x*2, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2)*width+x*2+8, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2+2)*width+x*2, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2+2)*width+x*2+8, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_DXT1;
|
|
|
|
|
#else
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
{
|
2010-01-19 19:28:27 +00:00
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
{
|
|
|
|
|
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x, (DXTBlock *)src, width);
|
|
|
|
|
src += sizeof(DXTBlock);
|
|
|
|
|
decodeDXTBlock(((u32*)((u8*)dst + y * Pitch)) + x + 4, (DXTBlock *)src, width);
|
|
|
|
|
src += sizeof(DXTBlock);
|
|
|
|
|
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x, (DXTBlock *)src, width);
|
|
|
|
|
src += sizeof(DXTBlock);
|
|
|
|
|
decodeDXTBlock(((u32*)((u8*)dst + (y + 4) * Pitch)) + x + 4, (DXTBlock *)src, width);
|
|
|
|
|
src += sizeof(DXTBlock);
|
|
|
|
|
}
|
2009-12-07 18:48:31 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// The "copy" texture formats, too?
|
|
|
|
|
return PC_TEX_FMT_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
|
|
|
|
|
//switch endianness, unswizzle
|
|
|
|
|
//TODO: to save memory, don't blindly convert everything to argb8888
|
|
|
|
|
//also ARGB order needs to be swapped later, to accommodate modern hardware better
|
|
|
|
|
//need to add DXT support too
|
|
|
|
|
PC_TexFormat TexDecoder_Decode_real(u8 *dst, const u8 *src, int width, int height, int texformat, int tlutaddr, int tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
switch (texformat)
|
|
|
|
|
{
|
|
|
|
|
case GX_TF_C4:
|
2009-05-13 02:06:02 +00:00
|
|
|
if (tlutfmt == 2)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
// Special decoding is required for TLUT format 5A3
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 8; iy++, src += 4)
|
2009-07-26 09:52:35 +00:00
|
|
|
decodebytesC4_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, src, tlutaddr);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-13 02:06:02 +00:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 8; iy++, src += 4)
|
2009-07-26 09:52:35 +00:00
|
|
|
decodebytesC4_To_Raw16((u16*)dst + (y + iy) * width + x, src, tlutaddr);
|
2009-05-13 02:06:02 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_I4:
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 8; iy++, src += 4)
|
|
|
|
|
for (int ix = 0; ix < 4; ix++)
|
|
|
|
|
{
|
|
|
|
|
int val = src[ix];
|
2009-07-30 20:29:52 +00:00
|
|
|
dst[(y + iy) * width + x + ix * 2] = Convert4To8(val >> 4);
|
|
|
|
|
dst[(y + iy) * width + x + ix * 2 + 1] = Convert4To8(val & 0xF);
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-13 02:06:02 +00:00
|
|
|
return PC_TEX_FMT_I4_AS_I8;
|
2009-05-09 07:55:30 +00:00
|
|
|
case GX_TF_I8: // speed critical
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
2009-07-26 09:52:35 +00:00
|
|
|
memcpy(dst + (y + iy)*width+x, src, 8);
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_I8;
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_C8:
|
2009-05-13 02:06:02 +00:00
|
|
|
if (tlutfmt == 2)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
// Special decoding is required for TLUT format 5A3
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
2009-07-26 09:52:35 +00:00
|
|
|
decodebytesC8_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, src, tlutaddr);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-13 02:06:02 +00:00
|
|
|
else
|
|
|
|
|
{
|
2010-02-24 23:58:48 +00:00
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
decodebytesC8_To_Raw16((u16*)dst + (y + iy) * width + x, src, tlutaddr);
|
2009-05-13 02:06:02 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_IA4:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
2009-07-26 09:52:35 +00:00
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
decodebytesIA4((u16*)dst + (y + iy) * width + x, src);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-13 02:06:02 +00:00
|
|
|
return PC_TEX_FMT_IA4_AS_IA8;
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_IA8:
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
2009-07-26 09:52:35 +00:00
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
{
|
|
|
|
|
u16 *ptr = (u16 *)dst + (y + iy) * width + x;
|
2009-05-09 07:55:30 +00:00
|
|
|
u16 *s = (u16 *)src;
|
|
|
|
|
for(int j = 0; j < 4; j++)
|
|
|
|
|
*ptr++ = Common::swap16(*s++);
|
|
|
|
|
}
|
2009-02-13 14:14:45 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-09 07:55:30 +00:00
|
|
|
return PC_TEX_FMT_IA8;
|
|
|
|
|
case GX_TF_C14X2:
|
2009-05-13 02:06:02 +00:00
|
|
|
if (tlutfmt == 2)
|
2008-12-08 05:30:24 +00:00
|
|
|
{
|
2009-05-13 02:06:02 +00:00
|
|
|
// Special decoding is required for TLUT format 5A3
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
2009-07-26 09:52:35 +00:00
|
|
|
decodebytesC14X2_5A3_To_BGRA32((u32*)dst + (y + iy) * width + x, (u16*)src, tlutaddr);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-13 02:06:02 +00:00
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
2009-07-26 09:52:35 +00:00
|
|
|
decodebytesC14X2_To_Raw16((u16*)dst + (y + iy) * width + x, (u16*)src, tlutaddr);
|
2009-05-13 02:06:02 +00:00
|
|
|
}
|
|
|
|
|
return GetPCFormatFromTLUTFormat(tlutfmt);
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_RGB565:
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
2009-07-26 09:52:35 +00:00
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
{
|
|
|
|
|
u16 *ptr = (u16 *)dst + (y + iy) * width + x;
|
2009-05-09 07:55:30 +00:00
|
|
|
u16 *s = (u16 *)src;
|
|
|
|
|
for(int j = 0; j < 4; j++)
|
|
|
|
|
*ptr++ = Common::swap16(*s++);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_RGB565;
|
2008-12-08 05:30:24 +00:00
|
|
|
case GX_TF_RGB5A3:
|
|
|
|
|
{
|
|
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
for (int iy = 0; iy < 4; iy++, src += 8)
|
|
|
|
|
//decodebytesRGB5A3((u32*)dst+(y+iy)*width+x, (u16*)src, 4);
|
|
|
|
|
decodebytesRGB5A3((u32*)dst+(y+iy)*width+x, (u16*)src);
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
case GX_TF_RGBA8: // speed critical
|
|
|
|
|
{
|
2010-02-24 23:58:48 +00:00
|
|
|
for (int y = 0; y < height; y += 4)
|
|
|
|
|
for (int x = 0; x < width; x += 4)
|
|
|
|
|
{
|
|
|
|
|
for (int iy = 0; iy < 4; iy++)
|
|
|
|
|
decodebytesARGB8_4((u32*)dst + (y+iy)*width + x, (u16*)src + 4 * iy, (u16*)src + 4 * iy + 16);
|
|
|
|
|
src += 64;
|
|
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
case GX_TF_CMPR: // speed critical
|
2009-05-11 19:04:46 +00:00
|
|
|
// The metroid games use this format almost exclusively.
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2009-05-11 19:04:46 +00:00
|
|
|
#if 0 // TODO - currently does not handle transparency correctly and causes problems when texture dimensions are not multiples of 8
|
|
|
|
|
// 11111111 22222222 55555555 66666666
|
|
|
|
|
// 33333333 44444444 77777777 88888888
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
{
|
2008-12-08 05:30:24 +00:00
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
copyDXTBlock(dst+(y/2)*width+x*2, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2)*width+x*2+8, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2+2)*width+x*2, src);
|
|
|
|
|
src += 8;
|
|
|
|
|
copyDXTBlock(dst+(y/2+2)*width+x*2+8, src);
|
|
|
|
|
src += 8;
|
2009-05-11 19:04:46 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return PC_TEX_FMT_DXT1;
|
|
|
|
|
#else
|
|
|
|
|
for (int y = 0; y < height; y += 8)
|
|
|
|
|
{
|
|
|
|
|
for (int x = 0; x < width; x += 8)
|
|
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
decodeDXTBlock((u32*)dst + y * width + x, (DXTBlock*)src, width);
|
2009-05-11 19:04:46 +00:00
|
|
|
src += sizeof(DXTBlock);
|
2009-07-26 09:52:35 +00:00
|
|
|
decodeDXTBlock((u32*)dst + y * width + x + 4, (DXTBlock*)src, width);
|
2009-05-11 19:04:46 +00:00
|
|
|
src += sizeof(DXTBlock);
|
2009-07-26 09:52:35 +00:00
|
|
|
decodeDXTBlock((u32*)dst + (y + 4) * width + x, (DXTBlock*)src, width);
|
2009-05-11 19:04:46 +00:00
|
|
|
src += sizeof(DXTBlock);
|
2009-07-26 09:52:35 +00:00
|
|
|
decodeDXTBlock((u32*)dst + (y + 4) * width + x + 4, (DXTBlock*)src, width);
|
2009-05-11 19:04:46 +00:00
|
|
|
src += sizeof(DXTBlock);
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
2009-05-11 19:04:46 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return PC_TEX_FMT_BGRA32;
|
|
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
2009-05-09 07:55:30 +00:00
|
|
|
// The "copy" texture formats, too?
|
2008-12-08 05:30:24 +00:00
|
|
|
return PC_TEX_FMT_NONE;
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-07 18:48:31 +00:00
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
void TexDecoder_SetTexFmtOverlayOptions(bool enable, bool center)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
TexFmt_Overlay_Enable = enable;
|
|
|
|
|
TexFmt_Overlay_Center = center;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
2009-12-07 18:48:31 +00:00
|
|
|
void TexDecoder_DirectDecode(u8 *dst, const u8 *src, int width, int height,int Pitch, int texformat, int tlutaddr, int tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
PC_TexFormat retval = TexDecoder_DirectDecode_real(dst,src,width,height,Pitch,texformat,tlutaddr,tlutfmt);
|
|
|
|
|
|
|
|
|
|
if ((!TexFmt_Overlay_Enable)|| (retval == PC_TEX_FMT_NONE))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
int w = min(width, 40);
|
|
|
|
|
int h = min(height, 10);
|
|
|
|
|
|
|
|
|
|
int xoff = (width - w) >> 1;
|
|
|
|
|
int yoff = (height - h) >> 1;
|
|
|
|
|
|
|
|
|
|
if (!TexFmt_Overlay_Center)
|
|
|
|
|
{
|
|
|
|
|
xoff=0;
|
|
|
|
|
yoff=0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* fmt = texfmt[texformat&15];
|
|
|
|
|
while (*fmt)
|
|
|
|
|
{
|
|
|
|
|
int xcnt = 0;
|
|
|
|
|
int nchar = sfont_map[(int)*fmt];
|
|
|
|
|
|
|
|
|
|
const unsigned char *ptr = sfont_raw[nchar]; // each char is up to 9x10
|
|
|
|
|
|
|
|
|
|
for (int x = 0; x < 9;x++)
|
|
|
|
|
{
|
|
|
|
|
if (ptr[x] == 0x78)
|
|
|
|
|
break;
|
|
|
|
|
xcnt++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (int y=0; y < 10; y++)
|
|
|
|
|
{
|
|
|
|
|
for (int x=0; x < xcnt; x++)
|
|
|
|
|
{
|
|
|
|
|
switch(retval)
|
|
|
|
|
{
|
|
|
|
|
case PC_TEX_FMT_I8:
|
|
|
|
|
{
|
|
|
|
|
// TODO: Is this an acceptable way to draw in I8?
|
|
|
|
|
u8 *dtp = (u8*)dst;
|
|
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFF : 0x88;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case PC_TEX_FMT_IA8:
|
|
|
|
|
case PC_TEX_FMT_IA4_AS_IA8:
|
|
|
|
|
{
|
|
|
|
|
u16 *dtp = (u16*)dst;
|
|
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFFFF : 0xFF00;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case PC_TEX_FMT_RGB565:
|
|
|
|
|
{
|
|
|
|
|
u16 *dtp = (u16*)dst;
|
|
|
|
|
dtp[(y + yoff)*width + x + xoff] = ptr[x] ? 0xFFFF : 0x0000;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
case PC_TEX_FMT_BGRA32:
|
|
|
|
|
{
|
|
|
|
|
int *dtp = (int*)dst;
|
|
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFFFFFFFF : 0xFF000000;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
ptr += 9;
|
|
|
|
|
}
|
|
|
|
|
xoff += xcnt;
|
|
|
|
|
fmt++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
PC_TexFormat TexDecoder_Decode(u8 *dst, const u8 *src, int width, int height, int texformat, int tlutaddr, int tlutfmt)
|
|
|
|
|
{
|
2009-09-30 12:58:02 +00:00
|
|
|
#if defined(HAVE_OPENCL) && HAVE_OPENCL
|
2009-09-30 00:28:27 +00:00
|
|
|
PC_TexFormat retval = TexDecoder_Decode_OpenCL(dst, src, width, height, texformat, tlutaddr, tlutfmt);
|
2009-10-07 02:48:21 +00:00
|
|
|
if(retval == PC_TEX_FMT_NONE)
|
|
|
|
|
retval = TexDecoder_Decode_real(dst,src,width,height,texformat,tlutaddr,tlutfmt);
|
2009-09-30 12:58:02 +00:00
|
|
|
#else
|
2009-05-09 07:55:30 +00:00
|
|
|
PC_TexFormat retval = TexDecoder_Decode_real(dst,src,width,height,texformat,tlutaddr,tlutfmt);
|
2009-09-30 12:58:02 +00:00
|
|
|
#endif
|
2009-07-26 09:52:35 +00:00
|
|
|
if ((!TexFmt_Overlay_Enable)|| (retval == PC_TEX_FMT_NONE))
|
2009-05-09 07:55:30 +00:00
|
|
|
return retval;
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-07-26 09:52:35 +00:00
|
|
|
int w = min(width, 40);
|
|
|
|
|
int h = min(height, 10);
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-07-26 09:52:35 +00:00
|
|
|
int xoff = (width - w) >> 1;
|
|
|
|
|
int yoff = (height - h) >> 1;
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-05-09 07:55:30 +00:00
|
|
|
if (!TexFmt_Overlay_Center)
|
|
|
|
|
{
|
|
|
|
|
xoff=0;
|
|
|
|
|
yoff=0;
|
|
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-05-09 07:55:30 +00:00
|
|
|
const char* fmt = texfmt[texformat&15];
|
|
|
|
|
while (*fmt)
|
|
|
|
|
{
|
|
|
|
|
int xcnt = 0;
|
|
|
|
|
int nchar = sfont_map[(int)*fmt];
|
|
|
|
|
|
|
|
|
|
const unsigned char *ptr = sfont_raw[nchar]; // each char is up to 9x10
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-08-11 13:58:35 +00:00
|
|
|
for (int x = 0; x < 9;x++)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
|
|
|
|
if (ptr[x] == 0x78)
|
|
|
|
|
break;
|
|
|
|
|
xcnt++;
|
|
|
|
|
}
|
2009-08-11 13:58:35 +00:00
|
|
|
|
|
|
|
|
for (int y=0; y < 10; y++)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2009-08-11 13:58:35 +00:00
|
|
|
for (int x=0; x < xcnt; x++)
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
2009-07-26 09:52:35 +00:00
|
|
|
switch(retval)
|
|
|
|
|
{
|
2009-05-09 07:55:30 +00:00
|
|
|
case PC_TEX_FMT_I8:
|
|
|
|
|
{
|
|
|
|
|
// TODO: Is this an acceptable way to draw in I8?
|
|
|
|
|
u8 *dtp = (u8*)dst;
|
2009-08-11 13:58:35 +00:00
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFF : 0x88;
|
2009-05-09 07:55:30 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case PC_TEX_FMT_IA8:
|
2009-05-13 02:06:02 +00:00
|
|
|
case PC_TEX_FMT_IA4_AS_IA8:
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
|
|
|
|
u16 *dtp = (u16*)dst;
|
2009-08-11 13:58:35 +00:00
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFFFF : 0xFF00;
|
2009-05-09 07:55:30 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
case PC_TEX_FMT_RGB565:
|
|
|
|
|
{
|
|
|
|
|
u16 *dtp = (u16*)dst;
|
2009-07-26 09:52:35 +00:00
|
|
|
dtp[(y + yoff)*width + x + xoff] = ptr[x] ? 0xFFFF : 0x0000;
|
2009-05-09 07:55:30 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
default:
|
|
|
|
|
case PC_TEX_FMT_BGRA32:
|
|
|
|
|
{
|
|
|
|
|
int *dtp = (int*)dst;
|
2009-08-11 13:58:35 +00:00
|
|
|
dtp[(y + yoff) * width + x + xoff] = ptr[x] ? 0xFFFFFFFF : 0xFF000000;
|
2009-05-09 07:55:30 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-07-26 09:52:35 +00:00
|
|
|
ptr += 9;
|
2009-05-09 07:55:30 +00:00
|
|
|
}
|
2009-07-26 09:52:35 +00:00
|
|
|
xoff += xcnt;
|
2009-05-09 07:55:30 +00:00
|
|
|
fmt++;
|
|
|
|
|
}
|
2008-12-08 05:30:24 +00:00
|
|
|
|
2009-05-09 07:55:30 +00:00
|
|
|
return retval;
|
2008-12-08 05:30:24 +00:00
|
|
|
}
|
|
|
|
|
|
2009-10-10 21:19:39 +00:00
|
|
|
|
|
|
|
|
inline u32 decode565RGBA(u16 val)
|
|
|
|
|
{
|
|
|
|
|
int r,g,b,a;
|
|
|
|
|
r=Convert5To8((val>>11) & 0x1f);
|
|
|
|
|
g=Convert6To8((val>>5 ) & 0x3f);
|
|
|
|
|
b=Convert5To8((val ) & 0x1f);
|
|
|
|
|
a=0xFF;
|
|
|
|
|
return r | (g<<8) | (b << 16) | (a << 24);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline u32 decodeIA8Swapped(u16 val)
|
|
|
|
|
{
|
|
|
|
|
int a = val & 0xFF;
|
|
|
|
|
int i = val >> 8;
|
|
|
|
|
return i | (i<<8) | (i<<16) | (a<<24);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
inline u32 decode5A3RGBA(u16 val)
|
|
|
|
|
{
|
|
|
|
|
int r,g,b,a;
|
|
|
|
|
if ((val&0x8000))
|
|
|
|
|
{
|
|
|
|
|
r=Convert5To8((val>>10) & 0x1f);
|
|
|
|
|
g=Convert5To8((val>>5 ) & 0x1f);
|
|
|
|
|
b=Convert5To8((val ) & 0x1f);
|
|
|
|
|
a=0xFF;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
a=Convert3To8((val>>12) & 0x7);
|
|
|
|
|
r=Convert4To8((val>>8 ) & 0xf);
|
|
|
|
|
g=Convert4To8((val>>4 ) & 0xf);
|
|
|
|
|
b=Convert4To8((val ) & 0xf);
|
|
|
|
|
}
|
|
|
|
|
return r | (g<<8) | (b << 16) | (a << 24);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TexDecoder_DecodeTexel(u8 *dst, const u8 *src, int s, int t, int imageWidth, int texformat, int tlutaddr, int tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
/* General formula for computing texture offset
|
|
|
|
|
//
|
|
|
|
|
u16 sBlk = s / blockWidth;
|
|
|
|
|
u16 tBlk = t / blockHeight;
|
|
|
|
|
u16 widthBlks = (width / blockWidth) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) * blockWidth * blockHeight;
|
|
|
|
|
u16 blkS = s & (blockWidth - 1);
|
|
|
|
|
u16 blkT = t & (blockHeight - 1);
|
|
|
|
|
u32 blkOff = blkT * blockWidth + blkS;
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
switch (texformat)
|
|
|
|
|
{
|
|
|
|
|
case GX_TF_C4:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 3;
|
|
|
|
|
u16 tBlk = t >> 3;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5;
|
|
|
|
|
u16 blkS = s & 7;
|
|
|
|
|
u16 blkT = t & 7;
|
|
|
|
|
u32 blkOff = (blkT << 3) + blkS;
|
|
|
|
|
|
|
|
|
|
int rs = (blkOff & 1)?0:4;
|
|
|
|
|
u32 offset = base + (blkOff >> 1);
|
|
|
|
|
|
|
|
|
|
u8 val = (*(src + offset) >> rs) & 0xF;
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
|
|
|
|
|
switch (tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
*((u32*)dst) = decodeIA8Swapped(tlut[val]);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
*((u32*)dst) = decode565RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
*((u32*)dst) = decode5A3RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_I4:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 3;
|
|
|
|
|
u16 tBlk = t >> 3;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5;
|
|
|
|
|
u16 blkS = s & 7;
|
|
|
|
|
u16 blkT = t & 7;
|
|
|
|
|
u32 blkOff = (blkT << 3) + blkS;
|
|
|
|
|
|
|
|
|
|
int rs = (blkOff & 1)?0:4;
|
|
|
|
|
u32 offset = base + (blkOff >> 1);
|
|
|
|
|
|
|
|
|
|
u8 val = (*(src + offset) >> rs) & 0xF;
|
|
|
|
|
val = Convert4To8(val);
|
|
|
|
|
dst[0] = val;
|
|
|
|
|
dst[1] = val;
|
|
|
|
|
dst[2] = val;
|
|
|
|
|
dst[3] = val;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_I8:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 3;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5;
|
|
|
|
|
u16 blkS = s & 7;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 3) + blkS;
|
|
|
|
|
|
|
|
|
|
u8 val = *(src + base + blkOff);
|
|
|
|
|
dst[0] = val;
|
|
|
|
|
dst[1] = val;
|
|
|
|
|
dst[2] = val;
|
|
|
|
|
dst[3] = val;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_C8:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 3;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5;
|
|
|
|
|
u16 blkS = s & 7;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 3) + blkS;
|
|
|
|
|
|
|
|
|
|
u8 val = *(src + base + blkOff);
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
|
|
|
|
|
switch (tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
*((u32*)dst) = decodeIA8Swapped(tlut[val]);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
*((u32*)dst) = decode565RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
*((u32*)dst) = decode5A3RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_IA4:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 3;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5;
|
|
|
|
|
u16 blkS = s & 7;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 3) + blkS;
|
|
|
|
|
|
|
|
|
|
u8 val = *(src + base + blkOff);
|
|
|
|
|
const u8 a = Convert4To8(val>>4);
|
|
|
|
|
const u8 l = Convert4To8(val&0xF);
|
|
|
|
|
dst[0] = l;
|
|
|
|
|
dst[1] = l;
|
|
|
|
|
dst[2] = l;
|
|
|
|
|
dst[3] = a;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_IA8:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 2;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 2) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 4;
|
|
|
|
|
u16 blkS = s & 3;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 2) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 1;
|
|
|
|
|
const u16* valAddr = (u16*)(src + offset);
|
|
|
|
|
|
|
|
|
|
*((u32*)dst) = decodeIA8Swapped(*valAddr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_C14X2:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 2;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 2) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 4;
|
|
|
|
|
u16 blkS = s & 3;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 2) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 1;
|
|
|
|
|
const u16* valAddr = (u16*)(src + offset);
|
|
|
|
|
|
|
|
|
|
u16 val = Common::swap16(*valAddr) & 0x3FFF;
|
|
|
|
|
u16 *tlut = (u16*)(texMem + tlutaddr);
|
|
|
|
|
|
|
|
|
|
switch (tlutfmt)
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
*((u32*)dst) = decodeIA8Swapped(tlut[val]);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
*((u32*)dst) = decode565RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
*((u32*)dst) = decode5A3RGBA(Common::swap16(tlut[val]));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_RGB565:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 2;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 2) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 4;
|
|
|
|
|
u16 blkS = s & 3;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 2) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 1;
|
|
|
|
|
const u16* valAddr = (u16*)(src + offset);
|
|
|
|
|
|
|
|
|
|
*((u32*)dst) = decode565RGBA(Common::swap16(*valAddr));
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_RGB5A3:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 2;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 2) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 4;
|
|
|
|
|
u16 blkS = s & 3;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 2) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 1;
|
|
|
|
|
const u16* valAddr = (u16*)(src + offset);
|
|
|
|
|
|
|
|
|
|
*((u32*)dst) = decode5A3RGBA(Common::swap16(*valAddr));
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_RGBA8:
|
|
|
|
|
{
|
|
|
|
|
u16 sBlk = s >> 2;
|
|
|
|
|
u16 tBlk = t >> 2;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 2) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 5; // shift by 5 is correct
|
|
|
|
|
u16 blkS = s & 3;
|
|
|
|
|
u16 blkT = t & 3;
|
|
|
|
|
u32 blkOff = (blkT << 2) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 1 ;
|
|
|
|
|
const u8* valAddr = src + offset;
|
|
|
|
|
|
|
|
|
|
dst[3] = valAddr[0];
|
|
|
|
|
dst[0] = valAddr[1];
|
|
|
|
|
dst[1] = valAddr[32];
|
|
|
|
|
dst[2] = valAddr[33];
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GX_TF_CMPR:
|
|
|
|
|
{
|
|
|
|
|
u16 sDxt = s >> 2;
|
|
|
|
|
u16 tDxt = t >> 2;
|
|
|
|
|
|
|
|
|
|
u16 sBlk = sDxt >> 1;
|
|
|
|
|
u16 tBlk = tDxt >> 1;
|
|
|
|
|
u16 widthBlks = (imageWidth >> 3) + 1;
|
|
|
|
|
u32 base = (tBlk * widthBlks + sBlk) << 2;
|
|
|
|
|
u16 blkS = sDxt & 1;
|
|
|
|
|
u16 blkT = tDxt & 1;
|
|
|
|
|
u32 blkOff = (blkT << 1) + blkS;
|
|
|
|
|
|
|
|
|
|
u32 offset = (base + blkOff) << 3;
|
|
|
|
|
|
|
|
|
|
const DXTBlock* dxtBlock = (const DXTBlock*)(src + offset);
|
|
|
|
|
|
|
|
|
|
u16 c1 = Common::swap16(dxtBlock->color1);
|
|
|
|
|
u16 c2 = Common::swap16(dxtBlock->color2);
|
|
|
|
|
int blue1 = Convert5To8(c1 & 0x1F);
|
|
|
|
|
int blue2 = Convert5To8(c2 & 0x1F);
|
|
|
|
|
int green1 = Convert6To8((c1 >> 5) & 0x3F);
|
|
|
|
|
int green2 = Convert6To8((c2 >> 5) & 0x3F);
|
|
|
|
|
int red1 = Convert5To8((c1 >> 11) & 0x1F);
|
|
|
|
|
int red2 = Convert5To8((c2 >> 11) & 0x1F);
|
|
|
|
|
|
|
|
|
|
u16 ss = s & 3;
|
|
|
|
|
u16 tt = t & 3;
|
|
|
|
|
|
|
|
|
|
int colorSel = dxtBlock->lines[tt];
|
|
|
|
|
int rs = 6 - (ss << 1);
|
|
|
|
|
colorSel = (colorSel >> rs) & 3;
|
|
|
|
|
colorSel |= c1 > c2?0:4;
|
|
|
|
|
|
|
|
|
|
u32 color = 0;
|
|
|
|
|
|
|
|
|
|
switch (colorSel)
|
|
|
|
|
{
|
|
|
|
|
case 0:
|
|
|
|
|
case 4:
|
|
|
|
|
color = makeRGBA(red1, green1, blue1, 255);
|
|
|
|
|
break;
|
|
|
|
|
case 1:
|
|
|
|
|
case 5:
|
|
|
|
|
color = makeRGBA(red2, green2, blue2, 255);
|
|
|
|
|
break;
|
|
|
|
|
case 2:
|
|
|
|
|
color = makeRGBA(red1+(red2-red1)/3, green1+(green2-green1)/3, blue1+(blue2-blue1)/3, 255);
|
|
|
|
|
break;
|
|
|
|
|
case 3:
|
|
|
|
|
color = makeRGBA(red2+(red1-red2)/3, green2+(green1-green2)/3, blue2+(blue1-blue2)/3, 255);
|
|
|
|
|
break;
|
|
|
|
|
case 6:
|
|
|
|
|
color = makeRGBA((int)ceil((float)(red1+red2)/2), (int)ceil((float)(green1+green2)/2), (int)ceil((float)(blue1+blue2)/2), 255);
|
|
|
|
|
break;
|
|
|
|
|
case 7:
|
|
|
|
|
color = makeRGBA(red2, green2, blue2, 0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*((u32*)dst) = color;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-12-08 05:30:24 +00:00
|
|
|
const char* texfmt[] = {
|
2009-05-09 07:55:30 +00:00
|
|
|
// pixel
|
|
|
|
|
"I4", "I8", "IA4", "IA8",
|
|
|
|
|
"RGB565", "RGB5A3", "RGBA8", "C4",
|
|
|
|
|
"C8", "C14X2", "0x0A", "0x0B",
|
|
|
|
|
"0x0C", "0x0D", "CMPR", "0x0F",
|
|
|
|
|
// Z-buffer
|
|
|
|
|
"0x10", "Z8", "0x12", "Z16",
|
|
|
|
|
"0x14", "0x15", "Z24X8", "0x17",
|
|
|
|
|
"0x18", "0x19", "0x1A", "0x1B",
|
|
|
|
|
"0x1C", "0x1D", "0x1E", "0x1F",
|
|
|
|
|
// pixel + copy
|
|
|
|
|
"CR4", "0x21", "CRA4", "CRA8",
|
|
|
|
|
"0x24", "0x25", "CYUVA8", "CA8",
|
|
|
|
|
"CR8", "CG8", "CB8", "CRG8",
|
|
|
|
|
"CGB8", "0x2D", "0x2E", "0x2F",
|
|
|
|
|
// Z + copy
|
|
|
|
|
"CZ4", "0x31", "0x32", "0x33",
|
|
|
|
|
"0x34", "0x35", "0x36", "0x37",
|
|
|
|
|
"0x38", "CZ8M", "CZ8L", "0x3B",
|
|
|
|
|
"CZ16L", "0x3D", "0x3E", "0x3F",
|
2008-12-08 05:30:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const unsigned char sfont_map[] = {
|
2009-05-09 07:55:30 +00:00
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,10,10,10,10,10,
|
|
|
|
|
10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,
|
|
|
|
|
26,27,28,29,30,31,32,33,34,35,36,10,10,10,10,10,
|
|
|
|
|
10,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
|
|
|
|
|
52,53,54,55,56,57,58,59,60,61,62,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
|
|
|
|
10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
|
2008-12-08 05:30:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const unsigned char sfont_raw[][9*10] = {
|
2009-05-09 07:55:30 +00:00
|
|
|
{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0x00, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},{
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0x00, 0x00, 0x00, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0x78, 0x78, 0x78, 0x78,
|
|
|
|
|
},
|
2008-12-08 05:30:24 +00:00
|
|
|
};
|