From 66c8fce606281038e3d5e1237af9b4027c6e77de Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 17 Mar 2018 21:12:09 -0400 Subject: [PATCH] cache: add item sprite renderer Most of the code is slightly deobfuscated and stripped down from the client --- .../net/runelite/cache/item/Graphics3D.java | 2940 +++++++++++++++++ .../cache/item/ItemSpriteFactory.java | 439 +++ .../java/net/runelite/cache/item/Model.java | 773 +++++ .../cache/item/RSTextureProvider.java | 101 + .../net/runelite/cache/item/Rasterizer2D.java | 96 + .../net/runelite/cache/item/Renderable.java | 35 + .../net/runelite/cache/item/SpritePixels.java | 216 ++ .../cache/item/ItemSpriteFactoryTest.java | 118 + 8 files changed, 4718 insertions(+) create mode 100644 cache/src/main/java/net/runelite/cache/item/Graphics3D.java create mode 100644 cache/src/main/java/net/runelite/cache/item/ItemSpriteFactory.java create mode 100644 cache/src/main/java/net/runelite/cache/item/Model.java create mode 100644 cache/src/main/java/net/runelite/cache/item/RSTextureProvider.java create mode 100644 cache/src/main/java/net/runelite/cache/item/Rasterizer2D.java create mode 100644 cache/src/main/java/net/runelite/cache/item/Renderable.java create mode 100644 cache/src/main/java/net/runelite/cache/item/SpritePixels.java create mode 100644 cache/src/test/java/net/runelite/cache/item/ItemSpriteFactoryTest.java diff --git a/cache/src/main/java/net/runelite/cache/item/Graphics3D.java b/cache/src/main/java/net/runelite/cache/item/Graphics3D.java new file mode 100644 index 0000000000..9312a9f945 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/Graphics3D.java @@ -0,0 +1,2940 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +class Graphics3D extends Rasterizer2D +{ + private static final double UNIT = Math.PI / 1024d; // How much of the circle each unit of SINE/COSINE is + + public static final int[] SINE = new int[2048]; // sine angles for each of the 2048 units, * 65536 and stored as an int + public static final int[] COSINE = new int[2048]; // cosine + + private static int[] field1932 = new int[512]; + static int[] field1933 = new int[2048]; + + static + { + for (int i = 0; i < 2048; ++i) + { + SINE[i] = (int) (65536.0D * Math.sin((double) i * UNIT)); + COSINE[i] = (int) (65536.0D * Math.cos((double) i * UNIT)); + } + + int var0; + for (var0 = 1; var0 < 512; ++var0) + { + field1932[var0] = 32768 / var0; + } + + for (var0 = 1; var0 < 2048; ++var0) + { + field1933[var0] = 65536 / var0; + } + } + + private final RSTextureProvider textureProvider; + boolean rasterClipEnable; + boolean field1909; + boolean lowMem; + public boolean rasterGouraudLowRes = true; + int rasterAlpha; + public int Rasterizer3D_zoom = 512; + int centerX; + int centerY; + int rasterClipX; + int Rasterizer3D_clipHeight; + int Rasterizer3D_clipNegativeMidX; + int Rasterizer3D_clipMidX2; + int Rasterizer3D_clipNegativeMidY; + int Rasterizer3D_clipMidY2; + int[] rasterClipY = new int[1024]; + public int[] colorPalette = new int[65536]; + + public Graphics3D(RSTextureProvider textureProvider) + { + this.textureProvider = textureProvider; + } + + public final void setRasterClipping() + { + setRasterClipping(draw_region_x, drawingAreaTop, drawingAreaRight, drawingAreaBottom); + } + + final void setRasterClipping(int var0, int var1, int var2, int var3) + { + rasterClipX = var2 - var0; + Rasterizer3D_clipHeight = var3 - var1; + Rasterizer3D_method3(); + + if (rasterClipY.length < Rasterizer3D_clipHeight) + { + // Find closest 2^n >= v + int v = Rasterizer3D_clipHeight - 1; + v |= v >>> 1; + v |= v >>> 2; + v |= v >>> 4; + v |= v >>> 8; + v |= v >>> 16; + rasterClipY = new int[v + 1]; + } + + int var4 = var0 + graphicsPixelsWidth * var1; + for (int i = 0; i < Rasterizer3D_clipHeight; ++i) + { + rasterClipY[i] = var4; + var4 += graphicsPixelsWidth; + } + + } + + public final void Rasterizer3D_method3() + { + centerX = rasterClipX / 2; + centerY = Rasterizer3D_clipHeight / 2; + Rasterizer3D_clipNegativeMidX = -centerX; + Rasterizer3D_clipMidX2 = rasterClipX - centerX; + Rasterizer3D_clipNegativeMidY = -centerY; + Rasterizer3D_clipMidY2 = Rasterizer3D_clipHeight - centerY; + } + + public final void setOffset(int x, int y) + { + int var2 = rasterClipY[0]; + int var3 = var2 / graphicsPixelsWidth; + int var4 = var2 - var3 * graphicsPixelsWidth; + centerX = x - var4; + centerY = y - var3; + Rasterizer3D_clipNegativeMidX = -centerX; + Rasterizer3D_clipMidX2 = rasterClipX - centerX; + Rasterizer3D_clipNegativeMidY = -centerY; + Rasterizer3D_clipMidY2 = Rasterizer3D_clipHeight - centerY; + } + + public final void setBrightness(double var0) + { + buildColorPalette(var0, 0, 512); + } + + final void buildColorPalette(double var0, int var2, int var3) + { + int var4 = var2 * 128; + + for (int var5 = var2; var5 < var3; ++var5) + { + double var6 = (double) (var5 >> 3) / 64.0D + 0.0078125D; + double var8 = (double) (var5 & 7) / 8.0D + 0.0625D; + + for (int var10 = 0; var10 < 128; ++var10) + { + double var11 = (double) var10 / 128.0D; + double var13 = var11; + double var15 = var11; + double var17 = var11; + if (var8 != 0.0D) + { + double var19; + if (var11 < 0.5D) + { + var19 = var11 * (1.0D + var8); + } + else + { + var19 = var11 + var8 - var11 * var8; + } + + double var21 = 2.0D * var11 - var19; + double var23 = var6 + 0.3333333333333333D; + if (var23 > 1.0D) + { + --var23; + } + + double var27 = var6 - 0.3333333333333333D; + if (var27 < 0.0D) + { + ++var27; + } + + if (6.0D * var23 < 1.0D) + { + var13 = var21 + (var19 - var21) * 6.0D * var23; + } + else if (2.0D * var23 < 1.0D) + { + var13 = var19; + } + else if (3.0D * var23 < 2.0D) + { + var13 = var21 + (var19 - var21) * (0.6666666666666666D - var23) * 6.0D; + } + else + { + var13 = var21; + } + + if (6.0D * var6 < 1.0D) + { + var15 = var21 + (var19 - var21) * 6.0D * var6; + } + else if (2.0D * var6 < 1.0D) + { + var15 = var19; + } + else if (3.0D * var6 < 2.0D) + { + var15 = var21 + (var19 - var21) * (0.6666666666666666D - var6) * 6.0D; + } + else + { + var15 = var21; + } + + if (6.0D * var27 < 1.0D) + { + var17 = var21 + (var19 - var21) * 6.0D * var27; + } + else if (2.0D * var27 < 1.0D) + { + var17 = var19; + } + else if (3.0D * var27 < 2.0D) + { + var17 = var21 + (var19 - var21) * (0.6666666666666666D - var27) * 6.0D; + } + else + { + var17 = var21; + } + } + + int var29 = (int) (var13 * 256.0D); + int var20 = (int) (var15 * 256.0D); + int var30 = (int) (var17 * 256.0D); + int var22 = var30 + (var20 << 8) + (var29 << 16); + var22 = adjustRGB(var22, var0); + if (var22 == 0) + { + var22 = 1; + } + + colorPalette[var4++] = var22; + } + } + + } + + static int adjustRGB(int var0, double var1) + { + double var3 = (double) (var0 >> 16) / 256.0D; + double var5 = (double) (var0 >> 8 & 255) / 256.0D; + double var7 = (double) (var0 & 255) / 256.0D; + var3 = Math.pow(var3, var1); + var5 = Math.pow(var5, var1); + var7 = Math.pow(var7, var1); + int var9 = (int) (var3 * 256.0D); + int var10 = (int) (var5 * 256.0D); + int var11 = (int) (var7 * 256.0D); + return var11 + (var10 << 8) + (var9 << 16); + } + + final void rasterGouraud(int var0, int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8) + { + int var9 = var4 - var3; + int var10 = var1 - var0; + int var11 = var5 - var3; + int var12 = var2 - var0; + int var13 = var7 - var6; + int var14 = var8 - var6; + int var15; + if (var2 != var1) + { + var15 = (var5 - var4 << 14) / (var2 - var1); + } + else + { + var15 = 0; + } + + int var16; + if (var0 != var1) + { + var16 = (var9 << 14) / var10; + } + else + { + var16 = 0; + } + + int var17; + if (var0 != var2) + { + var17 = (var11 << 14) / var12; + } + else + { + var17 = 0; + } + + int var18 = var9 * var12 - var11 * var10; + if (var18 != 0) + { + int var19 = (var13 * var12 - var14 * var10 << 8) / var18; + int var20 = (var14 * var9 - var13 * var11 << 8) / var18; + if (var0 <= var1 && var0 <= var2) + { + if (var0 < Rasterizer3D_clipHeight) + { + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + var6 = var19 + ((var6 << 8) - var3 * var19); + if (var1 < var2) + { + var5 = var3 <<= 14; + if (var0 < 0) + { + var5 -= var0 * var17; + var3 -= var0 * var16; + var6 -= var0 * var20; + var0 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var15 * var1; + var1 = 0; + } + + if (var0 != var1 && var17 < var16 || var0 == var1 && var17 > var15) + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2778(graphicsPixels, var0, 0, 0, var5 >> 14, var4 >> 14, var6, var19); + var5 += var17; + var4 += var15; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var0, 0, 0, var5 >> 14, var3 >> 14, var6, var19); + var5 += var17; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + else + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2778(graphicsPixels, var0, 0, 0, var4 >> 14, var5 >> 14, var6, var19); + var5 += var17; + var4 += var15; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var0, 0, 0, var3 >> 14, var5 >> 14, var6, var19); + var5 += var17; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + } + else + { + var4 = var3 <<= 14; + if (var0 < 0) + { + var4 -= var0 * var17; + var3 -= var0 * var16; + var6 -= var0 * var20; + var0 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var15 * var2; + var2 = 0; + } + + if (var0 != var2 && var17 < var16 || var0 == var2 && var15 > var16) + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2778(graphicsPixels, var0, 0, 0, var5 >> 14, var3 >> 14, var6, var19); + var5 += var15; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var0, 0, 0, var4 >> 14, var3 >> 14, var6, var19); + var4 += var17; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + else + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2778(graphicsPixels, var0, 0, 0, var3 >> 14, var5 >> 14, var6, var19); + var5 += var15; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var0, 0, 0, var3 >> 14, var4 >> 14, var6, var19); + var4 += var17; + var3 += var16; + var6 += var20; + var0 += graphicsPixelsWidth; + } + } + } + } + } + else if (var1 <= var2) + { + if (var1 < Rasterizer3D_clipHeight) + { + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + var7 = var19 + ((var7 << 8) - var19 * var4); + if (var2 < var0) + { + var3 = var4 <<= 14; + if (var1 < 0) + { + var3 -= var16 * var1; + var4 -= var15 * var1; + var7 -= var20 * var1; + var1 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var17 * var2; + var2 = 0; + } + + if (var2 != var1 && var16 < var15 || var2 == var1 && var16 > var17) + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2778(graphicsPixels, var1, 0, 0, var3 >> 14, var5 >> 14, var7, var19); + var3 += var16; + var5 += var17; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var1, 0, 0, var3 >> 14, var4 >> 14, var7, var19); + var3 += var16; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + else + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2778(graphicsPixels, var1, 0, 0, var5 >> 14, var3 >> 14, var7, var19); + var3 += var16; + var5 += var17; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var1, 0, 0, var4 >> 14, var3 >> 14, var7, var19); + var3 += var16; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + } + else + { + var5 = var4 <<= 14; + if (var1 < 0) + { + var5 -= var16 * var1; + var4 -= var15 * var1; + var7 -= var20 * var1; + var1 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var17; + var0 = 0; + } + + if (var16 < var15) + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2778(graphicsPixels, var1, 0, 0, var3 >> 14, var4 >> 14, var7, var19); + var3 += var17; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var1, 0, 0, var5 >> 14, var4 >> 14, var7, var19); + var5 += var16; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + else + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2778(graphicsPixels, var1, 0, 0, var4 >> 14, var3 >> 14, var7, var19); + var3 += var17; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var1, 0, 0, var4 >> 14, var5 >> 14, var7, var19); + var5 += var16; + var4 += var15; + var7 += var20; + var1 += graphicsPixelsWidth; + } + } + } + } + } + else if (var2 < Rasterizer3D_clipHeight) + { + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + var8 = var19 + ((var8 << 8) - var5 * var19); + if (var0 < var1) + { + var4 = var5 <<= 14; + if (var2 < 0) + { + var4 -= var15 * var2; + var5 -= var17 * var2; + var8 -= var20 * var2; + var2 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var16; + var0 = 0; + } + + if (var15 < var17) + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2778(graphicsPixels, var2, 0, 0, var4 >> 14, var3 >> 14, var8, var19); + var4 += var15; + var3 += var16; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var2, 0, 0, var4 >> 14, var5 >> 14, var8, var19); + var4 += var15; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + else + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2778(graphicsPixels, var2, 0, 0, var3 >> 14, var4 >> 14, var8, var19); + var4 += var15; + var3 += var16; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var2, 0, 0, var5 >> 14, var4 >> 14, var8, var19); + var4 += var15; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + } + else + { + var3 = var5 <<= 14; + if (var2 < 0) + { + var3 -= var15 * var2; + var5 -= var17 * var2; + var8 -= var20 * var2; + var2 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var16 * var1; + var1 = 0; + } + + if (var15 < var17) + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2778(graphicsPixels, var2, 0, 0, var4 >> 14, var5 >> 14, var8, var19); + var4 += var16; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var2, 0, 0, var3 >> 14, var5 >> 14, var8, var19); + var3 += var15; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + else + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2778(graphicsPixels, var2, 0, 0, var5 >> 14, var4 >> 14, var8, var19); + var4 += var16; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + + method2778(graphicsPixels, var2, 0, 0, var5 >> 14, var3 >> 14, var8, var19); + var3 += var15; + var5 += var17; + var8 += var20; + var2 += graphicsPixelsWidth; + } + } + } + } + } + } + + + final void method2778(int[] var0, int var1, int var2, int var3, int var4, int var5, int var6, int var7) + { + if (rasterClipEnable) + { + if (var5 > rasterClipX) + { + var5 = rasterClipX; + } + + if (var4 < 0) + { + var4 = 0; + } + } + + if (var4 < var5) + { + var1 += var4; + var6 += var4 * var7; + int var8; + int var9; + int var10; + if (rasterGouraudLowRes) + { + var3 = var5 - var4 >> 2; + var7 <<= 2; + if (rasterAlpha == 0) + { + if (var3 > 0) + { + do + { + var2 = colorPalette[var6 >> 8]; + var6 += var7; + var0[var1++] = var2; + var0[var1++] = var2; + var0[var1++] = var2; + var0[var1++] = var2; + --var3; + } while (var3 > 0); + } + + var3 = var5 - var4 & 3; + if (var3 > 0) + { + var2 = colorPalette[var6 >> 8]; + + do + { + var0[var1++] = var2; + --var3; + } while (var3 > 0); + } + } + else + { + var8 = rasterAlpha; + var9 = 256 - rasterAlpha; + if (var3 > 0) + { + do + { + var2 = colorPalette[var6 >> 8]; + var6 += var7; + var2 = (var9 * (var2 & 65280) >> 8 & 65280) + (var9 * (var2 & 16711935) >> 8 & 16711935); + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + --var3; + } while (var3 > 0); + } + + var3 = var5 - var4 & 3; + if (var3 > 0) + { + var2 = colorPalette[var6 >> 8]; + var2 = (var9 * (var2 & 65280) >> 8 & 65280) + (var9 * (var2 & 16711935) >> 8 & 16711935); + + do + { + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + --var3; + } while (var3 > 0); + } + } + + } + else + { + var3 = var5 - var4; + if (rasterAlpha == 0) + { + do + { + var0[var1++] = colorPalette[var6 >> 8]; + var6 += var7; + --var3; + } while (var3 > 0); + } + else + { + var8 = rasterAlpha; + var9 = 256 - rasterAlpha; + + do + { + var2 = colorPalette[var6 >> 8]; + var6 += var7; + var2 = (var9 * (var2 & 65280) >> 8 & 65280) + (var9 * (var2 & 16711935) >> 8 & 16711935); + var10 = var0[var1]; + var0[var1++] = ((var10 & 16711935) * var8 >> 8 & 16711935) + var2 + (var8 * (var10 & 65280) >> 8 & 65280); + --var3; + } while (var3 > 0); + } + + } + } + } + + + public final void rasterFlat(int var0, int var1, int var2, int var3, int var4, int var5, int var6) + { + int var7 = 0; + if (var0 != var1) + { + var7 = (var4 - var3 << 14) / (var1 - var0); + } + + int var8 = 0; + if (var2 != var1) + { + var8 = (var5 - var4 << 14) / (var2 - var1); + } + + int var9 = 0; + if (var0 != var2) + { + var9 = (var3 - var5 << 14) / (var0 - var2); + } + + if (var0 <= var1 && var0 <= var2) + { + if (var0 < Rasterizer3D_clipHeight) + { + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + if (var1 < var2) + { + var5 = var3 <<= 14; + if (var0 < 0) + { + var5 -= var0 * var9; + var3 -= var0 * var7; + var0 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var8 * var1; + var1 = 0; + } + + if ((var0 == var1 || var9 >= var7) && (var0 != var1 || var9 <= var8)) + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2842(graphicsPixels, var0, var6, 0, var4 >> 14, var5 >> 14); + var5 += var9; + var4 += var8; + var0 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var0, var6, 0, var3 >> 14, var5 >> 14); + var5 += var9; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + else + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2842(graphicsPixels, var0, var6, 0, var5 >> 14, var4 >> 14); + var5 += var9; + var4 += var8; + var0 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var0, var6, 0, var5 >> 14, var3 >> 14); + var5 += var9; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + } + else + { + var4 = var3 <<= 14; + if (var0 < 0) + { + var4 -= var0 * var9; + var3 -= var0 * var7; + var0 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var8 * var2; + var2 = 0; + } + + if (var0 != var2 && var9 < var7 || var0 == var2 && var8 > var7) + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2842(graphicsPixels, var0, var6, 0, var5 >> 14, var3 >> 14); + var5 += var8; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var0, var6, 0, var4 >> 14, var3 >> 14); + var4 += var9; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + else + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2842(graphicsPixels, var0, var6, 0, var3 >> 14, var5 >> 14); + var5 += var8; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var0, var6, 0, var3 >> 14, var4 >> 14); + var4 += var9; + var3 += var7; + var0 += graphicsPixelsWidth; + } + } + } + } + } + else if (var1 <= var2) + { + if (var1 < Rasterizer3D_clipHeight) + { + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + if (var2 < var0) + { + var3 = var4 <<= 14; + if (var1 < 0) + { + var3 -= var7 * var1; + var4 -= var8 * var1; + var1 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var9 * var2; + var2 = 0; + } + + if ((var2 == var1 || var7 >= var8) && (var2 != var1 || var7 <= var9)) + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2842(graphicsPixels, var1, var6, 0, var5 >> 14, var3 >> 14); + var3 += var7; + var5 += var9; + var1 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var1, var6, 0, var4 >> 14, var3 >> 14); + var3 += var7; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + else + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2842(graphicsPixels, var1, var6, 0, var3 >> 14, var5 >> 14); + var3 += var7; + var5 += var9; + var1 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var1, var6, 0, var3 >> 14, var4 >> 14); + var3 += var7; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + } + else + { + var5 = var4 <<= 14; + if (var1 < 0) + { + var5 -= var7 * var1; + var4 -= var8 * var1; + var1 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var9; + var0 = 0; + } + + if (var7 < var8) + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2842(graphicsPixels, var1, var6, 0, var3 >> 14, var4 >> 14); + var3 += var9; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var1, var6, 0, var5 >> 14, var4 >> 14); + var5 += var7; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + else + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2842(graphicsPixels, var1, var6, 0, var4 >> 14, var3 >> 14); + var3 += var9; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var1, var6, 0, var4 >> 14, var5 >> 14); + var5 += var7; + var4 += var8; + var1 += graphicsPixelsWidth; + } + } + } + } + } + else if (var2 < Rasterizer3D_clipHeight) + { + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + if (var0 < var1) + { + var4 = var5 <<= 14; + if (var2 < 0) + { + var4 -= var8 * var2; + var5 -= var9 * var2; + var2 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var7; + var0 = 0; + } + + if (var8 < var9) + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2842(graphicsPixels, var2, var6, 0, var4 >> 14, var3 >> 14); + var4 += var8; + var3 += var7; + var2 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var2, var6, 0, var4 >> 14, var5 >> 14); + var4 += var8; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + else + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2842(graphicsPixels, var2, var6, 0, var3 >> 14, var4 >> 14); + var4 += var8; + var3 += var7; + var2 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var2, var6, 0, var5 >> 14, var4 >> 14); + var4 += var8; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + } + else + { + var3 = var5 <<= 14; + if (var2 < 0) + { + var3 -= var8 * var2; + var5 -= var9 * var2; + var2 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var7 * var1; + var1 = 0; + } + + if (var8 < var9) + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2842(graphicsPixels, var2, var6, 0, var4 >> 14, var5 >> 14); + var4 += var7; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var2, var6, 0, var3 >> 14, var5 >> 14); + var3 += var8; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + else + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2842(graphicsPixels, var2, var6, 0, var5 >> 14, var4 >> 14); + var4 += var7; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + + method2842(graphicsPixels, var2, var6, 0, var5 >> 14, var3 >> 14); + var3 += var8; + var5 += var9; + var2 += graphicsPixelsWidth; + } + } + } + } + } + + + final void method2842(int[] var0, int var1, int var2, int var3, int var4, int var5) + { + if (rasterClipEnable) + { + if (var5 > rasterClipX) + { + var5 = rasterClipX; + } + + if (var4 < 0) + { + var4 = 0; + } + } + + if (var4 < var5) + { + var1 += var4; + var3 = var5 - var4 >> 2; + if (rasterAlpha != 0) + { + if (rasterAlpha == 254) + { + while (true) + { + --var3; + if (var3 < 0) + { + var3 = var5 - var4 & 3; + + while (true) + { + --var3; + if (var3 < 0) + { + return; + } + + var0[var1++] = var0[var1]; + } + } + + var0[var1++] = var0[var1]; + var0[var1++] = var0[var1]; + var0[var1++] = var0[var1]; + var0[var1++] = var0[var1]; + } + } + else + { + int var6 = rasterAlpha; + int var7 = 256 - rasterAlpha; + var2 = (var7 * (var2 & 65280) >> 8 & 65280) + (var7 * (var2 & 16711935) >> 8 & 16711935); + + while (true) + { + --var3; + int var8; + if (var3 < 0) + { + var3 = var5 - var4 & 3; + + while (true) + { + --var3; + if (var3 < 0) + { + return; + } + + var8 = var0[var1]; + var0[var1++] = ((var8 & 16711935) * var6 >> 8 & 16711935) + var2 + (var6 * (var8 & 65280) >> 8 & 65280); + } + } + + var8 = var0[var1]; + var0[var1++] = ((var8 & 16711935) * var6 >> 8 & 16711935) + var2 + (var6 * (var8 & 65280) >> 8 & 65280); + var8 = var0[var1]; + var0[var1++] = ((var8 & 16711935) * var6 >> 8 & 16711935) + var2 + (var6 * (var8 & 65280) >> 8 & 65280); + var8 = var0[var1]; + var0[var1++] = ((var8 & 16711935) * var6 >> 8 & 16711935) + var2 + (var6 * (var8 & 65280) >> 8 & 65280); + var8 = var0[var1]; + var0[var1++] = ((var8 & 16711935) * var6 >> 8 & 16711935) + var2 + (var6 * (var8 & 65280) >> 8 & 65280); + } + } + } + else + { + while (true) + { + --var3; + if (var3 < 0) + { + var3 = var5 - var4 & 3; + + while (true) + { + --var3; + if (var3 < 0) + { + return; + } + + var0[var1++] = var2; + } + } + + var0[var1++] = var2; + var0[var1++] = var2; + var0[var1++] = var2; + var0[var1++] = var2; + } + } + } + } + + + final void rasterTextureAffine(int var0, int var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, int var12, int var13, int var14, int var15, int var16, int var17, int var18) + { + int[] var19 = textureProvider.load(var18); + int var20; + if (var19 == null) + { + var20 = textureProvider.getAverageTextureRGB(var18); + rasterGouraud(var0, var1, var2, var3, var4, var5, method2794(var20, var6), method2794(var20, var7), method2794(var20, var8)); + } + else + { + lowMem = textureProvider.vmethod3066(var18); + field1909 = textureProvider.vmethod3057(var18); + var20 = var4 - var3; + int var21 = var1 - var0; + int var22 = var5 - var3; + int var23 = var2 - var0; + int var24 = var7 - var6; + int var25 = var8 - var6; + int var26 = 0; + if (var0 != var1) + { + var26 = (var4 - var3 << 14) / (var1 - var0); + } + + int var27 = 0; + if (var2 != var1) + { + var27 = (var5 - var4 << 14) / (var2 - var1); + } + + int var28 = 0; + if (var0 != var2) + { + var28 = (var3 - var5 << 14) / (var0 - var2); + } + + int var29 = var20 * var23 - var22 * var21; + if (var29 != 0) + { + int var30 = (var24 * var23 - var25 * var21 << 9) / var29; + int var31 = (var25 * var20 - var24 * var22 << 9) / var29; + var10 = var9 - var10; + var13 = var12 - var13; + var16 = var15 - var16; + var11 -= var9; + var14 -= var12; + var17 -= var15; + int var32 = var11 * var12 - var9 * var14 << 14; + int var33 = (int) (((long) (var15 * var14 - var17 * var12) << 3 << 14) / (long) Rasterizer3D_zoom); + int var34 = (int) (((long) (var17 * var9 - var11 * var15) << 14) / (long) Rasterizer3D_zoom); + int var35 = var10 * var12 - var13 * var9 << 14; + int var36 = (int) (((long) (var13 * var15 - var16 * var12) << 3 << 14) / (long) Rasterizer3D_zoom); + int var37 = (int) (((long) (var16 * var9 - var10 * var15) << 14) / (long) Rasterizer3D_zoom); + int var38 = var13 * var11 - var10 * var14 << 14; + int var39 = (int) (((long) (var16 * var14 - var13 * var17) << 3 << 14) / (long) Rasterizer3D_zoom); + int var40 = (int) (((long) (var17 * var10 - var11 * var16) << 14) / (long) Rasterizer3D_zoom); + int var41; + if (var0 <= var1 && var0 <= var2) + { + if (var0 < Rasterizer3D_clipHeight) + { + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + var6 = var30 + ((var6 << 9) - var3 * var30); + if (var1 < var2) + { + var5 = var3 <<= 14; + if (var0 < 0) + { + var5 -= var0 * var28; + var3 -= var0 * var26; + var6 -= var0 * var31; + var0 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var27 * var1; + var1 = 0; + } + + var41 = var0 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if ((var0 == var1 || var28 >= var26) && (var0 != var1 || var28 <= var27)) + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var0, var4 >> 14, var5 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var28; + var4 += var27; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var0, var3 >> 14, var5 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var28; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var2 -= var1; + var1 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var0, var5 >> 14, var4 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var28; + var4 += var27; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var0, var5 >> 14, var3 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var28; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + else + { + var4 = var3 <<= 14; + if (var0 < 0) + { + var4 -= var0 * var28; + var3 -= var0 * var26; + var6 -= var0 * var31; + var0 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var27 * var2; + var2 = 0; + } + + var41 = var0 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if (var0 != var2 && var28 < var26 || var0 == var2 && var27 > var26) + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var0, var5 >> 14, var3 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var27; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var0, var4 >> 14, var3 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var4 += var28; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var1 -= var2; + var2 -= var0; + var0 = rasterClipY[var0]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var0, var3 >> 14, var5 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var5 += var27; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var0, var3 >> 14, var4 >> 14, var6, var30, var32, var35, var38, var33, var36, var39); + var4 += var28; + var3 += var26; + var6 += var31; + var0 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + } + } + else if (var1 <= var2) + { + if (var1 < Rasterizer3D_clipHeight) + { + if (var2 > Rasterizer3D_clipHeight) + { + var2 = Rasterizer3D_clipHeight; + } + + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + var7 = var30 + ((var7 << 9) - var30 * var4); + if (var2 < var0) + { + var3 = var4 <<= 14; + if (var1 < 0) + { + var3 -= var26 * var1; + var4 -= var27 * var1; + var7 -= var31 * var1; + var1 = 0; + } + + var5 <<= 14; + if (var2 < 0) + { + var5 -= var28 * var2; + var2 = 0; + } + + var41 = var1 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if ((var2 == var1 || var26 >= var27) && (var2 != var1 || var26 <= var28)) + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var1, var5 >> 14, var3 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var26; + var5 += var28; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var1, var4 >> 14, var3 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var26; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var0 -= var2; + var2 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var2; + if (var2 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var1, var3 >> 14, var5 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var26; + var5 += var28; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var1, var3 >> 14, var4 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var26; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + else + { + var5 = var4 <<= 14; + if (var1 < 0) + { + var5 -= var26 * var1; + var4 -= var27 * var1; + var7 -= var31 * var1; + var1 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var28; + var0 = 0; + } + + var41 = var1 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if (var26 < var27) + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var1, var3 >> 14, var4 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var28; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var1, var5 >> 14, var4 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var5 += var26; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var2 -= var0; + var0 -= var1; + var1 = rasterClipY[var1]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var2; + if (var2 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var1, var4 >> 14, var3 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var3 += var28; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var1, var4 >> 14, var5 >> 14, var7, var30, var32, var35, var38, var33, var36, var39); + var5 += var26; + var4 += var27; + var7 += var31; + var1 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + } + } + else if (var2 < Rasterizer3D_clipHeight) + { + if (var0 > Rasterizer3D_clipHeight) + { + var0 = Rasterizer3D_clipHeight; + } + + if (var1 > Rasterizer3D_clipHeight) + { + var1 = Rasterizer3D_clipHeight; + } + + var8 = (var8 << 9) - var5 * var30 + var30; + if (var0 < var1) + { + var4 = var5 <<= 14; + if (var2 < 0) + { + var4 -= var27 * var2; + var5 -= var28 * var2; + var8 -= var31 * var2; + var2 = 0; + } + + var3 <<= 14; + if (var0 < 0) + { + var3 -= var0 * var26; + var0 = 0; + } + + var41 = var2 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if (var27 < var28) + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var2, var4 >> 14, var3 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var27; + var3 += var26; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var2, var4 >> 14, var5 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var27; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var1 -= var0; + var0 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var0; + if (var0 < 0) + { + while (true) + { + --var1; + if (var1 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var2, var3 >> 14, var4 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var27; + var3 += var26; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var2, var5 >> 14, var4 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var27; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + else + { + var3 = var5 <<= 14; + if (var2 < 0) + { + var3 -= var27 * var2; + var5 -= var28 * var2; + var8 -= var31 * var2; + var2 = 0; + } + + var4 <<= 14; + if (var1 < 0) + { + var4 -= var26 * var1; + var1 = 0; + } + + var41 = var2 - centerY; + var32 += var34 * var41; + var35 += var37 * var41; + var38 += var40 * var41; + if (var27 < var28) + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var2, var4 >> 14, var5 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var26; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var2, var3 >> 14, var5 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var3 += var27; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + else + { + var0 -= var1; + var1 -= var2; + var2 = rasterClipY[var2]; + + while (true) + { + --var1; + if (var1 < 0) + { + while (true) + { + --var0; + if (var0 < 0) + { + return; + } + + method2791(graphicsPixels, var19, 0, 0, var2, var5 >> 14, var4 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var4 += var26; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + + method2791(graphicsPixels, var19, 0, 0, var2, var5 >> 14, var3 >> 14, var8, var30, var32, var35, var38, var33, var36, var39); + var3 += var27; + var5 += var28; + var8 += var31; + var2 += graphicsPixelsWidth; + var32 += var34; + var35 += var37; + var38 += var40; + } + } + } + } + } + } + } + + + final void method2791(int[] var0, int[] var1, int var2, int var3, int var4, int var5, int var6, int var7, int var8, int var9, int var10, int var11, int var12, int var13, int var14) + { + if (rasterClipEnable) + { + if (var6 > rasterClipX) + { + var6 = rasterClipX; + } + + if (var5 < 0) + { + var5 = 0; + } + } + + if (var5 < var6) + { + var4 += var5; + var7 += var5 * var8; + int var17 = var6 - var5; + int var15; + int var16; + int var10000; + int var18; + int var19; + int var20; + int var21; + int var22; + int var23; + if (lowMem) + { + var23 = var5 - centerX; + var9 += var23 * (var12 >> 3); + var10 += (var13 >> 3) * var23; + var11 += var23 * (var14 >> 3); + var22 = var11 >> 12; + if (var22 != 0) + { + var18 = var9 / var22; + var19 = var10 / var22; + if (var18 < 0) + { + var18 = 0; + } + else if (var18 > 4032) + { + var18 = 4032; + } + } + else + { + var18 = 0; + var19 = 0; + } + + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 12; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 4032) + { + var20 = 4032; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 20) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 20); + var17 >>= 3; + var8 <<= 3; + var15 = var7 >> 8; + if (field1909) + { + if (var17 > 0) + { + do + { + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var10000 = var16 + var2; + var18 = var20; + var19 = var21; + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 12; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 4032) + { + var20 = 4032; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 20) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 20); + var7 += var8; + var15 = var7 >> 8; + --var17; + } while (var17 > 0); + } + + var17 = var6 - var5 & 7; + if (var17 > 0) + { + do + { + var3 = var1[(var2 >>> 26) + (var2 & 4032)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + --var17; + } while (var17 > 0); + } + } + else + { + if (var17 > 0) + { + do + { + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var10000 = var16 + var2; + var18 = var20; + var19 = var21; + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 12; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 4032) + { + var20 = 4032; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 20) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 20); + var7 += var8; + var15 = var7 >> 8; + --var17; + } while (var17 > 0); + } + + var17 = var6 - var5 & 7; + if (var17 > 0) + { + do + { + if ((var3 = var1[(var2 >>> 26) + (var2 & 4032)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + --var17; + } while (var17 > 0); + } + } + } + else + { + var23 = var5 - centerX; + var9 += var23 * (var12 >> 3); + var10 += (var13 >> 3) * var23; + var11 += var23 * (var14 >> 3); + var22 = var11 >> 14; + if (var22 != 0) + { + var18 = var9 / var22; + var19 = var10 / var22; + if (var18 < 0) + { + var18 = 0; + } + else if (var18 > 16256) + { + var18 = 16256; + } + } + else + { + var18 = 0; + var19 = 0; + } + + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 14; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 16256) + { + var20 = 16256; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 18) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 18); + var17 >>= 3; + var8 <<= 3; + var15 = var7 >> 8; + if (field1909) + { + if (var17 > 0) + { + do + { + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var10000 = var16 + var2; + var18 = var20; + var19 = var21; + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 14; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 16256) + { + var20 = 16256; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 18) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 18); + var7 += var8; + var15 = var7 >> 8; + --var17; + } while (var17 > 0); + } + + var17 = var6 - var5 & 7; + if (var17 > 0) + { + do + { + var3 = var1[(var2 & 16256) + (var2 >>> 25)]; + var0[var4++] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + var2 += var16; + --var17; + } while (var17 > 0); + } + } + else + { + if (var17 > 0) + { + do + { + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var10000 = var16 + var2; + var18 = var20; + var19 = var21; + var9 += var12; + var10 += var13; + var11 += var14; + var22 = var11 >> 14; + if (var22 != 0) + { + var20 = var9 / var22; + var21 = var10 / var22; + if (var20 < 0) + { + var20 = 0; + } + else if (var20 > 16256) + { + var20 = 16256; + } + } + else + { + var20 = 0; + var21 = 0; + } + + var2 = (var18 << 18) + var19; + var16 = (var21 - var19 >> 3) + (var20 - var18 >> 3 << 18); + var7 += var8; + var15 = var7 >> 8; + --var17; + } while (var17 > 0); + } + + var17 = var6 - var5 & 7; + if (var17 > 0) + { + do + { + if ((var3 = var1[(var2 & 16256) + (var2 >>> 25)]) != 0) + { + var0[var4] = (var15 * (var3 & 65280) & 16711680) + ((var3 & 16711935) * var15 & -16711936) >> 8; + } + + ++var4; + var2 += var16; + --var17; + } while (var17 > 0); + } + } + } + + } + } + + static final int method2794(int var0, int var1) + { + var1 = (var0 & 127) * var1 >> 7; + if (var1 < 2) + { + var1 = 2; + } + else if (var1 > 126) + { + var1 = 126; + } + + return (var0 & 65408) + var1; + } +} diff --git a/cache/src/main/java/net/runelite/cache/item/ItemSpriteFactory.java b/cache/src/main/java/net/runelite/cache/item/ItemSpriteFactory.java new file mode 100644 index 0000000000..c93edf3611 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/ItemSpriteFactory.java @@ -0,0 +1,439 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +import java.awt.image.BufferedImage; +import java.io.IOException; +import net.runelite.cache.definitions.ItemDefinition; +import net.runelite.cache.definitions.ModelDefinition; +import net.runelite.cache.definitions.providers.ItemProvider; +import net.runelite.cache.definitions.providers.ModelProvider; +import net.runelite.cache.definitions.providers.SpriteProvider; +import net.runelite.cache.definitions.providers.TextureProvider; +import net.runelite.cache.models.FaceNormal; +import net.runelite.cache.models.VertexNormal; + +public class ItemSpriteFactory +{ + public static final BufferedImage createSprite(ItemProvider itemProvider, ModelProvider modelProvider, + SpriteProvider spriteProvider, TextureProvider textureProvider, + int itemId, int quantity, int border, int shadowColor, + boolean noted) throws IOException + { + SpritePixels spritePixels = createSpritePixels(itemProvider, modelProvider, spriteProvider, textureProvider, + itemId, quantity, border, shadowColor, noted); + return spritePixels == null ? null : spritePixels.toBufferedImage(); + } + + private static final SpritePixels createSpritePixels(ItemProvider itemProvider, ModelProvider modelProvider, + SpriteProvider spriteProvider, TextureProvider textureProvider, + int itemId, int quantity, int border, int shadowColor, + boolean noted) throws IOException + { + ItemDefinition item = itemProvider.provide(itemId); + + if (quantity > 1 && item.countObj != null) + { + int stackItemID = -1; + + for (int i = 0; i < 10; ++i) + { + if (quantity >= item.countCo[i] && item.countCo[i] != 0) + { + stackItemID = item.countObj[i]; + } + } + + if (stackItemID != -1) + { + item = itemProvider.provide(stackItemID); + } + } + + if (item.notedTemplate != -1) + { + item.updateNote(itemProvider.provide(item.notedTemplate), itemProvider.provide(item.notedID)); + } + + Model itemModel = getModel(modelProvider, item); + if (itemModel == null) + { + return null; + } + + SpritePixels auxSpritePixels = null; + if (item.notedTemplate != -1) + { + auxSpritePixels = createSpritePixels(itemProvider, modelProvider, spriteProvider, textureProvider, + item.notedID, 10, 1, 0, true); + if (auxSpritePixels == null) + { + return null; + } + } + else if (item.boughtTemplateId != -1) + { + auxSpritePixels = createSpritePixels(itemProvider, modelProvider, spriteProvider, textureProvider, + item.boughtId, quantity, border, shadowColor, false); + if (auxSpritePixels == null) + { + return null; + } + } + else if (item.placeholderTemplateId != -1) + { + auxSpritePixels = createSpritePixels(itemProvider, modelProvider, spriteProvider, textureProvider, + item.placeholderId, quantity, 0, 0, false); + if (auxSpritePixels == null) + { + return null; + } + } + + RSTextureProvider rsTextureProvider = new RSTextureProvider(textureProvider, spriteProvider); + + SpritePixels spritePixels = new SpritePixels(36, 32); + Graphics3D graphics = new Graphics3D(rsTextureProvider); + graphics.setBrightness(0.6d); + graphics.setRasterBuffer(spritePixels.pixels, 36, 32); + graphics.reset(); + graphics.setRasterClipping(); + graphics.setOffset(16, 16); + graphics.rasterGouraudLowRes = false; + if (item.placeholderTemplateId != -1) + { + auxSpritePixels.drawAtOn(graphics, 0, 0); + } + + int zoom2d = item.zoom2d; + if (noted) + { + zoom2d = (int) ((double) zoom2d * 1.5D); + } + else if (border == 2) + { + zoom2d = (int) ((double) zoom2d * 1.04D); + } + + int var17 = zoom2d * Graphics3D.SINE[item.xan2d] >> 16; + int var18 = zoom2d * Graphics3D.COSINE[item.xan2d] >> 16; + + itemModel.calculateBoundsCylinder(); + itemModel.rotateAndProject(graphics, 0, + item.yan2d, + item.zan2d, + item.xan2d, + item.xOffset2d, + itemModel.modelHeight / 2 + var17 + item.yOffset2d, + var18 + item.yOffset2d); + if (item.boughtTemplateId != -1) + { + auxSpritePixels.drawAtOn(graphics, 0, 0); + } + + if (border >= 1) + { + spritePixels.drawBorder(1); + } + + if (border >= 2) + { + spritePixels.drawBorder(0xffffff); + } + + if (shadowColor != 0) + { + spritePixels.drawShadow(shadowColor); + } + + graphics.setRasterBuffer(spritePixels.pixels, 36, 32); + if (item.notedTemplate != -1) + { + auxSpritePixels.drawAtOn(graphics, 0, 0); + } + + graphics.setRasterBuffer(graphics.graphicsPixels, + graphics.graphicsPixelsWidth, + graphics.graphicsPixelsHeight); + + graphics.setRasterClipping(); + graphics.rasterGouraudLowRes = true; + return spritePixels; + } + + private static Model getModel(ModelProvider modelProvider, ItemDefinition item) throws IOException + { + Model itemModel; + ModelDefinition inventoryModel = modelProvider.provide(item.inventoryModel); + if (inventoryModel == null) + { + return null; + } + + if (item.resizeX != 128 || item.resizeY != 128 || item.resizeZ != 128) + { + inventoryModel.resize(item.resizeX, item.resizeY, item.resizeZ); + } + + if (item.colorFind != null) + { + for (int i = 0; i < item.colorFind.length; ++i) + { + inventoryModel.recolor(item.colorFind[i], item.colorReplace[i]); + } + } + + if (item.textureFind != null) + { + for (int i = 0; i < item.textureFind.length; ++i) + { + inventoryModel.retexture(item.textureFind[i], item.textureReplace[i]); + } + } + + itemModel = light(inventoryModel, item.ambient + 64, item.contrast + 768, -50, -10, -50); + itemModel.isItemModel = true; + return itemModel; + } + + private static Model light(ModelDefinition def, int ambient, int contrast, int x, int y, int z) + { + def.computeNormals(); + int somethingMagnitude = (int) Math.sqrt((double) (z * z + x * x + y * y)); + int var7 = somethingMagnitude * contrast >> 8; + Model litModel = new Model(); + litModel.field1856 = new int[def.faceCount]; + litModel.field1854 = new int[def.faceCount]; + litModel.field1823 = new int[def.faceCount]; + if (def.textureTriangleCount > 0 && def.textureCoordinates != null) + { + int[] var9 = new int[def.textureTriangleCount]; + + int var10; + for (var10 = 0; var10 < def.faceCount; ++var10) + { + if (def.textureCoordinates[var10] != -1) + { + ++var9[def.textureCoordinates[var10] & 255]; + } + } + + litModel.field1852 = 0; + + for (var10 = 0; var10 < def.textureTriangleCount; ++var10) + { + if (var9[var10] > 0 && def.textureRenderTypes[var10] == 0) + { + ++litModel.field1852; + } + } + + litModel.field1844 = new int[litModel.field1852]; + litModel.field1865 = new int[litModel.field1852]; + litModel.field1846 = new int[litModel.field1852]; + var10 = 0; + + + for (int i = 0; i < def.textureTriangleCount; ++i) + { + if (var9[i] > 0 && def.textureRenderTypes[i] == 0) + { + litModel.field1844[var10] = def.textureTriangleVertexIndices1[i] & '\uffff'; + litModel.field1865[var10] = def.textureTriangleVertexIndices2[i] & '\uffff'; + litModel.field1846[var10] = def.textureTriangleVertexIndices3[i] & '\uffff'; + var9[i] = var10++; + } + else + { + var9[i] = -1; + } + } + + litModel.field1840 = new byte[def.faceCount]; + + for (int i = 0; i < def.faceCount; ++i) + { + if (def.textureCoordinates[i] != -1) + { + litModel.field1840[i] = (byte) var9[def.textureCoordinates[i] & 255]; + } + else + { + litModel.field1840[i] = -1; + } + } + } + + for (int faceIdx = 0; faceIdx < def.faceCount; ++faceIdx) + { + byte faceType; + if (def.faceRenderTypes == null) + { + faceType = 0; + } + else + { + faceType = def.faceRenderTypes[faceIdx]; + } + + byte faceAlpha; + if (def.faceAlphas == null) + { + faceAlpha = 0; + } + else + { + faceAlpha = def.faceAlphas[faceIdx]; + } + + short faceTexture; + if (def.faceTextures == null) + { + faceTexture = -1; + } + else + { + faceTexture = def.faceTextures[faceIdx]; + } + + if (faceAlpha == -2) + { + faceType = 3; + } + + if (faceAlpha == -1) + { + faceType = 2; + } + + VertexNormal vertexNormal; + int tmp; + FaceNormal faceNormal; + if (faceTexture == -1) + { + if (faceType != 0) + { + if (faceType == 1) + { + faceNormal = def.faceNormals[faceIdx]; + tmp = (y * faceNormal.y + z * faceNormal.z + x * faceNormal.x) / (var7 / 2 + var7) + ambient; + litModel.field1856[faceIdx] = method2608(def.faceColors[faceIdx] & '\uffff', tmp); + litModel.field1823[faceIdx] = -1; + } + else if (faceType == 3) + { + litModel.field1856[faceIdx] = 128; + litModel.field1823[faceIdx] = -1; + } + else + { + litModel.field1823[faceIdx] = -2; + } + } + else + { + int var15 = def.faceColors[faceIdx] & '\uffff'; + vertexNormal = def.vertexNormals[def.faceVertexIndices1[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1856[faceIdx] = method2608(var15, tmp); + vertexNormal = def.vertexNormals[def.faceVertexIndices2[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1854[faceIdx] = method2608(var15, tmp); + vertexNormal = def.vertexNormals[def.faceVertexIndices3[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1823[faceIdx] = method2608(var15, tmp); + } + } + else if (faceType != 0) + { + if (faceType == 1) + { + faceNormal = def.faceNormals[faceIdx]; + tmp = (y * faceNormal.y + z * faceNormal.z + x * faceNormal.x) / (var7 / 2 + var7) + ambient; + litModel.field1856[faceIdx] = bound2to126(tmp); + litModel.field1823[faceIdx] = -1; + } + else + { + litModel.field1823[faceIdx] = -2; + } + } + else + { + vertexNormal = def.vertexNormals[def.faceVertexIndices1[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1856[faceIdx] = bound2to126(tmp); + vertexNormal = def.vertexNormals[def.faceVertexIndices2[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1854[faceIdx] = bound2to126(tmp); + vertexNormal = def.vertexNormals[def.faceVertexIndices3[faceIdx]]; + + tmp = (y * vertexNormal.y + z * vertexNormal.z + x * vertexNormal.x) / (var7 * vertexNormal.magnitude) + ambient; + litModel.field1823[faceIdx] = bound2to126(tmp); + } + } + + litModel.verticesCount = def.vertexCount; + litModel.verticesX = def.vertexPositionsX; + litModel.verticesY = def.vertexPositionsY; + litModel.verticesZ = def.vertexPositionsZ; + litModel.indicesCount = def.faceCount; + litModel.indices1 = def.faceVertexIndices1; + litModel.indices2 = def.faceVertexIndices2; + litModel.indices3 = def.faceVertexIndices3; + litModel.field1838 = def.faceRenderPriorities; + litModel.field1882 = def.faceAlphas; + litModel.field1842 = def.priority; + litModel.field1841 = def.faceTextures; + return litModel; + } + + static final int method2608(int var0, int var1) + { + var1 = ((var0 & 127) * var1) >> 7; + var1 = bound2to126(var1); + + return (var0 & 65408) + var1; + } + + static final int bound2to126(int var0) + { + if (var0 < 2) + { + var0 = 2; + } + else if (var0 > 126) + { + var0 = 126; + } + + return var0; + } +} diff --git a/cache/src/main/java/net/runelite/cache/item/Model.java b/cache/src/main/java/net/runelite/cache/item/Model.java new file mode 100644 index 0000000000..e35943acfb --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/Model.java @@ -0,0 +1,773 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +class Model extends Renderable +{ + boolean[] field1887 = new boolean[4700]; + boolean[] field1885 = new boolean[4700]; + int[] modelViewportYs = new int[4700]; + int[] modelViewportXs = new int[4700]; + int[] modelViewportZs = new int[4700]; + int[] yViewportBuffer = new int[4700]; + int[] field1839 = new int[4700]; + int[] field1869 = new int[4700]; + int[] field1871 = new int[1600]; + int[][] field1868 = new int[1600][512]; + int[] field1872 = new int[12]; + int[][] field1874 = new int[12][2000]; + int[] field1857 = new int[2000]; + int[] field1863 = new int[2000]; + int[] field1877 = new int[12]; + int[] field1831 = new int[10]; + int[] field1837 = new int[10]; + int[] xViewportBuffer = new int[10]; + static int[] Model_sine; + static int[] Model_cosine; + static int[] field1890; + int verticesCount; + int[] verticesX; + int[] verticesY; + int[] verticesZ; + int indicesCount; + int[] indices1; + int[] indices2; + int[] indices3; + int[] field1856; + int[] field1854; + int[] field1823; + byte[] field1838; + byte[] field1882; + byte[] field1840; + short[] field1841; + byte field1842; + int field1852; + int[] field1844; + int[] field1865; + int[] field1846; + public boolean isItemModel; + int boundsType; + int bottomY; + int XYZMag; + int diameter; + int radius; + public int extremeX; + public int extremeY; + public int extremeZ; + + static + { + Model_sine = Graphics3D.SINE; + Model_cosine = Graphics3D.COSINE; + field1890 = Graphics3D.field1933; + } + + Model() + { + this.verticesCount = 0; + this.indicesCount = 0; + this.field1842 = 0; + this.field1852 = 0; + this.isItemModel = false; + this.extremeX = -1; + this.extremeY = -1; + this.extremeZ = -1; + } + + public void calculateBoundsCylinder() + { + if (this.boundsType != 1) + { + this.boundsType = 1; + super.modelHeight = 0; + this.bottomY = 0; + this.XYZMag = 0; + + for (int var1 = 0; var1 < this.verticesCount; ++var1) + { + int var2 = this.verticesX[var1]; + int var3 = this.verticesY[var1]; + int var4 = this.verticesZ[var1]; + if (-var3 > super.modelHeight) + { + super.modelHeight = -var3; + } + + if (var3 > this.bottomY) + { + this.bottomY = var3; + } + + int var5 = var2 * var2 + var4 * var4; + if (var5 > this.XYZMag) + { + this.XYZMag = var5; + } + } + + this.XYZMag = (int) (Math.sqrt((double) this.XYZMag) + 0.99D); + this.radius = (int) (Math.sqrt((double) (this.XYZMag * this.XYZMag + super.modelHeight * super.modelHeight)) + 0.99D); + this.diameter = this.radius + (int) (Math.sqrt((double) (this.XYZMag * this.XYZMag + this.bottomY * this.bottomY)) + 0.99D); + } + } + + public final void rotateAndProject(Graphics3D graphics, int rotation_1, int yRotation, int zRotation, int xRotation, int xOffset, int yOffset, int zOffset) + { + field1871[0] = -1; + // (re?)Calculate magnitude as necessary + if (this.boundsType != 2 && this.boundsType != 1) + { + this.boundsType = 2; + this.XYZMag = 0; + + for (int var1 = 0; var1 < this.verticesCount; ++var1) + { + int x = this.verticesX[var1]; + int y = this.verticesY[var1]; + int z = this.verticesZ[var1]; + int magnitude_squared = x * x + z * z + y * y; + if (magnitude_squared > this.XYZMag) + { + this.XYZMag = magnitude_squared; + } + } + + this.XYZMag = (int) (Math.sqrt((double) this.XYZMag) + 0.99D); + this.radius = this.XYZMag; + this.diameter = this.XYZMag + this.XYZMag; + } + + // rotate + perspective transform + int sinX = Model_sine[xRotation]; + int cosX = Model_cosine[xRotation]; + int zRelatedVariable = sinX * yOffset + cosX * zOffset >> 16; + + for (int i = 0; i < this.verticesCount; ++i) + { + int x = this.verticesX[i]; + int y = this.verticesY[i]; + int z = this.verticesZ[i]; + if (zRotation != 0) + { + int sinZ = Model_sine[zRotation]; + int cosZ = Model_cosine[zRotation]; + int tmp; + tmp = y * sinZ + x * cosZ >> 16; + y = y * cosZ - x * sinZ >> 16; + x = tmp; + } + + if (rotation_1 != 0) + { + int sinR1 = Model_sine[rotation_1]; + int cosR1 = Model_cosine[rotation_1]; + int tmp; + tmp = y * cosR1 - z * sinR1 >> 16; + z = y * sinR1 + z * cosR1 >> 16; + y = tmp; + } + + if (yRotation != 0) + { + int sinY = Model_sine[yRotation]; + int cosY = Model_cosine[yRotation]; + int tmp; + tmp = z * sinY + x * cosY >> 16; + z = z * cosY - x * sinY >> 16; + x = tmp; + } + + x += xOffset; + y += yOffset; + z += zOffset; + int tmp = y * cosX - z * sinX >> 16; + z = y * sinX + z * cosX >> 16; + modelViewportZs[i] = z - zRelatedVariable; + modelViewportYs[i] = x * graphics.Rasterizer3D_zoom / z + graphics.centerX; + modelViewportXs[i] = tmp * graphics.Rasterizer3D_zoom / z + graphics.centerY; + if (this.field1852 > 0) + { + yViewportBuffer[i] = x; + field1839[i] = tmp; + field1869[i] = z; + } + } + + this.method0(graphics, false, false, 0); + } + + + private void method0(Graphics3D graphics, boolean var1, boolean var3, int var4) + { + if (this.diameter < 1600) + { + for (int var5 = 0; var5 < this.diameter; ++var5) + { + field1871[var5] = 0; + } + + int var7; + int var9; + int var10; + int var11; + int var12; + int var13; + int var14; + int var15; + int var16; + int var17; + int var18; + int var19; + int var20; + int var27; + + int var26; + for (var26 = 0; var26 < this.indicesCount; ++var26) + { + if (this.field1823[var26] != -2) + { + var7 = this.indices1[var26]; + var27 = this.indices2[var26]; + var9 = this.indices3[var26]; + var10 = modelViewportYs[var7]; + var11 = modelViewportYs[var27]; + var12 = modelViewportYs[var9]; + if (var1 && (var10 == -5000 || var11 == -5000 || var12 == -5000)) + { + var13 = yViewportBuffer[var7]; + var14 = yViewportBuffer[var27]; + var15 = yViewportBuffer[var9]; + var16 = field1839[var7]; + var17 = field1839[var27]; + var18 = field1839[var9]; + var19 = field1869[var7]; + var20 = field1869[var27]; + int var21 = field1869[var9]; + var13 -= var14; + var15 -= var14; + var16 -= var17; + var18 -= var17; + var19 -= var20; + var21 -= var20; + int var22 = var16 * var21 - var19 * var18; + int var23 = var19 * var15 - var13 * var21; + int var24 = var13 * var18 - var16 * var15; + if (var14 * var22 + var17 * var23 + var20 * var24 > 0) + { + field1885[var26] = true; + int var25 = (modelViewportZs[var7] + modelViewportZs[var27] + modelViewportZs[var9]) / 3 + this.radius; + field1868[var25][field1871[var25]++] = var26; + } + } + else + { + if ((var10 - var11) * (modelViewportXs[var9] - modelViewportXs[var27]) - (var12 - var11) * (modelViewportXs[var7] - modelViewportXs[var27]) > 0) + { + field1885[var26] = false; + if (var10 >= 0 && var11 >= 0 && var12 >= 0 && var10 <= graphics.rasterClipX && var11 <= graphics.rasterClipX && var12 <= graphics.rasterClipX) + { + field1887[var26] = false; + } + else + { + field1887[var26] = true; + } + + var13 = (modelViewportZs[var7] + modelViewportZs[var27] + modelViewportZs[var9]) / 3 + this.radius; + field1868[var13][field1871[var13]++] = var26; + } + } + } + } + + int[] var8; + if (this.field1838 == null) + { + for (var26 = this.diameter - 1; var26 >= 0; --var26) + { + var7 = field1871[var26]; + if (var7 > 0) + { + var8 = field1868[var26]; + + for (var9 = 0; var9 < var7; ++var9) + { + this.method2706(graphics, var8[var9]); + } + } + } + + } + else + { + for (var26 = 0; var26 < 12; ++var26) + { + field1872[var26] = 0; + field1877[var26] = 0; + } + + for (var26 = this.diameter - 1; var26 >= 0; --var26) + { + var7 = field1871[var26]; + if (var7 > 0) + { + var8 = field1868[var26]; + + for (var9 = 0; var9 < var7; ++var9) + { + var10 = var8[var9]; + byte var31 = this.field1838[var10]; + var12 = field1872[var31]++; + field1874[var31][var12] = var10; + if (var31 < 10) + { + field1877[var31] += var26; + } + else if (var31 == 10) + { + field1857[var12] = var26; + } + else + { + field1863[var12] = var26; + } + } + } + } + + var26 = 0; + if (field1872[1] > 0 || field1872[2] > 0) + { + var26 = (field1877[1] + field1877[2]) / (field1872[1] + field1872[2]); + } + + var7 = 0; + if (field1872[3] > 0 || field1872[4] > 0) + { + var7 = (field1877[3] + field1877[4]) / (field1872[3] + field1872[4]); + } + + var27 = 0; + if (field1872[6] > 0 || field1872[8] > 0) + { + var27 = (field1877[8] + field1877[6]) / (field1872[8] + field1872[6]); + } + + var10 = 0; + var11 = field1872[10]; + int[] var28 = field1874[10]; + int[] var29 = field1857; + if (var10 == var11) + { + var10 = 0; + var11 = field1872[11]; + var28 = field1874[11]; + var29 = field1863; + } + + if (var10 < var11) + { + var9 = var29[var10]; + } + else + { + var9 = -1000; + } + + for (var14 = 0; var14 < 10; ++var14) + { + while (var14 == 0 && var9 > var26) + { + this.method2706(graphics, var28[var10++]); + if (var10 == var11 && var28 != field1874[11]) + { + var10 = 0; + var11 = field1872[11]; + var28 = field1874[11]; + var29 = field1863; + } + + if (var10 < var11) + { + var9 = var29[var10]; + } + else + { + var9 = -1000; + } + } + + while (var14 == 3 && var9 > var7) + { + this.method2706(graphics, var28[var10++]); + if (var10 == var11 && var28 != field1874[11]) + { + var10 = 0; + var11 = field1872[11]; + var28 = field1874[11]; + var29 = field1863; + } + + if (var10 < var11) + { + var9 = var29[var10]; + } + else + { + var9 = -1000; + } + } + + while (var14 == 5 && var9 > var27) + { + this.method2706(graphics, var28[var10++]); + if (var10 == var11 && var28 != field1874[11]) + { + var10 = 0; + var11 = field1872[11]; + var28 = field1874[11]; + var29 = field1863; + } + + if (var10 < var11) + { + var9 = var29[var10]; + } + else + { + var9 = -1000; + } + } + + var15 = field1872[var14]; + int[] var30 = field1874[var14]; + + for (var17 = 0; var17 < var15; ++var17) + { + this.method2706(graphics, var30[var17]); + } + } + + while (var9 != -1000) + { + this.method2706(graphics, var28[var10++]); + if (var10 == var11 && var28 != field1874[11]) + { + var10 = 0; + var28 = field1874[11]; + var11 = field1872[11]; + var29 = field1863; + } + + if (var10 < var11) + { + var9 = var29[var10]; + } + else + { + var9 = -1000; + } + } + + } + } + } + + private void method2706(Graphics3D graphics, int var1) + { + if (field1885[var1]) + { + this.method2707(graphics, var1); + } + else + { + int var2 = this.indices1[var1]; + int var3 = this.indices2[var1]; + int var4 = this.indices3[var1]; + graphics.rasterClipEnable = field1887[var1]; + if (this.field1882 == null) + { + graphics.rasterAlpha = 0; + } + else + { + graphics.rasterAlpha = this.field1882[var1] & 255; + } + + if (this.field1841 != null && this.field1841[var1] != -1) + { + int var5; + int var6; + int var7; + if (this.field1840 != null && this.field1840[var1] != -1) + { + int var8 = this.field1840[var1] & 255; + var5 = this.field1844[var8]; + var6 = this.field1865[var8]; + var7 = this.field1846[var8]; + } + else + { + var5 = var2; + var6 = var3; + var7 = var4; + } + + if (this.field1823[var1] == -1) + { + graphics.rasterTextureAffine(modelViewportXs[var2], modelViewportXs[var3], modelViewportXs[var4], modelViewportYs[var2], modelViewportYs[var3], modelViewportYs[var4], this.field1856[var1], this.field1856[var1], this.field1856[var1], yViewportBuffer[var5], yViewportBuffer[var6], yViewportBuffer[var7], field1839[var5], field1839[var6], field1839[var7], field1869[var5], field1869[var6], field1869[var7], this.field1841[var1]); + } + else + { + graphics.rasterTextureAffine(modelViewportXs[var2], modelViewportXs[var3], modelViewportXs[var4], modelViewportYs[var2], modelViewportYs[var3], modelViewportYs[var4], this.field1856[var1], this.field1854[var1], this.field1823[var1], yViewportBuffer[var5], yViewportBuffer[var6], yViewportBuffer[var7], field1839[var5], field1839[var6], field1839[var7], field1869[var5], field1869[var6], field1869[var7], this.field1841[var1]); + } + } + else if (this.field1823[var1] == -1) + { + int[] field1889 = graphics.colorPalette; + graphics.rasterFlat(modelViewportXs[var2], modelViewportXs[var3], modelViewportXs[var4], modelViewportYs[var2], modelViewportYs[var3], modelViewportYs[var4], field1889[this.field1856[var1]]); + } + else + { + graphics.rasterGouraud(modelViewportXs[var2], modelViewportXs[var3], modelViewportXs[var4], modelViewportYs[var2], modelViewportYs[var3], modelViewportYs[var4], this.field1856[var1], this.field1854[var1], this.field1823[var1]); + } + + } + } + + + private void method2707(Graphics3D graphics, int var1) + { + int var2 = graphics.centerX; + int var3 = graphics.centerY; + int var4 = 0; + int var5 = this.indices1[var1]; + int var6 = this.indices2[var1]; + int var7 = this.indices3[var1]; + int var8 = field1869[var5]; + int var9 = field1869[var6]; + int var10 = field1869[var7]; + if (this.field1882 == null) + { + graphics.rasterAlpha = 0; + } + else + { + graphics.rasterAlpha = this.field1882[var1] & 255; + } + + int var11; + int var12; + int var13; + int var14; + if (var8 >= 50) + { + field1831[var4] = modelViewportYs[var5]; + field1837[var4] = modelViewportXs[var5]; + xViewportBuffer[var4++] = this.field1856[var1]; + } + else + { + var11 = yViewportBuffer[var5]; + var12 = field1839[var5]; + var13 = this.field1856[var1]; + if (var10 >= 50) + { + var14 = field1890[var10 - var8] * (50 - var8); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var7] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var7] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1823[var1] - var13) * var14 >> 16); + } + + if (var9 >= 50) + { + var14 = field1890[var9 - var8] * (50 - var8); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var6] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var6] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1854[var1] - var13) * var14 >> 16); + } + } + + if (var9 >= 50) + { + field1831[var4] = modelViewportYs[var6]; + field1837[var4] = modelViewportXs[var6]; + xViewportBuffer[var4++] = this.field1854[var1]; + } + else + { + var11 = yViewportBuffer[var6]; + var12 = field1839[var6]; + var13 = this.field1854[var1]; + if (var8 >= 50) + { + var14 = field1890[var8 - var9] * (50 - var9); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var5] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var5] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1856[var1] - var13) * var14 >> 16); + } + + if (var10 >= 50) + { + var14 = field1890[var10 - var9] * (50 - var9); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var7] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var7] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1823[var1] - var13) * var14 >> 16); + } + } + + if (var10 >= 50) + { + field1831[var4] = modelViewportYs[var7]; + field1837[var4] = modelViewportXs[var7]; + xViewportBuffer[var4++] = this.field1823[var1]; + } + else + { + var11 = yViewportBuffer[var7]; + var12 = field1839[var7]; + var13 = this.field1823[var1]; + if (var9 >= 50) + { + var14 = field1890[var9 - var10] * (50 - var10); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var6] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var6] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1854[var1] - var13) * var14 >> 16); + } + + if (var8 >= 50) + { + var14 = field1890[var8 - var10] * (50 - var10); + field1831[var4] = var2 + graphics.Rasterizer3D_zoom * (var11 + ((yViewportBuffer[var5] - var11) * var14 >> 16)) / 50; + field1837[var4] = var3 + graphics.Rasterizer3D_zoom * (var12 + ((field1839[var5] - var12) * var14 >> 16)) / 50; + xViewportBuffer[var4++] = var13 + ((this.field1856[var1] - var13) * var14 >> 16); + } + } + + var11 = field1831[0]; + var12 = field1831[1]; + var13 = field1831[2]; + var14 = field1837[0]; + int var15 = field1837[1]; + int var16 = field1837[2]; + graphics.rasterClipEnable = false; + int var17; + int var18; + int var19; + int var20; + if (var4 == 3) + { + if (var11 < 0 || var12 < 0 || var13 < 0 || var11 > graphics.rasterClipX || var12 > graphics.rasterClipX || var13 > graphics.rasterClipX) + { + graphics.rasterClipEnable = true; + } + + if (this.field1841 != null && this.field1841[var1] != -1) + { + if (this.field1840 != null && this.field1840[var1] != -1) + { + var20 = this.field1840[var1] & 255; + var17 = this.field1844[var20]; + var18 = this.field1865[var20]; + var19 = this.field1846[var20]; + } + else + { + var17 = var5; + var18 = var6; + var19 = var7; + } + + if (this.field1823[var1] == -1) + { + graphics.rasterTextureAffine(var14, var15, var16, var11, var12, var13, this.field1856[var1], this.field1856[var1], this.field1856[var1], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], this.field1841[var1]); + } + else + { + graphics.rasterTextureAffine(var14, var15, var16, var11, var12, var13, xViewportBuffer[0], xViewportBuffer[1], xViewportBuffer[2], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], this.field1841[var1]); + } + } + else if (this.field1823[var1] == -1) + { + int[] field1889 = graphics.colorPalette; + graphics.rasterFlat(var14, var15, var16, var11, var12, var13, field1889[this.field1856[var1]]); + } + else + { + graphics.rasterGouraud(var14, var15, var16, var11, var12, var13, xViewportBuffer[0], xViewportBuffer[1], xViewportBuffer[2]); + } + } + + if (var4 == 4) + { + if (var11 < 0 || var12 < 0 || var13 < 0 || var11 > graphics.rasterClipX || var12 > graphics.rasterClipX || var13 > graphics.rasterClipX || field1831[3] < 0 || field1831[3] > graphics.rasterClipX) + { + graphics.rasterClipEnable = true; + } + + if (this.field1841 != null && this.field1841[var1] != -1) + { + if (this.field1840 != null && this.field1840[var1] != -1) + { + var20 = this.field1840[var1] & 255; + var17 = this.field1844[var20]; + var18 = this.field1865[var20]; + var19 = this.field1846[var20]; + } + else + { + var17 = var5; + var18 = var6; + var19 = var7; + } + + short var21 = this.field1841[var1]; + if (this.field1823[var1] == -1) + { + graphics.rasterTextureAffine(var14, var15, var16, var11, var12, var13, this.field1856[var1], this.field1856[var1], this.field1856[var1], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], var21); + graphics.rasterTextureAffine(var14, var16, field1837[3], var11, var13, field1831[3], this.field1856[var1], this.field1856[var1], this.field1856[var1], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], var21); + } + else + { + graphics.rasterTextureAffine(var14, var15, var16, var11, var12, var13, xViewportBuffer[0], xViewportBuffer[1], xViewportBuffer[2], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], var21); + graphics.rasterTextureAffine(var14, var16, field1837[3], var11, var13, field1831[3], xViewportBuffer[0], xViewportBuffer[2], xViewportBuffer[3], yViewportBuffer[var17], yViewportBuffer[var18], yViewportBuffer[var19], field1839[var17], field1839[var18], field1839[var19], field1869[var17], field1869[var18], field1869[var19], var21); + } + } + else if (this.field1823[var1] == -1) + { + int[] field1889 = graphics.colorPalette; + var17 = field1889[this.field1856[var1]]; + graphics.rasterFlat(var14, var15, var16, var11, var12, var13, var17); + graphics.rasterFlat(var14, var16, field1837[3], var11, var13, field1831[3], var17); + } + else + { + graphics.rasterGouraud(var14, var15, var16, var11, var12, var13, xViewportBuffer[0], xViewportBuffer[1], xViewportBuffer[2]); + graphics.rasterGouraud(var14, var16, field1837[3], var11, var13, field1831[3], xViewportBuffer[0], xViewportBuffer[2], xViewportBuffer[3]); + } + } + + } +} \ No newline at end of file diff --git a/cache/src/main/java/net/runelite/cache/item/RSTextureProvider.java b/cache/src/main/java/net/runelite/cache/item/RSTextureProvider.java new file mode 100644 index 0000000000..90296dfa70 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/RSTextureProvider.java @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +import net.runelite.cache.definitions.TextureDefinition; +import net.runelite.cache.definitions.providers.SpriteProvider; +import net.runelite.cache.definitions.providers.TextureProvider; + +class RSTextureProvider +{ + private final SpriteProvider spriteProvider; + TextureDefinition[] textures; + int maxSize; + int size; + double brightness; + int width; + + public RSTextureProvider(TextureProvider textureProvider, SpriteProvider spriteProvider) + { + this.spriteProvider = spriteProvider; + this.size = 0; + this.brightness = 1.0D; + this.width = 128; + this.maxSize = 20; + this.size = this.maxSize; + this.brightness = 0.8D; + this.width = 128; + + int max = -1; + for (TextureDefinition textureDefinition : textureProvider.provide()) + { + if (textureDefinition.getId() > max) + { + max = textureDefinition.getId(); + } + } + + textures = new TextureDefinition[max + 1]; + for (TextureDefinition textureDefinition : textureProvider.provide()) + { + textures[textureDefinition.getId()] = textureDefinition; + } + } + + public int[] load(int var1) + { + TextureDefinition var2 = this.textures[var1]; + if (var2 != null) + { + if (var2.pixels != null) + { + return var2.pixels; + } + + boolean var3 = var2.method2680(this.brightness, this.width, spriteProvider); + return var2.pixels; + } + + return null; + } + + + public int getAverageTextureRGB(int var1) + { + return this.textures[var1] != null ? this.textures[var1].field1777 : 0; + } + + + public boolean vmethod3057(int var1) + { + return this.textures[var1].field1778; + } + + + public boolean vmethod3066(int var1) + { + return this.width == 64; + } +} diff --git a/cache/src/main/java/net/runelite/cache/item/Rasterizer2D.java b/cache/src/main/java/net/runelite/cache/item/Rasterizer2D.java new file mode 100644 index 0000000000..b3d03fdd61 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/Rasterizer2D.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +class Rasterizer2D +{ + public int[] graphicsPixels; + public int graphicsPixelsWidth; + public int graphicsPixelsHeight; + public int drawingAreaTop; + public int drawingAreaBottom; + public int draw_region_x; + protected int drawingAreaRight; + + public void setRasterBuffer(int[] var0, int var1, int var2) + { + graphicsPixels = var0; + graphicsPixelsWidth = var1; + graphicsPixelsHeight = var2; + setDrawRegion(0, 0, var1, var2); + } + + public void setDrawRegion(int var0, int var1, int var2, int var3) + { + if (var0 < 0) + { + var0 = 0; + } + + if (var1 < 0) + { + var1 = 0; + } + + if (var2 > graphicsPixelsWidth) + { + var2 = graphicsPixelsWidth; + } + + if (var3 > graphicsPixelsHeight) + { + var3 = graphicsPixelsHeight; + } + + draw_region_x = var0; + drawingAreaTop = var1; + drawingAreaRight = var2; + drawingAreaBottom = var3; + } + + public void reset() + { + int var0 = 0; + + int var1; + for (var1 = graphicsPixelsWidth * graphicsPixelsHeight - 7; var0 < var1; graphicsPixels[var0++] = 0) + { + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + graphicsPixels[var0++] = 0; + } + + for (var1 += 7; var0 < var1; graphicsPixels[var0++] = 0) + { + ; + } + + } + +} \ No newline at end of file diff --git a/cache/src/main/java/net/runelite/cache/item/Renderable.java b/cache/src/main/java/net/runelite/cache/item/Renderable.java new file mode 100644 index 0000000000..e1ef1b427a --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/Renderable.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +abstract class Renderable +{ + public int modelHeight; + + protected Renderable() + { + this.modelHeight = 1000; + } +} diff --git a/cache/src/main/java/net/runelite/cache/item/SpritePixels.java b/cache/src/main/java/net/runelite/cache/item/SpritePixels.java new file mode 100644 index 0000000000..02079847f7 --- /dev/null +++ b/cache/src/main/java/net/runelite/cache/item/SpritePixels.java @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +import java.awt.image.BufferedImage; + +class SpritePixels +{ + public int[] pixels; + public int width; + public int height; + public int offsetX; + int offsetY; + + public SpritePixels(int[] var1, int var2, int var3) + { + this.pixels = var1; + this.width = var2; + this.height = var3; + this.offsetY = 0; + this.offsetX = 0; + } + + public SpritePixels(int var1, int var2) + { + this(new int[var2 * var1], var1, var2); + } + + public void drawBorder(int color) + { + int[] newPixels = new int[this.width * this.height]; + int pixelIndex = 0; + + for (int y = 0; y < this.height; ++y) + { + for (int x = 0; x < this.width; ++x) + { + int pixel = this.pixels[pixelIndex]; + if (pixel == 0) + { + // W + if (x > 0 && this.pixels[pixelIndex - 1] != 0) + { + pixel = color; + } + // N + else if (y > 0 && this.pixels[pixelIndex - this.width] != 0) + { + pixel = color; + } + // E + else if (x < this.width - 1 && this.pixels[pixelIndex + 1] != 0) + { + pixel = color; + } + // S + else if (y < this.height - 1 && this.pixels[pixelIndex + this.width] != 0) + { + pixel = color; + } + } + + newPixels[pixelIndex++] = pixel; + } + } + + this.pixels = newPixels; + } + + + public void drawShadow(int color) + { + for (int y = this.height - 1; y > 0; --y) + { + int rowOffset = y * this.width; + + for (int x = this.width - 1; x > 0; --x) + { + // if *this* pixel is black/unset AND the pixel to the NW isn't black/unset + if (this.pixels[x + rowOffset] == 0 && this.pixels[x + rowOffset - 1 - this.width] != 0) + { + this.pixels[x + rowOffset] = color; + } + } + } + + } + + public void drawAtOn(Rasterizer2D graphics, int x, int y) + { + x += this.offsetX; + y += this.offsetY; + int pixelIndex = x + y * graphics.graphicsPixelsWidth; + int deltaIndex = 0; + int height = this.height; + int width = this.width; + int var7 = graphics.graphicsPixelsWidth - width; + int var8 = 0; + if (y < graphics.drawingAreaTop) + { + int deltaY = graphics.drawingAreaTop - y; + height -= deltaY; + y = graphics.drawingAreaTop; + deltaIndex += deltaY * width; + pixelIndex += deltaY * graphics.graphicsPixelsWidth; + } + + if (height + y > graphics.drawingAreaBottom) + { + height -= height + y - graphics.drawingAreaBottom; + } + + if (x < graphics.draw_region_x) + { + int deltaX = graphics.draw_region_x - x; + width -= deltaX; + x = graphics.draw_region_x; + deltaIndex += deltaX; + pixelIndex += deltaX; + var8 += deltaX; + var7 += deltaX; + } + + if (width + x > graphics.drawingAreaRight) + { + int deltaX = width + x - graphics.drawingAreaRight; + width -= deltaX; + var8 += deltaX; + var7 += deltaX; + } + + if (width > 0 && height > 0) + { + method5843(graphics.graphicsPixels, this.pixels, 0, deltaIndex, pixelIndex, width, height, var7, var8); + } + } + + static void method5843(int[] rasterizerPixels, int[] spritePixels, int var2, int var3, int pixelIndex, int width, int height, int var7, int var8) + { + int var9 = -(width >> 2); + width = -(width & 3); + + for (int var10 = -height; var10 < 0; ++var10) + { + for (int i = var9 * 4; i < 0; ++i) + { + var2 = spritePixels[var3++]; + if (var2 != 0) + { + rasterizerPixels[pixelIndex++] = var2; + } + else + { + ++pixelIndex; + } + } + + for (int i = width; i < 0; ++i) + { + var2 = spritePixels[var3++]; + if (var2 != 0) + { + rasterizerPixels[pixelIndex++] = var2; + } + else + { + ++pixelIndex; + } + } + + pixelIndex += var7; + var3 += var8; + } + + } + + public BufferedImage toBufferedImage() + { + int[] transPixels = new int[pixels.length]; + BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB); + + for (int i = 0; i < pixels.length; i++) + { + if (pixels[i] != 0) + { + transPixels[i] = pixels[i] | 0xff000000; + } + } + + img.setRGB(0, 0, width, height, transPixels, 0, width); + return img; + } + +} diff --git a/cache/src/test/java/net/runelite/cache/item/ItemSpriteFactoryTest.java b/cache/src/test/java/net/runelite/cache/item/ItemSpriteFactoryTest.java new file mode 100644 index 0000000000..30fb140a1b --- /dev/null +++ b/cache/src/test/java/net/runelite/cache/item/ItemSpriteFactoryTest.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2018, Adam + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package net.runelite.cache.item; + +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import javax.imageio.ImageIO; +import lombok.extern.slf4j.Slf4j; +import net.runelite.cache.IndexType; +import net.runelite.cache.ItemManager; +import net.runelite.cache.SpriteManager; +import net.runelite.cache.StoreLocation; +import net.runelite.cache.TextureManager; +import net.runelite.cache.definitions.ItemDefinition; +import net.runelite.cache.definitions.ModelDefinition; +import net.runelite.cache.definitions.loaders.ModelLoader; +import net.runelite.cache.definitions.providers.ModelProvider; +import net.runelite.cache.fs.Archive; +import net.runelite.cache.fs.Index; +import net.runelite.cache.fs.Store; +import org.junit.Ignore; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; + +@Slf4j +public class ItemSpriteFactoryTest +{ + @Rule + public TemporaryFolder folder = StoreLocation.getTemporaryFolder(); + + @Test + @Ignore + public void test() throws IOException + { + File base = StoreLocation.LOCATION, + outDir = folder.newFolder(); + + int count = 0; + + try (Store store = new Store(base)) + { + store.load(); + + ItemManager itemManager = new ItemManager(store); + itemManager.load(); + + ModelProvider modelProvider = new ModelProvider() + { + @Override + public ModelDefinition provide(int modelId) throws IOException + { + Index models = store.getIndex(IndexType.MODELS); + Archive archive = models.getArchive(modelId); + + byte[] data = archive.decompress(store.getStorage().loadArchive(archive)); + ModelDefinition inventoryModel = new ModelLoader().load(modelId, data); + return inventoryModel; + } + }; + + SpriteManager spriteManager = new SpriteManager(store); + spriteManager.load(); + + TextureManager textureManager = new TextureManager(store); + textureManager.load(); + + for (ItemDefinition itemDef : itemManager.getItems()) + { + if (itemDef.name == null || itemDef.name.equalsIgnoreCase("null")) + { + continue; + } + + try + { + BufferedImage sprite = ItemSpriteFactory.createSprite(itemManager, modelProvider, spriteManager, textureManager, + itemDef.id, 1, 1, 3153952, false); + + File out = new File(outDir, itemDef.id + ".png"); + BufferedImage img = sprite; + ImageIO.write(img, "PNG", out); + + ++count; + } + catch (Exception ex) + { + log.warn("error dumping item {}", itemDef.id, ex); + } + } + } + + log.info("Dumped {} item images to {}", count, outDir); + } +} \ No newline at end of file