diff options
Diffstat (limited to 'Minecraft.Client/Textures.cpp')
| -rw-r--r-- | Minecraft.Client/Textures.cpp | 1404 |
1 files changed, 1404 insertions, 0 deletions
diff --git a/Minecraft.Client/Textures.cpp b/Minecraft.Client/Textures.cpp new file mode 100644 index 00000000..ce7a9bfc --- /dev/null +++ b/Minecraft.Client/Textures.cpp @@ -0,0 +1,1404 @@ +#include "stdafx.h" +#include "Textures.h" +#include "TexturePackRepository.h" +#include "HttpTexture.h" +#include "MemTexture.h" +#include "..\Minecraft.World\InputStream.h" +#include "..\Minecraft.World\IntBuffer.h" +#include "..\Minecraft.World\ByteBuffer.h" +#include "TexturePack.h" +#include "Options.h" +#include "..\Minecraft.Client\MemTextureProcessor.h" +#include "MobSkinMemTextureProcessor.h" +#include "PreStitchedTextureMap.h" +#include "StitchedTexture.h" +#include "Texture.h" +#include "..\Minecraft.World\net.minecraft.world.h" +#include "..\Minecraft.World\net.minecraft.world.level.h" +#include "..\Minecraft.World\StringHelpers.h" + +bool Textures::MIPMAP = true; +C4JRender::eTextureFormat Textures::TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGyBzAw; + +int Textures::preLoadedIdx[TN_COUNT]; +wchar_t *Textures::preLoaded[TN_COUNT] = +{ + L"%blur%misc/pumpkinblur", +// L"%blur%/misc/vignette", // Not currently used + L"%clamp%misc/shadow", +// L"/achievement/bg", // Not currently used + L"art/kz", + L"environment/clouds", + L"environment/rain", + L"environment/snow", + L"gui/gui", + L"gui/icons", + L"item/arrows", + L"item/boat", + L"item/cart", + L"item/sign", + L"misc/mapbg", + L"misc/mapicons", + L"misc/water", + L"misc/footprint", + L"mob/saddle", + L"mob/sheep_fur", + L"mob/spider_eyes", + L"particles", + L"mob/chicken", + L"mob/cow", + L"mob/pig", + L"mob/sheep", + L"mob/squid", + L"mob/wolf", + L"mob/wolf_tame", + L"mob/wolf_angry", + L"mob/creeper", + L"mob/ghast", + L"mob/ghast_fire", + L"mob/zombie", + L"mob/pigzombie", + L"mob/skeleton", + L"mob/slime", + L"mob/spider", + L"mob/char", + L"mob/char1", + L"mob/char2", + L"mob/char3", + L"mob/char4", + L"mob/char5", + L"mob/char6", + L"mob/char7", + L"terrain/moon", + L"terrain/sun", + L"armor/power", + + // 1.8.2 + L"mob/cavespider", + L"mob/enderman", + L"mob/silverfish", + L"mob/enderman_eyes", + L"misc/explosion", + L"item/xporb", + L"item/chest", + L"item/largechest", + + // 1.3.2 + L"item/enderchest", + + // 1.0.1 + L"mob/redcow", + L"mob/snowman", + L"mob/enderdragon/ender", + L"mob/fire", + L"mob/lava", + L"mob/villager/villager", + L"mob/villager/farmer", + L"mob/villager/librarian", + L"mob/villager/priest", + L"mob/villager/smith", + L"mob/villager/butcher", + L"mob/enderdragon/crystal", + L"mob/enderdragon/shuffle", + L"mob/enderdragon/beam", + L"mob/enderdragon/ender_eyes", + L"%blur%misc/glint", + L"item/book", + L"misc/tunnel", + L"misc/particlefield", + L"terrain/moon_phases", + + // 1.2.3 + L"mob/ozelot", + L"mob/cat_black", + L"mob/cat_red", + L"mob/cat_siamese", + L"mob/villager_golem", + L"mob/skeleton_wither", + + // TU 14 + L"mob/wolf_collar", + L"mob/zombie_villager", + +#ifdef _LARGE_WORLDS + L"misc/additionalmapicons", +#endif + + L"font/Default", + L"font/alternate", + + // skin packs +/* L"/SP1", + L"/SP2", + L"/SP3", + L"/SPF", + + // themes + L"/ThSt", + L"/ThIr", + L"/ThGo", + L"/ThDi", + + // gamerpics + L"/GPAn", + L"/GPCo", + L"/GPEn", + L"/GPFo", + L"/GPTo", + L"/GPBA", + L"/GPFa", + L"/GPME", + L"/GPMF", + L"/GPMM", + L"/GPSE", + + // avatar items + + L"/AH_0006", + L"/AH_0003", + L"/AH_0007", + L"/AH_0005", + L"/AH_0004", + L"/AH_0001", + L"/AH_0002", + L"/AT_0001", + L"/AT_0002", + L"/AT_0003", + L"/AT_0004", + L"/AT_0005", + L"/AT_0006", + L"/AT_0007", + L"/AT_0008", + L"/AT_0009", + L"/AT_0010", + L"/AT_0011", + L"/AT_0012", + L"/AP_0001", + L"/AP_0002", + L"/AP_0003", + L"/AP_0004", + L"/AP_0005", + L"/AP_0006", + L"/AP_0007", + L"/AP_0009", + L"/AP_0010", + L"/AP_0011", + L"/AP_0012", + L"/AP_0013", + L"/AP_0014", + L"/AP_0015", + L"/AP_0016", + L"/AP_0017", + L"/AP_0018", + L"/AA_0001", + L"/AT_0013", + L"/AT_0014", + L"/AT_0015", + L"/AT_0016", + L"/AT_0017", + L"/AT_0018", + L"/AP_0019", + L"/AP_0020", + L"/AP_0021", + L"/AP_0022", + L"/AP_0023", + L"/AH_0008", + L"/AH_0009",*/ + + L"gui/items", + L"terrain", +}; + +Textures::Textures(TexturePackRepository *skins, Options *options) +{ +// pixels = MemoryTracker::createIntBuffer(2048 * 2048); // 4J removed - now just creating this buffer when we need it + missingNo = new BufferedImage(16, 16, BufferedImage::TYPE_INT_ARGB); + + this->skins = skins; + this->options = options; + + /* 4J - TODO, maybe... + Graphics g = missingNo.getGraphics(); + g.setColor(Color.WHITE); + g.fillRect(0, 0, 64, 64); + g.setColor(Color.BLACK); + int y = 10; + int i = 0; + while (y < 64) { + String text = (i++ % 2 == 0) ? "missing" : "texture"; + g.drawString(text, 1, y); + y += g.getFont().getSize(); + if (i % 2 == 0) y += 5; + } + + g.dispose(); + */ + + // 4J Stu - Changed these to our PreStitchedTextureMap from TextureMap + terrain = new PreStitchedTextureMap(Icon::TYPE_TERRAIN, L"terrain", L"textures/blocks/", missingNo, true); + items = new PreStitchedTextureMap(Icon::TYPE_ITEM, L"items", L"textures/items/", missingNo, true); + + // 4J - added - preload a set of commonly used textures that can then be referenced directly be an enumerated type rather by string + loadIndexedTextures(); +} + +void Textures::loadIndexedTextures() +{ + // 4J - added - preload a set of commonly used textures that can then be referenced directly be an enumerated type rather by string + for( int i = 0; i < TN_COUNT - 2; i++ ) + { + preLoadedIdx[i] = loadTexture((TEXTURE_NAME)i, wstring(preLoaded[i]) + L".png"); + } +} + +intArray Textures::loadTexturePixels(TEXTURE_NAME texId, const wstring& resourceName) +{ + TexturePack *skin = skins->getSelected(); + + { + intArray id = pixelsMap[resourceName]; + // 4J - if resourceName isn't in the map, it should add an element and as that will use the default constructor, its + // internal data pointer will be NULL + if (id.data != NULL) return id; + } + + // 4J - removed try/catch +// try { + intArray res; + //wstring in = skin->getResource(resourceName); + if (false)// 4J - removed - was ( in == NULL) + { + res = loadTexturePixels(missingNo); + } + else + { + BufferedImage *bufImage = readImage(texId, resourceName); //in); + res = loadTexturePixels(bufImage); + delete bufImage; + } + + pixelsMap[resourceName] = res; + return res; +/* +} + catch (IOException e) { + e.printStackTrace(); + int[] res = loadTexturePixels(missingNo); + pixelsMap.put(resourceName, res); + return res; + } + */ +} + +intArray Textures::loadTexturePixels(BufferedImage *img) +{ + int w = img->getWidth(); + int h = img->getHeight(); + intArray pixels(w*h); + return loadTexturePixels(img, pixels); +} + +intArray Textures::loadTexturePixels(BufferedImage *img, intArray pixels) +{ + int w = img->getWidth(); + int h = img->getHeight(); + img->getRGB(0, 0, w, h, pixels, 0, w); + return pixels; +} + +int Textures::loadTexture(int idx) +{ + if( idx == -1 ) + { + return 0; + } + else + { + if ( idx == TN_TERRAIN ) + { + terrain->getStitchedTexture()->bind(0); + return terrain->getStitchedTexture()->getGlId(); + } + if ( idx == TN_GUI_ITEMS) + { + items->getStitchedTexture()->bind(0); + return items->getStitchedTexture()->getGlId(); + } + return preLoadedIdx[idx]; + } +} + +// 4J added - textures default to standard 32-bit RGBA format, but where we can, use an 8-bit format. There's 3 different varieties of these currently +// in the renderer that map the single 8-bit channel to RGBA differently. +void Textures::setTextureFormat(const wstring& resourceName) +{ + // 4J Stu - These texture formats are not currently in the render header +#ifdef _XBOX + if(resourceName == L"/environment/clouds.png") + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_R1G1B1Ax; + } + else if(resourceName == L"%blur%/misc/pumpkinblur.png") + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_R0G0B0Ax; + } + else if(resourceName == L"%clamp%/misc/shadow.png") + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_R0G0B0Ax; + } + else if(resourceName == L"/environment/snow.png") + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGxBxAx; + } + else if(resourceName == L"/1_2_2/misc/explosion.png") + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGxBxAx; + } + else +#endif + { + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGyBzAw; + } +} + +void Textures::bindTexture(const wstring &resourceName) +{ + bind(loadTexture(TN_COUNT,resourceName)); +} + +// 4J Added +void Textures::bindTexture(int resourceId) +{ + bind(loadTexture(resourceId)); +} + +void Textures::bind(int id) +{ + //if (id != lastBoundId) + { + if(id < 0) return; + glBindTexture(GL_TEXTURE_2D, id); + // lastBoundId = id; + } +} + +void Textures::clearLastBoundId() +{ + lastBoundId = -1; +} + +int Textures::loadTexture(TEXTURE_NAME texId, const wstring& resourceName) +{ +// char buf[256]; +// wcstombs(buf, resourceName.c_str(), 256); +// printf("Textures::loadTexture name - %s\n",buf); + + //if (resourceName.compare(L"/terrain.png") == 0) + //{ + // terrain->getStitchedTexture()->bind(0); + // return terrain->getStitchedTexture()->getGlId(); + //} + //if (resourceName.compare(L"/gui/items.png") == 0) + //{ + // items->getStitchedTexture()->bind(0); + // return items->getStitchedTexture()->getGlId(); + //} + + // If the texture is not present in the idMap, load it, otherwise return its id + + { + bool inMap = ( idMap.find(resourceName) != idMap.end() ); + int id = idMap[resourceName]; + if (inMap) return id; + } + + wstring pathName = resourceName; + + // 4J - added special cases to avoid mipmapping on clouds & shadows + if( (resourceName == L"environment/clouds.png") || + (resourceName == L"%clamp%misc/shadow.png") || + (resourceName == L"%blur%misc/pumpkinblur.png") || + (resourceName == L"%clamp%misc/shadow.png") || + (resourceName == L"gui/icons.png" ) || + (resourceName == L"gui/gui.png" ) || + (resourceName == L"misc/footprint.png") ) + { + MIPMAP = false; + } + setTextureFormat(resourceName); + + // 4J - removed try/catch +// try { + int id = MemoryTracker::genTextures(); + + + wstring prefix = L"%blur%"; + bool blur = resourceName.substr(0, prefix.size()).compare(prefix) == 0; //resourceName.startsWith("%blur%"); + if (blur) pathName = resourceName.substr(6); + + prefix = L"%clamp%"; + bool clamp = resourceName.substr(0, prefix.size()).compare(prefix) == 0; //resourceName.startsWith("%clamp%"); + if (clamp) pathName = resourceName.substr(7); + + //wstring in = skins->getSelected()->getResource(pathName); + if (false ) // 4J - removed was ( in == NULL) + { + loadTexture(missingNo, id, blur, clamp); + } + else + { + // 4J Stu - Get resource above just returns the name for texture packs + BufferedImage *bufImage = readImage(texId, pathName); //in); + loadTexture(bufImage, id, blur, clamp); + delete bufImage; + } + + idMap[resourceName] = id; + MIPMAP = true; // 4J added + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGyBzAw; + return id; + /* + } catch (IOException e) { + e.printStackTrace(); + MemoryTracker.genTextures(ib); + int id = ib.get(0); + loadTexture(missingNo, id); + idMap.put(resourceName, id); + return id; + } + */ +} + +int Textures::getTexture(BufferedImage *img, C4JRender::eTextureFormat format, bool mipmap) +{ + int id = MemoryTracker::genTextures(); + TEXTURE_FORMAT = format; + MIPMAP = mipmap; + loadTexture(img, id); + TEXTURE_FORMAT = C4JRender::TEXTURE_FORMAT_RxGyBzAw; + MIPMAP = true; + loadedImages[id] = img; + return id; +} + +void Textures::loadTexture(BufferedImage *img, int id) +{ +// printf("Textures::loadTexture BufferedImage %d\n",id); + + loadTexture(img, id, false, false); +} + +void Textures::loadTexture(BufferedImage *img, int id, bool blur, bool clamp) +{ +// printf("Textures::loadTexture BufferedImage with blur and clamp %d\n",id); + int iMipLevels=1; + MemSect(33); + glBindTexture(GL_TEXTURE_2D, id); + + if (MIPMAP) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + /* + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4); + */ + } + else + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + if (blur) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + + if (clamp) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); + } + else + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + } + + int w = img->getWidth(); + int h = img->getHeight(); + + intArray rawPixels(w*h); + img->getRGB(0, 0, w, h, rawPixels, 0, w); + + if (options != NULL && options->anaglyph3d) + { + rawPixels = anaglyph(rawPixels); + } + + byteArray newPixels(w * h * 4); + for (unsigned int i = 0; i < rawPixels.length; i++) + { + int a = (rawPixels[i] >> 24) & 0xff; + int r = (rawPixels[i] >> 16) & 0xff; + int g = (rawPixels[i] >> 8) & 0xff; + int b = (rawPixels[i]) & 0xff; + +#ifdef _XBOX + newPixels[i * 4 + 0] = (byte) a; + newPixels[i * 4 + 1] = (byte) r; + newPixels[i * 4 + 2] = (byte) g; + newPixels[i * 4 + 3] = (byte) b; +#else + newPixels[i * 4 + 0] = (byte) r; + newPixels[i * 4 + 1] = (byte) g; + newPixels[i * 4 + 2] = (byte) b; + newPixels[i * 4 + 3] = (byte) a; +#endif + } + // 4J - now creating a buffer of the size we require dynamically + ByteBuffer *pixels = MemoryTracker::createByteBuffer(w * h * 4); + pixels->clear(); + pixels->put(newPixels); + pixels->position(0)->limit(newPixels.length); + + delete[] rawPixels.data; + delete[] newPixels.data; + + if (MIPMAP) + { + // 4J-PB - In the new XDK, the CreateTexture will fail if the number of mipmaps is higher than the width & height passed in will allow! + int iWidthMips=1; + int iHeightMips=1; + while((8<<iWidthMips)<w) iWidthMips++; + while((8<<iHeightMips)<h) iHeightMips++; + + iMipLevels=(iWidthMips<iHeightMips)?iWidthMips:iHeightMips; + //RenderManager.TextureSetTextureLevels(5); // 4J added + if(iMipLevels>5)iMipLevels = 5; + RenderManager.TextureSetTextureLevels(iMipLevels); // 4J added + } + RenderManager.TextureData(w,h,pixels->getBuffer(),0,TEXTURE_FORMAT); + //glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, pixels); + + if (MIPMAP) + { + for (int level = 1; level < iMipLevels; level++) + { + int ow = w >> (level - 1); + // int oh = h >> (level - 1); + + int ww = w >> level; + int hh = h >> level; + + // 4J - added tempData so we aren't overwriting source data + unsigned int *tempData = new unsigned int[ww * hh]; + // 4J - added - have we loaded mipmap data for this level? Use that rather than generating if possible + if( img->getData( level ) ) + { + memcpy( tempData, img->getData( level ), ww * hh * 4); +#ifndef _XBOX + // Swap ARGB to RGBA + for( int i = 0; i < ww * hh ; i++ ) + { + tempData[i] = ( tempData[i] >> 24 ) | (tempData[i] << 8 ); + } +#endif + } + else + { + for (int x = 0; x < ww; x++) + for (int y = 0; y < hh; y++) + { + int c0 = pixels->getInt(((x * 2 + 0) + (y * 2 + 0) * ow) * 4); + int c1 = pixels->getInt(((x * 2 + 1) + (y * 2 + 0) * ow) * 4); + int c2 = pixels->getInt(((x * 2 + 1) + (y * 2 + 1) * ow) * 4); + int c3 = pixels->getInt(((x * 2 + 0) + (y * 2 + 1) * ow) * 4); +#ifndef _XBOX + // 4J - convert our RGBA texels to ARGB that crispBlend is expecting + c0 = ( ( c0 >> 8 ) & 0x00ffffff ) | ( c0 << 24 ); + c1 = ( ( c1 >> 8 ) & 0x00ffffff ) | ( c1 << 24 ); + c2 = ( ( c2 >> 8 ) & 0x00ffffff ) | ( c2 << 24 ); + c3 = ( ( c3 >> 8 ) & 0x00ffffff ) | ( c3 << 24 ); +#endif + int col = Texture::crispBlend(Texture::crispBlend(c0, c1), Texture::crispBlend(c2, c3)); +#ifndef _XBOX + // 4J - and back from ARGB -> RGBA + col = ( col << 8 ) | (( col >> 24 ) & 0xff); +#endif + tempData[x + y * ww] = col; + } + } + for (int x = 0; x < ww; x++ ) + for (int y = 0; y < hh; y++) + { + pixels->putInt((x + y * ww) * 4, tempData[x + y * ww]); + } + delete [] tempData; + RenderManager.TextureData(ww,hh,pixels->getBuffer(),level,TEXTURE_FORMAT); + } + } + + /* + * if (MIPMAP) { GLU.gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, w, h, + * GL_RGBA, GL_UNSIGNED_BYTE, pixels); } else { } + */ + delete pixels; // 4J - now creating this dynamically + MemSect(0); +} + +intArray Textures::anaglyph(intArray rawPixels) +{ + intArray result(rawPixels.length); + for (unsigned int i = 0; i < rawPixels.length; i++) + { + int a = (rawPixels[i] >> 24) & 0xff; + int r = (rawPixels[i] >> 16) & 0xff; + int g = (rawPixels[i] >> 8) & 0xff; + int b = (rawPixels[i]) & 0xff; + + int rr = (r * 30 + g * 59 + b * 11) / 100; + int gg = (r * 30 + g * 70) / (100); + int bb = (r * 30 + b * 70) / (100); + + + result[i] = a << 24 | rr << 16 | gg << 8 | bb; + } + + delete[] rawPixels.data; + + return result; +} + +void Textures::replaceTexture(intArray rawPixels, int w, int h, int id) +{ + bind(id); + + // Removed in Java +#if 0 + if (MIPMAP) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + /* + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4); + */ + } + else +#endif + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + if (options != NULL && options->anaglyph3d) + { + rawPixels = anaglyph(rawPixels); + } + + byteArray newPixels(w * h * 4); + for (unsigned int i = 0; i < rawPixels.length; i++) + { + int a = (rawPixels[i] >> 24) & 0xff; + int r = (rawPixels[i] >> 16) & 0xff; + int g = (rawPixels[i] >> 8) & 0xff; + int b = (rawPixels[i]) & 0xff; + + if (options != NULL && options->anaglyph3d) + { + int rr = (r * 30 + g * 59 + b * 11) / 100; + int gg = (r * 30 + g * 70) / (100); + int bb = (r * 30 + b * 70) / (100); + + r = rr; + g = gg; + b = bb; + } + + newPixels[i * 4 + 0] = (byte) r; + newPixels[i * 4 + 1] = (byte) g; + newPixels[i * 4 + 2] = (byte) b; + newPixels[i * 4 + 3] = (byte) a; + } + ByteBuffer *pixels = MemoryTracker::createByteBuffer(w * h * 4); // 4J - now creating dynamically + pixels->put(newPixels); + pixels->position(0)->limit(newPixels.length); + delete [] newPixels.data; + + // New + // glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8_REV, pixels); +#ifdef _XBOX + RenderManager.TextureDataUpdate(pixels->getBuffer(),0); +#else + RenderManager.TextureDataUpdate(0, 0,w,h,pixels->getBuffer(),0); +#endif + // Old + //glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + delete pixels; +} + +// 4J - added. This is a more minimal version of replaceTexture that assumes the texture bytes are already in order, and so doesn't do any of the extra copying round +// that the original java version does +void Textures::replaceTextureDirect(intArray rawPixels, int w, int h, int id) +{ + glBindTexture(GL_TEXTURE_2D, id); + + // Remove in Java +#if 0 + if (MIPMAP) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + /* + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4); + */ + } + else +#endif + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + +#ifdef _XBOX + RenderManager.TextureDataUpdate(rawPixels.data, 0); +#else + RenderManager.TextureDataUpdate(0, 0, w, h, rawPixels.data, 0); +#endif +} + +// 4J - added. This is a more minimal version of replaceTexture that assumes the texture bytes are already in order, and so doesn't do any of the extra copying round +// that the original java version does +void Textures::replaceTextureDirect(shortArray rawPixels, int w, int h, int id) +{ + glBindTexture(GL_TEXTURE_2D, id); + + // Remove in Java +#if 0 + if (MIPMAP) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + /* + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_LOD, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); + * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 4); + */ + } + else +#endif + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + +#ifdef _XBOX + RenderManager.TextureDataUpdate(rawPixels.data, 0); +#else + RenderManager.TextureDataUpdate(0, 0, w, h, rawPixels.data, 0); +#endif +} + +void Textures::releaseTexture(int id) +{ + loadedImages.erase(id); + glDeleteTextures(id); +} + +int Textures::loadHttpTexture(const wstring& url, const wstring& backup) +{ + HttpTexture *texture = httpTextures[url]; + if (texture != NULL) + { + if (texture->loadedImage != NULL && !texture->isLoaded) + { + if (texture->id < 0) + { + texture->id = getTexture(texture->loadedImage); + } + else + { + loadTexture(texture->loadedImage, texture->id); + } + texture->isLoaded = true; + } + } + if (texture == NULL || texture->id < 0) + { + if (backup.empty() ) return -1; + return loadTexture(TN_COUNT, backup); + } + return texture->id; +} + +int Textures::loadHttpTexture(const wstring& url, int backup) +{ + HttpTexture *texture = httpTextures[url]; + if (texture != NULL) + { + if (texture->loadedImage != NULL && !texture->isLoaded) + { + if (texture->id < 0) + { + texture->id = getTexture(texture->loadedImage); + } + else + { + loadTexture(texture->loadedImage, texture->id); + } + texture->isLoaded = true; + } + } + if (texture == NULL || texture->id < 0) + { + return loadTexture(backup); + } + return texture->id; +} + +bool Textures::hasHttpTexture(const wstring &url) +{ + return httpTextures.find(url) != httpTextures.end(); +} + +HttpTexture *Textures::addHttpTexture(const wstring& url, HttpTextureProcessor *processor) +{ + HttpTexture *texture = httpTextures[url]; + if (texture == NULL) + { + httpTextures[url] = new HttpTexture(url, processor); + } + else + { + texture->count++; + } + return texture; +} + +void Textures::removeHttpTexture(const wstring& url) +{ + HttpTexture *texture = httpTextures[url]; + if (texture != NULL) + { + texture->count--; + if (texture->count == 0) + { + if (texture->id >= 0) releaseTexture(texture->id); + httpTextures.erase(url); + } + } +} + +// 4J-PB - adding for texture in memory (from global title storage) +int Textures::loadMemTexture(const wstring& url, const wstring& backup) +{ + MemTexture *texture = NULL; + AUTO_VAR(it, memTextures.find(url) ); + if (it != memTextures.end()) + { + texture = (*it).second; + } + if(texture == NULL && app.IsFileInMemoryTextures(url)) + { + // If we haven't loaded it yet, but we have the data for it then add it + texture = addMemTexture(url, new MobSkinMemTextureProcessor() ); + } + if(texture != NULL) + { + if (texture->loadedImage != NULL && !texture->isLoaded) + { + // 4J - Disable mipmapping in general for skins & capes. Have seen problems with edge-on polys for some eg mumbo jumbo + if( ( url.substr(0,7) == L"dlcskin" ) || + ( url.substr(0,7) == L"dlccape" ) ) + { + MIPMAP = false; + } + + if (texture->id < 0) + { + texture->id = getTexture(texture->loadedImage, C4JRender::TEXTURE_FORMAT_RxGyBzAw, MIPMAP); + } + else + { + loadTexture(texture->loadedImage, texture->id); + } + texture->isLoaded = true; + MIPMAP = true; + } + } + if (texture == NULL || texture->id < 0) + { + if (backup.empty() ) return -1; + return loadTexture(TN_COUNT,backup); + } + return texture->id; +} + +int Textures::loadMemTexture(const wstring& url, int backup) +{ + MemTexture *texture = NULL; + AUTO_VAR(it, memTextures.find(url) ); + if (it != memTextures.end()) + { + texture = (*it).second; + } + if(texture == NULL && app.IsFileInMemoryTextures(url)) + { + // If we haven't loaded it yet, but we have the data for it then add it + texture = addMemTexture(url, new MobSkinMemTextureProcessor() ); + } + if(texture != NULL) + { + texture->ticksSinceLastUse = 0; + if (texture->loadedImage != NULL && !texture->isLoaded) + { + // 4J - Disable mipmapping in general for skins & capes. Have seen problems with edge-on polys for some eg mumbo jumbo + if( ( url.substr(0,7) == L"dlcskin" ) || + ( url.substr(0,7) == L"dlccape" ) ) + { + MIPMAP = false; + } + if (texture->id < 0) + { + texture->id = getTexture(texture->loadedImage, C4JRender::TEXTURE_FORMAT_RxGyBzAw, MIPMAP); + } + else + { + loadTexture(texture->loadedImage, texture->id); + } + texture->isLoaded = true; + MIPMAP = true; + } + } + if (texture == NULL || texture->id < 0) + { + return loadTexture(backup); + } + return texture->id; +} + +MemTexture *Textures::addMemTexture(const wstring& name,MemTextureProcessor *processor) +{ + MemTexture *texture = NULL; + AUTO_VAR(it, memTextures.find(name) ); + if (it != memTextures.end()) + { + texture = (*it).second; + } + if(texture == NULL) + { + // can we find it in the app mem files? + PBYTE pbData=NULL; + DWORD dwBytes=0; + app.GetMemFileDetails(name,&pbData,&dwBytes); + + if(dwBytes!=0) + { + texture = new MemTexture(name, pbData, dwBytes, processor); + memTextures[name] = texture; + } + else + { + // 4J Stu - Make an entry for this anyway and we can populate it later + memTextures[name] = NULL; + } + } + else + { + texture->count++; + } + + delete processor; + + return texture; +} + +// MemTexture *Textures::getMemTexture(const wstring& url, MemTextureProcessor *processor) +// { +// MemTexture *texture = memTextures[url]; +// if (texture != NULL) +// { +// texture->count++; +// } +// return texture; +// } + +void Textures::removeMemTexture(const wstring& url) +{ + MemTexture *texture = NULL; + AUTO_VAR(it, memTextures.find(url) ); + if (it != memTextures.end()) + { + texture = (*it).second; + + // If it's NULL then we should just remove the entry + if( texture == NULL ) memTextures.erase(url); + } + if(texture != NULL) + { + texture->count--; + if (texture->count == 0) + { + if (texture->id >= 0) releaseTexture(texture->id); + memTextures.erase(url); + delete texture; + } + } +} + +void Textures::tick(bool updateTextures, bool tickDynamics) // 4J added updateTextures parameter & tickDynamics +{ + MemSect(22); + if(tickDynamics) + { + // 4J - added - if we aren't updating the final renderer textures, just tick each of the dynamic textures instead. This is used so that in frames were we have multiple + // ticks due to framerate compensation, that we don't lock the renderer textures twice needlessly and force the CPU to sync with the GPU. + if( !updateTextures ) + { + MemSect(0); + return; + } + + // 4J - added - tell renderer that we're about to do a block of dynamic texture updates, so we can unlock the resources after they are done rather than a series of locks/unlocks + //RenderManager.TextureDynamicUpdateStart(); + terrain->cycleAnimationFrames(); + items->cycleAnimationFrames(); + //RenderManager.TextureDynamicUpdateEnd(); // 4J added - see comment above + } + + // 4J - go over all the memory textures once per frame, and free any that haven't been used for a while. Ones that are being used will + // have their ticksSinceLastUse reset in Textures::loadMemTexture. + for( AUTO_VAR(it, memTextures.begin() ); it != memTextures.end(); ) + { + MemTexture *tex = it->second; + + if( tex && ( ++tex->ticksSinceLastUse > MemTexture::UNUSED_TICKS_TO_FREE ) ) + { + if (tex->id >= 0) releaseTexture(tex->id); + delete tex; + it = memTextures.erase(it); + } + else + { + it++; + } + + } + MemSect(0); +} + +void Textures::reloadAll() +{ + TexturePack *skin = skins->getSelected(); + + for( int i = 0; i < TN_COUNT - 2; i++ ) + { + releaseTexture(preLoadedIdx[i]); + } + + idMap.clear(); + loadedImages.clear(); + + loadIndexedTextures(); + + pixelsMap.clear(); + // 4J Stu - These are not used any more + //WaterColor::init(loadTexturePixels(L"misc/watercolor.png")); + //GrassColor::init(loadTexturePixels(L"misc/grasscolor.png")); + //FoliageColor::init(loadTexturePixels(L"misc/foliagecolor.png")); + + stitch(); + + skins->clearInvalidTexturePacks(); + +#if 0 + AUTO_VAR(itEndLI, loadedImages.end() ); + for(unordered_map<int, BufferedImage *>::iterator it = loadedImages.begin(); it != itEndLI; it++ ) + { + BufferedImage *image = it->second; + loadTexture(image, it->first); + } + + AUTO_VAR(itEndHT, httpTextures.end()); + for(unordered_map<wstring, HttpTexture *>::iterator it = httpTextures.begin(); it != itEndHT; it++ ) + { + it->second->isLoaded = false; + } + + AUTO_VAR(itEndMT, memTextures.end()); + for(unordered_map<wstring, MemTexture *>::iterator it = memTextures.begin(); it != itEndMT; it++ ) + { + it->second->isLoaded = false; + } + + + AUTO_VAR(itEndIM, idMap.end()); + for( unordered_map<wstring, int>::iterator it = idMap.begin(); it != itEndIM; it++ ) + { + wstring name = it->first; + + int id = idMap[name]; + BufferedImage *image; + + wstring prefix = L"%blur%"; + bool blur = name.substr(0, prefix.size()).compare(prefix) == 0; //name.startsWith("%blur%"); + if (blur) name = name.substr(6); + + prefix = L"%clamp%"; + bool clamp = name.substr(0, prefix.size()).compare(prefix) == 0; //name.startsWith("%clamp%"); + if (clamp) name = name.substr(7); + + image = readImage(skin->getResource(name)); + + loadTexture(image, id, blur, clamp); + delete image; + } + AUTO_VAR(itEndPM, pixelsMap.end()); + for( unordered_map<wstring, intArray>::iterator it = pixelsMap.begin(); it != itEndPM; it++ ) + { + wstring name = it->first; + BufferedImage *image = readImage(skin->getResource(name)); + + loadTexturePixels(image, pixelsMap[name]); + delete image; + } +#endif + + // Recalculate fonts + //Minecraft::GetInstance()->font->loadCharacterWidths(); + //Minecraft::GetInstance()->altFont->loadCharacterWidths(); +} + +void Textures::stitch() +{ + terrain->stitch(); + items->stitch(); +} + +Icon *Textures::getMissingIcon(int type) +{ + switch (type) + { + case Icon::TYPE_ITEM: + default: + return items->getMissingIcon(); + case Icon::TYPE_TERRAIN: + return terrain->getMissingIcon(); + } +} + +BufferedImage *Textures::readImage(TEXTURE_NAME texId, const wstring& name) // 4J was InputStream *in +{ + BufferedImage *img=NULL; + MemSect(32); + // is this image one of the Title Update ones? + bool isTu = IsTUImage(texId, name); + wstring drive = L""; + + if(!skins->isUsingDefaultSkin() && skins->getSelected()->hasFile(L"res/" + name,false)) + { + drive = skins->getSelected()->getPath(isTu); + img = skins->getSelected()->getImageResource(name, false, isTu, drive); //new BufferedImage(name,false,isTu,drive); + } + else + { + const char *pchName=wstringtofilename(name); +#ifdef __PS3__ + if(app.GetBootedFromDiscPatch() && app.IsFileInPatchList(pchName)) + { + char *pchUsrDir = app.GetBDUsrDirPath(pchName); + wstring wstr (pchUsrDir, pchUsrDir+strlen(pchUsrDir)); + + if(isTu) + { + drive= wstr + L"\\Common\\res\\TitleUpdate\\"; + + } + else + { + drive= wstr + L"\\Common\\"; + } + } + else +#endif + { + drive = skins->getDefault()->getPath(isTu); + } + + const char *pchDrive=wstringtofilename(drive); + + if(IsOriginalImage(texId, name) || isTu) + { + img = skins->getDefault()->getImageResource(name,false,isTu,drive); //new BufferedImage(name,false,isTu,drive); + } + else + { + img = skins->getDefault()->getImageResource(L"1_2_2/" + name, false, isTu, drive); //new BufferedImage(L"/1_2_2" + name,false,isTu,drive); + } + } + + MemSect(0); + return img; +} + +// Match the preload images from their enum to avoid a ton of string comparisons +TEXTURE_NAME TUImages[] = +{ + TN_POWERED_CREEPER, + TN_MOB_ENDERMAN_EYES, + TN_MISC_EXPLOSION, + TN_MOB_ZOMBIE, + TN_MISC_FOOTSTEP, + TN_MOB_RED_COW, + TN_MOB_SNOWMAN, + TN_MOB_ENDERDRAGON, + TN_MOB_VILLAGER_VILLAGER, + TN_MOB_VILLAGER_FARMER, + TN_MOB_VILLAGER_LIBRARIAN, + TN_MOB_VILLAGER_PRIEST, + TN_MOB_VILLAGER_SMITH, + TN_MOB_VILLAGER_BUTCHER, + TN_MOB_ENDERDRAGON_ENDEREYES, + TN__BLUR__MISC_GLINT, + TN_ITEM_BOOK, + TN_MISC_PARTICLEFIELD, + + // TU9 + TN_MISC_TUNNEL, + TN_MOB_ENDERDRAGON_BEAM, + TN_GUI_ITEMS, + TN_TERRAIN, + TN_MISC_MAPICONS, + + // TU12 + TN_MOB_WITHER_SKELETON, + + // TU14 + TN_TILE_ENDER_CHEST, + TN_ART_KZ, + TN_MOB_WOLF_TAME, + TN_MOB_WOLF_COLLAR, + TN_PARTICLES, + TN_MOB_ZOMBIE_VILLAGER, + +#ifdef _LARGE_WORLDS + TN_MISC_ADDITIONALMAPICONS, +#endif + + // TU17 + TN_DEFAULT_FONT, + // TN_ALT_FONT, // Not in TU yet + + TN_COUNT // Why is this here? +}; + +// This is for any TU textures that aren't part of our enum indexed preload set +wchar_t *TUImagePaths[] = +{ + L"font/Default", + L"font/Mojangles_7", + L"font/Mojangles_11", + + // TU12 + L"armor/cloth_1.png", + L"armor/cloth_1_b.png", + L"armor/cloth_2.png", + L"armor/cloth_2_b.png", + + NULL +}; + +bool Textures::IsTUImage(TEXTURE_NAME texId, const wstring& name) +{ + int i = 0; + if(texId < TN_COUNT) + { + while(TUImages[i] < TN_COUNT) + { + if(texId == TUImages[i]) + { + return true; + } + i++; + } + } + i = 0; + while(TUImagePaths[i]) + { + if(name.compare(TUImagePaths[i])==0) + { + return true; + } + i++; + } + return false; +} + +TEXTURE_NAME OriginalImages[] = +{ + TN_MOB_CHAR, + TN_MOB_CHAR1, + TN_MOB_CHAR2, + TN_MOB_CHAR3, + TN_MOB_CHAR4, + TN_MOB_CHAR5, + TN_MOB_CHAR6, + TN_MOB_CHAR7, + + TN_MISC_MAPBG, + + TN_COUNT +}; + +wchar_t *OriginalImagesPaths[] = +{ + L"misc/watercolor.png", + + NULL +}; + +bool Textures::IsOriginalImage(TEXTURE_NAME texId, const wstring& name) +{ + int i = 0; + if(texId < TN_COUNT) + { + while(OriginalImages[i] < TN_COUNT) + { + if(texId == OriginalImages[i]) + { + return true; + } + i++; + } + } + i = 0; + while(OriginalImagesPaths[i]) + { + if(name.compare(OriginalImagesPaths[i])==0) + { + return true; + } + i++; + } + return false; +} + |