backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-04-24 10:03:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
4jcraft/targets/minecraft/client/renderer/Textures.cpp

1367 lines
43 KiB
C++
Raw Permalink Blame History

#include "minecraft/IGameServices.h"
#include "Textures.h"
#include <assert.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <utility>
#include "platform/renderer/renderer.h"
#include "HttpTexture.h"
#include "app/linux/LinuxGame.h"
#include "minecraft/client/BufferedImage.h"
#include "minecraft/client/renderer/MemTexture.h"
#include "minecraft/client/renderer/MemTextureProcessor.h"
#include "minecraft/client/renderer/MobSkinMemTextureProcessor.h"
#include "util/StringHelpers.h"
#include "java/Buffer.h"
#include "java/ByteBuffer.h"
#include "minecraft/client/MemoryTracker.h"
#include "minecraft/client/Options.h"
#include "minecraft/client/renderer/texture/PreStitchedTextureMap.h"
#include "minecraft/client/renderer/texture/Texture.h"
#include "minecraft/client/renderer/texture/TextureAtlas.h"
#include "minecraft/client/resources/ResourceLocation.h"
#include "minecraft/client/skins/TexturePack.h"
#include "minecraft/client/skins/TexturePackRepository.h"
#include "minecraft/world/Icon.h"
#include "minecraft/world/entity/Entity.h"
#include "minecraft/world/entity/item/ItemEntity.h"
#include "minecraft/world/item/ItemInstance.h"
// Linux/PC port: disable mipmapping globally so textures are always sampled
// from the full-resolution level 0 with GL_NEAREST, giving pixel-crisp
// Minecraft blocks at all distances. Mipmapping causes glGenerateMipmap() to
// fire (which resets the min-filter to GL_NEAREST_MIPMAP_LINEAR on many
// Mesa/Nvidia drivers) and the per-level crispBlend loop is both wasteful and
// still causes visible blurring.
bool Textures::MIPMAP = false;
IPlatformRenderer::eTextureFormat Textures::TEXTURE_FORMAT =
IPlatformRenderer::TEXTURE_FORMAT_RxGyBzAw;
int Textures::preLoadedIdx[TN_COUNT];
const char* Textures::preLoaded[TN_COUNT] = {
"%blur%misc/pumpkinblur",
"%clamp%misc/shadow",
"art/kz",
"environment/clouds",
"environment/rain",
"environment/snow",
"gui/gui",
"gui/icons",
"item/arrows",
"item/boat",
"item/cart",
"item/sign",
"misc/mapbg",
"misc/mapicons",
"misc/water",
"misc/footprint",
"mob/saddle",
"mob/sheep_fur",
"mob/spider_eyes",
"particles",
"mob/chicken",
"mob/cow",
"mob/pig",
"mob/sheep",
"mob/squid",
"mob/wolf",
"mob/wolf_tame",
"mob/wolf_angry",
"mob/creeper",
"mob/ghast",
"mob/ghast_fire",
"mob/zombie",
"mob/pigzombie",
"mob/skeleton",
"mob/slime",
"mob/spider",
"mob/char",
"mob/char1",
"mob/char2",
"mob/char3",
"mob/char4",
"mob/char5",
"mob/char6",
"mob/char7",
"terrain/moon",
"terrain/sun",
"armor/power",
// 1.8.2
"mob/cavespider",
"mob/enderman",
"mob/silverfish",
"mob/enderman_eyes",
"misc/explosion",
"item/xporb",
"item/chest",
"item/largechest",
// 1.3.2
"item/enderchest",
// 1.0.1
"mob/redcow",
"mob/snowman",
"mob/enderdragon/ender",
"mob/fire",
"mob/lava",
"mob/villager/villager",
"mob/villager/farmer",
"mob/villager/librarian",
"mob/villager/priest",
"mob/villager/smith",
"mob/villager/butcher",
"mob/enderdragon/crystal",
"mob/enderdragon/shuffle",
"mob/enderdragon/beam",
"mob/enderdragon/ender_eyes",
"%blur%misc/glint",
"item/book",
"misc/tunnel",
"misc/particlefield",
"terrain/moon_phases",
// 1.2.3
"mob/ozelot",
"mob/cat_black",
"mob/cat_red",
"mob/cat_siamese",
"mob/villager_golem",
"mob/skeleton_wither",
// TU 14
"mob/wolf_collar",
"mob/zombie_villager",
// 1.6.4
"item/lead_knot",
"misc/beacon_beam",
"mob/bat",
"mob/horse/donkey",
"mob/horse/horse_black",
"mob/horse/horse_brown",
"mob/horse/horse_chestnut",
"mob/horse/horse_creamy",
"mob/horse/horse_darkbrown",
"mob/horse/horse_gray",
"mob/horse/horse_markings_blackdots",
"mob/horse/horse_markings_white",
"mob/horse/horse_markings_whitedots",
"mob/horse/horse_markings_whitefield",
"mob/horse/horse_skeleton",
"mob/horse/horse_white",
"mob/horse/horse_zombie",
"mob/horse/mule",
"mob/horse/armor/horse_armor_diamond",
"mob/horse/armor/horse_armor_gold",
"mob/horse/armor/horse_armor_iron",
"mob/witch",
"mob/wither/wither",
"mob/wither/wither_armor",
"mob/wither/wither_invulnerable",
"item/trapped",
"item/trapped_double",
// 4jcraft: java UI specific
#ifdef ENABLE_JAVA_GUIS
"%blur%/misc/vignette",
"/achievement/bg",
"gui/background",
"gui/inventory",
"gui/container",
"gui/crafting",
"gui/furnace",
"gui/creative_inventory/tabs",
"gui/creative_inventory/tab_items",
"gui/creative_inventory/tab_inventory",
"gui/creative_inventory/tab_item_search",
"title/mclogo",
"gui/horse",
"gui/anvil",
"gui/trap",
"gui/beacon",
"gui/hopper",
"gui/enchant",
"gui/villager",
"gui/brewing_stand",
"title/bg/panorama",
"title/bg/panorama0",
"title/bg/panorama1",
"title/bg/panorama2",
"title/bg/panorama3",
"title/bg/panorama4",
"title/bg/panorama5",
#endif
// "item/christmas",
// "item/christmas_double",
#if defined(_LARGE_WORLDS)
"misc/additionalmapicons",
#endif
"font/Default",
"font/alternate",
// skin packs
/* "/SP1",
"/SP2",
"/SP3",
"/SPF",
// themes
"/ThSt",
"/ThIr",
"/ThGo",
"/ThDi",
// gamerpics
"/GPAn",
"/GPCo",
"/GPEn",
"/GPFo",
"/GPTo",
"/GPBA",
"/GPFa",
"/GPME",
"/GPMF",
"/GPMM",
"/GPSE",
// avatar items
"/AH_0006",
"/AH_0003",
"/AH_0007",
"/AH_0005",
"/AH_0004",
"/AH_0001",
"/AH_0002",
"/AT_0001",
"/AT_0002",
"/AT_0003",
"/AT_0004",
"/AT_0005",
"/AT_0006",
"/AT_0007",
"/AT_0008",
"/AT_0009",
"/AT_0010",
"/AT_0011",
"/AT_0012",
"/AP_0001",
"/AP_0002",
"/AP_0003",
"/AP_0004",
"/AP_0005",
"/AP_0006",
"/AP_0007",
"/AP_0009",
"/AP_0010",
"/AP_0011",
"/AP_0012",
"/AP_0013",
"/AP_0014",
"/AP_0015",
"/AP_0016",
"/AP_0017",
"/AP_0018",
"/AA_0001",
"/AT_0013",
"/AT_0014",
"/AT_0015",
"/AT_0016",
"/AT_0017",
"/AT_0018",
"/AP_0019",
"/AP_0020",
"/AP_0021",
"/AP_0022",
"/AP_0023",
"/AH_0008",
"/AH_0009",*/
"gui/items",
"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, "terrain",
"textures/blocks/", missingNo, true);
items = new PreStitchedTextureMap(Icon::TYPE_ITEM, "items",
"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, std::string(preLoaded[i]) + ".png");
}
}
std::vector<int> Textures::loadTexturePixels(TEXTURE_NAME texId,
const std::string& resourceName) {
TexturePack* skin = skins->getSelected();
{
std::vector<int> 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 vector will be empty
if (!id.empty()) return id;
}
// 4J - removed try/catch
// try {
std::vector<int> res;
// string in = skin->getResource(resourceName);
if (false) // 4J - removed - was ( in == nullptr)
{
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;
}
*/
}
std::vector<int> Textures::loadTexturePixels(BufferedImage* img) {
int w = img->getWidth();
int h = img->getHeight();
std::vector<int> pixels(w * h);
return loadTexturePixels(img, pixels);
}
std::vector<int> Textures::loadTexturePixels(BufferedImage* img,
std::vector<int>& 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 std::string& resourceName) {
// 4J Stu - These texture formats are not currently in the render header
{
TEXTURE_FORMAT = IPlatformRenderer::TEXTURE_FORMAT_RxGyBzAw;
}
}
void Textures::bindTexture(const std::string& resourceName) {
bind(loadTexture(TN_COUNT, resourceName));
}
// 4J Added
void Textures::bindTexture(ResourceLocation* resource) {
if (resource->isPreloaded()) {
bind(loadTexture(resource->getTexture()));
} else {
bind(loadTexture(TN_COUNT, resource->getPath()));
}
}
// 4jcraft: brought over from smartcmd/MinecraftConsoles in TU19 merge
void Textures::bindTextureLayers(ResourceLocation* resource) {
assert(resource->isPreloaded());
// Hack: 4JLibs on Windows does not currently reproduce Minecraft's layered
// horse texture path reliably. Merge the layers on the CPU and bind the
// cached result as a normal single texture instead.
std::string cacheKey = "%layered%";
int layers = resource->getTextureCount();
for (int i = 0; i < layers; i++) {
cacheKey += std::to_string(resource->getTexture(i));
cacheKey += "/";
}
int id = -1;
bool inMap = (idMap.find(cacheKey) != idMap.end());
if (inMap) {
id = idMap[cacheKey];
} else {
// Cache by layer signature so the merge cost is only paid once per
// horse texture combination.
std::vector<int> mergedPixels;
int mergedWidth = 0;
int mergedHeight = 0;
bool hasMergedPixels = false;
for (int i = 0; i < layers; i++) {
TEXTURE_NAME textureName = resource->getTexture(i);
if (textureName == static_cast<_TEXTURE_NAME>(-1)) {
continue;
}
std::string resourceName =
std::string(preLoaded[textureName]) + ".png";
BufferedImage* image = readImage(textureName, resourceName);
if (image == nullptr) {
continue;
}
int width = image->getWidth();
int height = image->getHeight();
std::vector<int> layerPixels = loadTexturePixels(image);
delete image;
if (!hasMergedPixels) {
mergedWidth = width;
mergedHeight = height;
mergedPixels = std::vector<int>(width * height);
memcpy(mergedPixels.data(), layerPixels.data(),
width * height * sizeof(int));
hasMergedPixels = true;
} else if (width == mergedWidth && height == mergedHeight) {
for (int p = 0; p < width * height; p++) {
int dst = mergedPixels[p];
int src = layerPixels[p];
float srcAlpha = ((src >> 24) & 0xff) / 255.0f;
if (srcAlpha <= 0.0f) {
continue;
}
float dstAlpha = ((dst >> 24) & 0xff) / 255.0f;
float outAlpha = srcAlpha + dstAlpha * (1.0f - srcAlpha);
if (outAlpha <= 0.0f) {
mergedPixels[p] = 0;
continue;
}
float srcFactor = srcAlpha / outAlpha;
float dstFactor = (dstAlpha * (1.0f - srcAlpha)) / outAlpha;
int outA = static_cast<int>(outAlpha * 255.0f + 0.5f);
int outR = static_cast<int>(
(((src >> 16) & 0xff) * srcFactor) +
(((dst >> 16) & 0xff) * dstFactor) + 0.5f);
int outG = static_cast<int>(
(((src >> 8) & 0xff) * srcFactor) +
(((dst >> 8) & 0xff) * dstFactor) + 0.5f);
int outB =
static_cast<int>(((src & 0xff) * srcFactor) +
((dst & 0xff) * dstFactor) + 0.5f);
mergedPixels[p] =
(outA << 24) | (outR << 16) | (outG << 8) | outB;
}
}
}
if (hasMergedPixels) {
BufferedImage* mergedImage = new BufferedImage(
mergedWidth, mergedHeight, BufferedImage::TYPE_INT_ARGB);
memcpy(mergedImage->getData(), mergedPixels.data(),
mergedWidth * mergedHeight * sizeof(int));
id = getTexture(mergedImage, IPlatformRenderer::TEXTURE_FORMAT_RxGyBzAw,
false);
} else {
id = 0;
}
idMap[cacheKey] = id;
}
PlatformRenderer.TextureBind(id);
}
void Textures::bind(int id) {
// 4jcraft: Classic GUI code still performs some raw glBindTexture calls, so
// this path must always rebind rather than trusting lastBoundId to be in
// sync.
// TODO(4jcraft): Long term, route all texture binds through one
// synchronized path or invalidate lastBoundId at every raw glBindTexture
// call so this can safely use cached binds again without breaking font/UI
// rendering. if (id != lastBoundId)
{
if (id < 0) return;
glBindTexture(GL_TEXTURE_2D, id);
// lastBoundId = id;
}
}
ResourceLocation* Textures::getTextureLocation(std::shared_ptr<Entity> entity) {
std::shared_ptr<ItemEntity> item =
std::dynamic_pointer_cast<ItemEntity>(entity);
int iconType = item->getItem()->getIconType();
return getTextureLocation(iconType);
}
ResourceLocation* Textures::getTextureLocation(int iconType) {
switch (iconType) {
case Icon::TYPE_TERRAIN:
return &TextureAtlas::LOCATION_BLOCKS;
case Icon::TYPE_ITEM:
return &TextureAtlas::LOCATION_ITEMS;
}
return &TextureAtlas::LOCATION_ITEMS;
}
void Textures::clearLastBoundId() { lastBoundId = -1; }
int Textures::loadTexture(TEXTURE_NAME texId,
const std::string& resourceName) {
// char buf[256];
// strncpy(buf, resourceName.c_str(), 256);
// printf("Textures::loadTexture name - %s\n",buf);
// if (resourceName.compare("/terrain.png") == 0)
//{
// terrain->getStitchedTexture()->bind(0);
// return terrain->getStitchedTexture()->getGlId();
// }
// if (resourceName.compare("/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;
}
std::string pathName = resourceName;
// 4J - added special cases to avoid mipmapping on clouds & shadows
if ((resourceName == "environment/clouds.png") ||
(resourceName == "%clamp%misc/shadow.png") ||
(resourceName == "%blur%misc/pumpkinblur.png") ||
(resourceName == "%clamp%misc/shadow.png") ||
(resourceName == "gui/icons.png") ||
(resourceName == "gui/gui.png") ||
(resourceName == "misc/footprint.png")) {
MIPMAP = false;
}
setTextureFormat(resourceName);
// 4J - removed try/catch
// try {
int id = MemoryTracker::genTextures();
std::string prefix = "%blur%";
bool blur = resourceName.substr(0, prefix.size()).compare(prefix) ==
0; // resourceName.startsWith("%blur%");
if (blur) pathName = resourceName.substr(6);
prefix = "%clamp%";
bool clamp = resourceName.substr(0, prefix.size()).compare(prefix) ==
0; // resourceName.startsWith("%clamp%");
if (clamp) pathName = resourceName.substr(7);
// string in = skins->getSelected()->getResource(pathName);
if (false) // 4J - removed was ( in == nullptr)
{
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 = IPlatformRenderer::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, IPlatformRenderer::eTextureFormat format,
bool mipmap) {
int id = MemoryTracker::genTextures();
TEXTURE_FORMAT = format;
MIPMAP = mipmap;
loadTexture(img, id);
TEXTURE_FORMAT = IPlatformRenderer::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;
glBindTexture(GL_TEXTURE_2D, id);
if (MIPMAP) {
// Linux/PC port: force GL_NEAREST to avoid mip-level distance blurring
// and keep Minecraft textures pixel-crisp at all distances.
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_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_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
} 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();
std::vector<int> rawPixels(w * h);
img->getRGB(0, 0, w, h, rawPixels, 0, w);
if (options != nullptr && options->anaglyph3d) {
rawPixels = anaglyph(rawPixels);
}
std::vector<uint8_t> newPixels(w * h * 4);
for (unsigned int i = 0; i < rawPixels.size(); i++) {
int a = (rawPixels[i] >> 24) & 0xff;
int r = (rawPixels[i] >> 16) & 0xff;
int g = (rawPixels[i] >> 8) & 0xff;
int b = (rawPixels[i]) & 0xff;
newPixels[i * 4 + 0] = (uint8_t)r;
newPixels[i * 4 + 1] = (uint8_t)g;
newPixels[i * 4 + 2] = (uint8_t)b;
newPixels[i * 4 + 3] = (uint8_t)a;
}
// 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.size());
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;
// PlatformRenderer.TextureSetTextureLevels(5); // 4J added
if (iMipLevels > 5) iMipLevels = 5;
PlatformRenderer.TextureSetTextureLevels(iMipLevels); // 4J added
}
PlatformRenderer.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);
// Swap ARGB to RGBA
for (int i = 0; i < ww * hh; i++) {
tempData[i] = (tempData[i] >> 24) | (tempData[i] << 8);
}
} 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);
// 4J - convert our RGBA texels to ARGB that crispBlend
// is expecting 4jcraft, added uint cast to pervent
// shift of neg int
c0 =
((c0 >> 8) & 0x00ffffff) | ((unsigned int)c0 << 24);
c1 =
((c1 >> 8) & 0x00ffffff) | ((unsigned int)c1 << 24);
c2 =
((c2 >> 8) & 0x00ffffff) | ((unsigned int)c2 << 24);
c3 =
((c3 >> 8) & 0x00ffffff) | ((unsigned int)c3 << 24);
int col =
Texture::crispBlend(Texture::crispBlend(c0, c1),
Texture::crispBlend(c2, c3));
// 4J - and back from ARGB -> RGBA
col = ((unsigned int)col << 8) | ((col >> 24) & 0xff);
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;
PlatformRenderer.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
}
std::vector<int> Textures::anaglyph(std::vector<int>& rawPixels) {
std::vector<int> result(rawPixels.size());
for (unsigned int i = 0; i < rawPixels.size(); 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;
}
return result;
}
void Textures::replaceTexture(std::vector<int>& rawPixels, int w, int h,
int id) {
bind(id);
// Removed in Java
{
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 != nullptr && options->anaglyph3d) {
rawPixels = anaglyph(rawPixels);
}
std::vector<uint8_t> newPixels(w * h * 4);
for (unsigned int i = 0; i < rawPixels.size(); 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 != nullptr && 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] = (uint8_t)r;
newPixels[i * 4 + 1] = (uint8_t)g;
newPixels[i * 4 + 2] = (uint8_t)b;
newPixels[i * 4 + 3] = (uint8_t)a;
}
ByteBuffer* pixels = MemoryTracker::createByteBuffer(
w * h * 4); // 4J - now creating dynamically
pixels->put(newPixels);
pixels->position(0)->limit(newPixels.size());
// New
// glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL12.GL_BGRA,
// GL12.GL_UNSIGNED_INT_8_8_8_8_REV, pixels);
PlatformRenderer.TextureDataUpdate(0, 0, w, h, pixels->getBuffer(), 0);
// 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(const std::vector<int>& rawPixels, int w,
int h, int id) {
glBindTexture(GL_TEXTURE_2D, id);
// Remove in Java
{
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);
PlatformRenderer.TextureDataUpdate(0, 0, w, h,
const_cast<int*>(rawPixels.data()), 0);
}
// 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(const std::vector<short>& rawPixels, int w,
int h, int id) {
glBindTexture(GL_TEXTURE_2D, id);
// Remove in Java
{
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);
PlatformRenderer.TextureDataUpdate(0, 0, w, h,
const_cast<short*>(rawPixels.data()), 0);
}
void Textures::releaseTexture(int id) {
loadedImages.erase(id);
glDeleteTextures(id);
}
int Textures::loadHttpTexture(const std::string& url,
const std::string& backup) {
HttpTexture* texture = httpTextures[url];
if (texture != nullptr) {
if (texture->loadedImage != nullptr && !texture->isLoaded) {
if (texture->id < 0) {
texture->id = getTexture(texture->loadedImage);
} else {
loadTexture(texture->loadedImage, texture->id);
}
texture->isLoaded = true;
}
}
if (texture == nullptr || texture->id < 0) {
if (backup.empty()) return -1;
return loadTexture(TN_COUNT, backup);
}
return texture->id;
}
int Textures::loadHttpTexture(const std::string& url, int backup) {
HttpTexture* texture = httpTextures[url];
if (texture != nullptr) {
if (texture->loadedImage != nullptr && !texture->isLoaded) {
if (texture->id < 0) {
texture->id = getTexture(texture->loadedImage);
} else {
loadTexture(texture->loadedImage, texture->id);
}
texture->isLoaded = true;
}
}
if (texture == nullptr || texture->id < 0) {
return loadTexture(backup);
}
return texture->id;
}
bool Textures::hasHttpTexture(const std::string& url) {
return httpTextures.find(url) != httpTextures.end();
}
HttpTexture* Textures::addHttpTexture(const std::string& url,
HttpTextureProcessor* processor) {
HttpTexture* texture = httpTextures[url];
if (texture == nullptr) {
httpTextures[url] = new HttpTexture(url, processor);
} else {
texture->count++;
}
return texture;
}
void Textures::removeHttpTexture(const std::string& url) {
HttpTexture* texture = httpTextures[url];
if (texture != nullptr) {
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 std::string& url,
const std::string& backup) {
MemTexture* texture = nullptr;
auto it = memTextures.find(url);
if (it != memTextures.end()) {
texture = (*it).second;
}
if (texture == nullptr && gameServices().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 != nullptr) {
if (texture->loadedImage != nullptr && !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) == "dlcskin") ||
(url.substr(0, 7) == "dlccape")) {
MIPMAP = false;
}
if (texture->id < 0) {
texture->id =
getTexture(texture->loadedImage,
IPlatformRenderer::TEXTURE_FORMAT_RxGyBzAw, MIPMAP);
} else {
loadTexture(texture->loadedImage, texture->id);
}
texture->isLoaded = true;
MIPMAP = true;
}
}
if (texture == nullptr || texture->id < 0) {
if (backup.empty()) return -1;
return loadTexture(TN_COUNT, backup);
}
return texture->id;
}
int Textures::loadMemTexture(const std::string& url, int backup) {
MemTexture* texture = nullptr;
auto it = memTextures.find(url);
if (it != memTextures.end()) {
texture = (*it).second;
}
if (texture == nullptr && gameServices().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 != nullptr) {
texture->ticksSinceLastUse = 0;
if (texture->loadedImage != nullptr && !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) == "dlcskin") ||
(url.substr(0, 7) == "dlccape")) {
MIPMAP = false;
}
if (texture->id < 0) {
texture->id =
getTexture(texture->loadedImage,
IPlatformRenderer::TEXTURE_FORMAT_RxGyBzAw, MIPMAP);
} else {
loadTexture(texture->loadedImage, texture->id);
}
texture->isLoaded = true;
MIPMAP = true;
}
}
if (texture == nullptr || texture->id < 0) {
return loadTexture(backup);
}
return texture->id;
}
MemTexture* Textures::addMemTexture(const std::string& name,
MemTextureProcessor* processor) {
MemTexture* texture = nullptr;
auto it = memTextures.find(name);
if (it != memTextures.end()) {
texture = (*it).second;
}
if (texture == nullptr) {
// can we find it in the app mem files?
std::uint8_t* pbData = nullptr;
unsigned int dwBytes = 0;
gameServices().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] = nullptr;
}
} else {
texture->count++;
}
delete processor;
return texture;
}
// MemTexture *Textures::getMemTexture(const string& url, MemTextureProcessor
// *processor)
// {
// MemTexture *texture = memTextures[url];
// if (texture != nullptr)
// {
// texture->count++;
// }
// return texture;
// }
void Textures::removeMemTexture(const std::string& url) {
MemTexture* texture = nullptr;
auto it = memTextures.find(url);
if (it != memTextures.end()) {
texture = (*it).second;
// If it's nullptr then we should just remove the entry
if (texture == nullptr) memTextures.erase(url);
}
if (texture != nullptr) {
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
{
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) {
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
// PlatformRenderer.TextureDynamicUpdateStart();
terrain->cycleAnimationFrames();
items->cycleAnimationFrames();
// PlatformRenderer.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 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++;
}
}
}
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("misc/watercolor.png"));
// GrassColor::init(loadTexturePixels("misc/grasscolor.png"));
// FoliageColor::init(loadTexturePixels("misc/foliagecolor.png"));
stitch();
skins->clearInvalidTexturePacks();
// 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 std::string& name) // 4J was InputStream *in
{
BufferedImage* img = nullptr;
// is this image one of the Title Update ones?
bool isTu = IsTUImage(texId, name);
std::string drive = "";
if (!skins->isUsingDefaultSkin() &&
skins->getSelected()->hasFile("res/" + name, false)) {
drive = skins->getSelected()->getPath(isTu);
img = skins->getSelected()->getImageResource(
name, false, isTu,
drive); // new BufferedImage(name,false,isTu,drive);
} else {
{
drive = skins->getDefault()->getPath(isTu);
}
if (IsOriginalImage(texId, name) || isTu) {
img = skins->getDefault()->getImageResource(
name, false, isTu,
drive); // new BufferedImage(name,false,isTu,drive);
} else {
img = skins->getDefault()->getImageResource(
"1_2_2/" + name, false, isTu,
drive); // new BufferedImage("/1_2_2" +
// name,false,isTu,drive);
}
}
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,
TN_ITEM_LEASHKNOT,
TN_MISC_BEACON_BEAM,
TN_MOB_BAT,
TN_MOB_DONKEY, TN_MOB_HORSE_BLACK, TN_MOB_HORSE_BROWN,
TN_MOB_HORSE_CHESTNUT, TN_MOB_HORSE_CREAMY, TN_MOB_HORSE_DARKBROWN,
TN_MOB_HORSE_GRAY, TN_MOB_HORSE_MARKINGS_BLACKDOTS,
TN_MOB_HORSE_MARKINGS_WHITE, TN_MOB_HORSE_MARKINGS_WHITEDOTS,
TN_MOB_HORSE_MARKINGS_WHITEFIELD, TN_MOB_HORSE_SKELETON, TN_MOB_HORSE_WHITE,
TN_MOB_HORSE_ZOMBIE, TN_MOB_MULE, TN_MOB_HORSE_ARMOR_DIAMOND,
TN_MOB_HORSE_ARMOR_GOLD, TN_MOB_HORSE_ARMOR_IRON,
TN_MOB_WITCH,
TN_MOB_WITHER, TN_MOB_WITHER_ARMOR, TN_MOB_WITHER_INVULNERABLE,
TN_TILE_TRAP_CHEST, TN_TILE_LARGE_TRAP_CHEST,
// TN_TILE_XMAS_CHEST,
// TN_TILE_LARGE_XMAS_CHEST,
#if defined(_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
const char* const TUImagePaths[] = {
"font/Default", "font/Mojangles_7", "font/Mojangles_11",
// TU12
"armor/cloth_1.png", "armor/cloth_1_b.png", "armor/cloth_2.png",
"armor/cloth_2_b.png",
//
nullptr};
bool Textures::IsTUImage(TEXTURE_NAME texId, const std::string& 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};
const char* const OriginalImagesPaths[] = {"misc/watercolor.png",
nullptr};
bool Textures::IsOriginalImage(TEXTURE_NAME texId, const std::string& 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;
}
Reference in a new issue View git blame Copy permalink