Thread: Fog Filter

Page 1 of 2 12 LastLast
Results 1 to 10 of 17
  1. #1 Fog Filter 
    Rune-Server Affiliate

    Join Date
    Apr 2014
    Posts
    1,761
    Thanks given
    75
    Thanks received
    714
    Rep Power
    1073
    Applying a fog effect to your world background.
    Attached image


    Rasterizer class:
    Code:
    public static int applyFilter(int rgb, float ratio) {
            int start = 2000;
            int end = 3000;
            int fogRGB = 0xC8C0A8;
            return blend(rgb, fogRGB, (ratio - start) / (end - start));
        }
    
        private static int blend(int c1, int c2, float ratio) {
            if (ratio < 0f) {
                return c1;
            }
            if (ratio > 1f) {
                return c2;
            }
    
            int r1 = (c1 >> 16) & 0xff;
            int g1 = (c1 >> 8) & 0xff;
            int b1 = (c1 & 0xff);
    
            int r2 = (c2 >> 16) & 0xff;
            int g2 = (c2 >> 8) & 0xff;
            int b2 = (c2 & 0xff);
    
            int r3 = r2 - r1;
            int g3 = g2 - g1;
            int b3 = b2 - b1;
    
            int r = (int)(r1 + (r3 * ratio));
            int g = (int)(g1 + (g3 * ratio));
            int b = (int)(b1 + (b3 * ratio));
    
            return (r << 16) + (g << 8) + b;
        }
    Rasterizer drawing method example
    Code:
    public static void drawGouraudTriangle(int y1, int y2, int y3, int x1, int x2, int x3, int hsl1, int hsl2, int hsl3, float z1, float z2, float z3) {
            int rgb1 = anIntArray1482[hsl1];
            int rgb2 = anIntArray1482[hsl2];
            int rgb3 = anIntArray1482[hsl3];
            int r1 = rgb1 >> 16 & 0xff;
            int g1 = rgb1 >> 8 & 0xff;
            int b1 = rgb1 & 0xff;
            int r2 = rgb2 >> 16 & 0xff;
            int g2 = rgb2 >> 8 & 0xff;
            int b2 = rgb2 & 0xff;
            int r3 = rgb3 >> 16 & 0xff;
            int g3 = rgb3 >> 8 & 0xff;
            int b3 = rgb3 & 0xff;
            int dx1 = 0;
            int dr1 = 0;
            int dg1 = 0;
            int db1 = 0;
            if (y2 != y1) {
                dx1 = (x2 - x1 << 16) / (y2 - y1);
                dr1 = (r2 - r1 << 16) / (y2 - y1);
                dg1 = (g2 - g1 << 16) / (y2 - y1);
                db1 = (b2 - b1 << 16) / (y2 - y1);
            }
            int dx2 = 0;
            int dr2 = 0;
            int dg2 = 0;
            int db2 = 0;
            if (y3 != y2) {
                dx2 = (x3 - x2 << 16) / (y3 - y2);
                dr2 = (r3 - r2 << 16) / (y3 - y2);
                dg2 = (g3 - g2 << 16) / (y3 - y2);
                db2 = (b3 - b2 << 16) / (y3 - y2);
            }
            int dx3 = 0;
            int dr3 = 0;
            int dg3 = 0;
            int db3 = 0;
            if (y3 != y1) {
                dx3 = (x1 - x3 << 16) / (y1 - y3);
                dr3 = (r1 - r3 << 16) / (y1 - y3);
                dg3 = (g1 - g3 << 16) / (y1 - y3);
                db3 = (b1 - b3 << 16) / (y1 - y3);
            }
    
            float x21 = x2 - x1;
            float y21 = y2 - y1;
            float x31 = x3 - x1;
            float y31 = y3 - y1;
            float z21 = z2 - z1;
            float z31 = z3 - z1;
    
            float div = x21 * y31 - x31 * y21;
            float depthSlope = (z21 * y31 - z31 * y21) / div;
            float depthScale = (z31 * x21 - z21 * x31) / div;
    
            if (y1 <= y2 && y1 <= y3) {
                if (y1 >= bottomY) {
                    return;
                }
                if (y2 > bottomY) {
                    y2 = bottomY;
                }
                if (y3 > bottomY) {
                    y3 = bottomY;
                }
                z1 = z1 - depthSlope * x1 + depthSlope;
                if (y2 < y3) {
                    x3 = x1 <<= 16;
                    r3 = r1 <<= 16;
                    g3 = g1 <<= 16;
                    b3 = b1 <<= 16;
                    if (y1 < 0) {
                        x3 -= dx3 * y1;
                        x1 -= dx1 * y1;
                        r3 -= dr3 * y1;
                        g3 -= dg3 * y1;
                        b3 -= db3 * y1;
                        r1 -= dr1 * y1;
                        g1 -= dg1 * y1;
                        b1 -= db1 * y1;
                        z1 -= depthScale * y1;
                        y1 = 0;
                    }
                    x2 <<= 16;
                    r2 <<= 16;
                    g2 <<= 16;
                    b2 <<= 16;
                    if (y2 < 0) {
                        x2 -= dx2 * y2;
                        r2 -= dr2 * y2;
                        g2 -= dg2 * y2;
                        b2 -= db2 * y2;
                        y2 = 0;
                    }
                    if (y1 != y2 && dx3 < dx1 || y1 == y2 && dx3 > dx2) {
                        y3 -= y2;
                        y2 -= y1;
                        for (y1 = anIntArray1472[y1]; --y2 >= 0; y1 += width) {
                            drawGouraudScanline(pixels, y1, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1, z1, depthSlope);
                            x3 += dx3;
                            x1 += dx1;
                            r3 += dr3;
                            g3 += dg3;
                            b3 += db3;
                            r1 += dr1;
                            g1 += dg1;
                            b1 += db1;
                            z1 += depthScale;
                        }
                        while (--y3 >= 0) {
                            drawGouraudScanline(pixels, y1, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2, z1, depthSlope);
                            x3 += dx3;
                            x2 += dx2;
                            r3 += dr3;
                            g3 += dg3;
                            b3 += db3;
                            r2 += dr2;
                            g2 += dg2;
                            b2 += db2;
                            y1 += width;
                            z1 += depthScale;
                        }
                        return;
                    }
                    y3 -= y2;
                    y2 -= y1;
                    for (y1 = anIntArray1472[y1]; --y2 >= 0; y1 += width) {
                        drawGouraudScanline(pixels, y1, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3, z1, depthSlope);
                        x3 += dx3;
                        x1 += dx1;
                        r3 += dr3;
                        g3 += dg3;
                        b3 += db3;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        z1 += depthScale;
                    }
                    while (--y3 >= 0) {
                        drawGouraudScanline(pixels, y1, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3, z1, depthSlope);
                        x3 += dx3;
                        x2 += dx2;
                        r3 += dr3;
                        g3 += dg3;
                        b3 += db3;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        y1 += width;
                        z1 += depthScale;
                    }
                    return;
                }
                x2 = x1 <<= 16;
                r2 = r1 <<= 16;
                g2 = g1 <<= 16;
                b2 = b1 <<= 16;
                if (y1 < 0) {
                    x2 -= dx3 * y1;
                    x1 -= dx1 * y1;
                    r2 -= dr3 * y1;
                    g2 -= dg3 * y1;
                    b2 -= db3 * y1;
                    r1 -= dr1 * y1;
                    g1 -= dg1 * y1;
                    b1 -= db1 * y1;
                    z1 -= depthScale * y1;
                    y1 = 0;
                }
                x3 <<= 16;
                r3 <<= 16;
                g3 <<= 16;
                b3 <<= 16;
                if (y3 < 0) {
                    x3 -= dx2 * y3;
                    r3 -= dr2 * y3;
                    g3 -= dg2 * y3;
                    b3 -= db2 * y3;
                    y3 = 0;
                }
                if (y1 != y3 && dx3 < dx1 || y1 == y3 && dx2 > dx1) {
                    y2 -= y3;
                    y3 -= y1;
                    for (y1 = anIntArray1472[y1]; --y3 >= 0; y1 += width) {
                        drawGouraudScanline(pixels, y1, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1, z1, depthSlope);
                        x2 += dx3;
                        x1 += dx1;
                        r2 += dr3;
                        g2 += dg3;
                        b2 += db3;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        z1 += depthScale;
                    }
                    while (--y2 >= 0) {
                        drawGouraudScanline(pixels, y1, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1, z1, depthSlope);
                        x3 += dx2;
                        x1 += dx1;
                        r3 += dr2;
                        g3 += dg2;
                        b3 += db2;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        y1 += width;
                        z1 += depthScale;
                    }
                    return;
                }
                y2 -= y3;
                y3 -= y1;
                for (y1 = anIntArray1472[y1]; --y3 >= 0; y1 += width) {
                    drawGouraudScanline(pixels, y1, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2, z1, depthSlope);
                    x2 += dx3;
                    x1 += dx1;
                    r2 += dr3;
                    g2 += dg3;
                    b2 += db3;
                    r1 += dr1;
                    g1 += dg1;
                    b1 += db1;
                    z1 += depthScale;
                }
                while (--y2 >= 0) {
                    drawGouraudScanline(pixels, y1, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3, z1, depthSlope);
                    x3 += dx2;
                    x1 += dx1;
                    r3 += dr2;
                    g3 += dg2;
                    b3 += db2;
                    r1 += dr1;
                    g1 += dg1;
                    b1 += db1;
                    y1 += width;
                    z1 += depthScale;
                }
                return;
            }
            if (y2 <= y3) {
                if (y2 >= bottomY) {
                    return;
                }
                if (y3 > bottomY) {
                    y3 = bottomY;
                }
                if (y1 > bottomY) {
                    y1 = bottomY;
                }
                z2 = z2 - depthSlope * x2 + depthSlope;
                if (y3 < y1) {
                    x1 = x2 <<= 16;
                    r1 = r2 <<= 16;
                    g1 = g2 <<= 16;
                    b1 = b2 <<= 16;
                    if (y2 < 0) {
                        x1 -= dx1 * y2;
                        x2 -= dx2 * y2;
                        r1 -= dr1 * y2;
                        g1 -= dg1 * y2;
                        b1 -= db1 * y2;
                        r2 -= dr2 * y2;
                        g2 -= dg2 * y2;
                        b2 -= db2 * y2;
                        z2 -= depthScale * y2;
                        y2 = 0;
                    }
                    x3 <<= 16;
                    r3 <<= 16;
                    g3 <<= 16;
                    b3 <<= 16;
                    if (y3 < 0) {
                        x3 -= dx3 * y3;
                        r3 -= dr3 * y3;
                        g3 -= dg3 * y3;
                        b3 -= db3 * y3;
                        y3 = 0;
                    }
                    if (y2 != y3 && dx1 < dx2 || y2 == y3 && dx1 > dx3) {
                        y1 -= y3;
                        y3 -= y2;
                        for (y2 = anIntArray1472[y2]; --y3 >= 0; y2 += width) {
                            drawGouraudScanline(pixels, y2, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2, z2, depthSlope);
                            x1 += dx1;
                            x2 += dx2;
                            r1 += dr1;
                            g1 += dg1;
                            b1 += db1;
                            r2 += dr2;
                            g2 += dg2;
                            b2 += db2;
                            z2 += depthScale;
                        }
                        while (--y1 >= 0) {
                            drawGouraudScanline(pixels, y2, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3, z2, depthSlope);
                            x1 += dx1;
                            x3 += dx3;
                            r1 += dr1;
                            g1 += dg1;
                            b1 += db1;
                            r3 += dr3;
                            g3 += dg3;
                            b3 += db3;
                            y2 += width;
                            z2 += depthScale;
                        }
                        return;
                    }
                    y1 -= y3;
                    y3 -= y2;
                    for (y2 = anIntArray1472[y2]; --y3 >= 0; y2 += width) {
                        drawGouraudScanline(pixels, y2, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1, z2, depthSlope);
                        x1 += dx1;
                        x2 += dx2;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        z2 += depthScale;
                    }
                    while (--y1 >= 0) {
                        drawGouraudScanline(pixels, y2, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1, z2, depthSlope);
                        x1 += dx1;
                        x3 += dx3;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        r3 += dr3;
                        g3 += dg3;
                        b3 += db3;
                        y2 += width;
                        z2 += depthScale;
                    }
                    return;
                }
                x3 = x2 <<= 16;
                r3 = r2 <<= 16;
                g3 = g2 <<= 16;
                b3 = b2 <<= 16;
                if (y2 < 0) {
                    x3 -= dx1 * y2;
                    x2 -= dx2 * y2;
                    r3 -= dr1 * y2;
                    g3 -= dg1 * y2;
                    b3 -= db1 * y2;
                    r2 -= dr2 * y2;
                    g2 -= dg2 * y2;
                    b2 -= db2 * y2;
                    z2 -= depthScale * y2;
                    y2 = 0;
                }
                x1 <<= 16;
                r1 <<= 16;
                g1 <<= 16;
                b1 <<= 16;
                if (y1 < 0) {
                    x1 -= dx3 * y1;
                    r1 -= dr3 * y1;
                    g1 -= dg3 * y1;
                    b1 -= db3 * y1;
                    y1 = 0;
                }
                if (dx1 < dx2) {
                    y3 -= y1;
                    y1 -= y2;
                    for (y2 = anIntArray1472[y2]; --y1 >= 0; y2 += width) {
                        drawGouraudScanline(pixels, y2, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2, z2, depthSlope);
                        x3 += dx1;
                        x2 += dx2;
                        r3 += dr1;
                        g3 += dg1;
                        b3 += db1;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        z2 += depthScale;
                    }
                    while (--y3 >= 0) {
                        drawGouraudScanline(pixels, y2, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2, z2, depthSlope);
                        x1 += dx3;
                        x2 += dx2;
                        r1 += dr3;
                        g1 += dg3;
                        b1 += db3;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        y2 += width;
                        z2 += depthScale;
                    }
                    return;
                }
                y3 -= y1;
                y1 -= y2;
                for (y2 = anIntArray1472[y2]; --y1 >= 0; y2 += width) {
                    drawGouraudScanline(pixels, y2, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3, z2, depthSlope);
                    x3 += dx1;
                    x2 += dx2;
                    r3 += dr1;
                    g3 += dg1;
                    b3 += db1;
                    r2 += dr2;
                    g2 += dg2;
                    b2 += db2;
                    z2 += depthScale;
                }
                while (--y3 >= 0) {
                    drawGouraudScanline(pixels, y2, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1, z2, depthSlope);
                    x1 += dx3;
                    x2 += dx2;
                    r1 += dr3;
                    g1 += dg3;
                    b1 += db3;
                    r2 += dr2;
                    g2 += dg2;
                    b2 += db2;
                    y2 += width;
                    z2 += depthScale;
                }
                return;
            }
            if (y3 >= bottomY) {
                return;
            }
            if (y1 > bottomY) {
                y1 = bottomY;
            }
            if (y2 > bottomY) {
                y2 = bottomY;
            }
            z3 = z3 - depthSlope * x3 + depthSlope;
            if (y1 < y2) {
                x2 = x3 <<= 16;
                r2 = r3 <<= 16;
                g2 = g3 <<= 16;
                b2 = b3 <<= 16;
                if (y3 < 0) {
                    x2 -= dx2 * y3;
                    x3 -= dx3 * y3;
                    r2 -= dr2 * y3;
                    g2 -= dg2 * y3;
                    b2 -= db2 * y3;
                    r3 -= dr3 * y3;
                    g3 -= dg3 * y3;
                    b3 -= db3 * y3;
                    z3 -= depthScale * y3;
                    y3 = 0;
                }
                x1 <<= 16;
                r1 <<= 16;
                g1 <<= 16;
                b1 <<= 16;
                if (y1 < 0) {
                    x1 -= dx1 * y1;
                    r1 -= dr1 * y1;
                    g1 -= dg1 * y1;
                    b1 -= db1 * y1;
                    y1 = 0;
                }
                if (dx2 < dx3) {
                    y2 -= y1;
                    y1 -= y3;
                    for (y3 = anIntArray1472[y3]; --y1 >= 0; y3 += width) {
                        drawGouraudScanline(pixels, y3, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3, z3, depthSlope);
                        x2 += dx2;
                        x3 += dx3;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        r3 += dr3;
                        g3 += dg3;
                        b3 += db3;
                        z3 += depthScale;
                    }
                    while (--y2 >= 0) {
                        drawGouraudScanline(pixels, y3, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1, z3, depthSlope);
                        x2 += dx2;
                        x1 += dx1;
                        r2 += dr2;
                        g2 += dg2;
                        b2 += db2;
                        r1 += dr1;
                        g1 += dg1;
                        b1 += db1;
                        y3 += width;
                        z3 += depthScale;
                    }
                    return;
                }
                y2 -= y1;
                y1 -= y3;
                for (y3 = anIntArray1472[y3]; --y1 >= 0; y3 += width) {
                    drawGouraudScanline(pixels, y3, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2, z3, depthSlope);
                    x2 += dx2;
                    x3 += dx3;
                    r2 += dr2;
                    g2 += dg2;
                    b2 += db2;
                    r3 += dr3;
                    g3 += dg3;
                    b3 += db3;
                    z3 += depthScale;
                }
                while (--y2 >= 0) {
                    drawGouraudScanline(pixels, y3, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2, z3, depthSlope);
                    x2 += dx2;
                    x1 += dx1;
                    r2 += dr2;
                    g2 += dg2;
                    b2 += db2;
                    r1 += dr1;
                    g1 += dg1;
                    b1 += db1;
                    z3 += depthScale;
                    y3 += width;
                }
                return;
            }
            x1 = x3 <<= 16;
            r1 = r3 <<= 16;
            g1 = g3 <<= 16;
            b1 = b3 <<= 16;
            if (y3 < 0) {
                x1 -= dx2 * y3;
                x3 -= dx3 * y3;
                r1 -= dr2 * y3;
                g1 -= dg2 * y3;
                b1 -= db2 * y3;
                r3 -= dr3 * y3;
                g3 -= dg3 * y3;
                b3 -= db3 * y3;
                z3 -= depthScale * y3;
                y3 = 0;
            }
            x2 <<= 16;
            r2 <<= 16;
            g2 <<= 16;
            b2 <<= 16;
            if (y2 < 0) {
                x2 -= dx1 * y2;
                r2 -= dr1 * y2;
                g2 -= dg1 * y2;
                b2 -= db1 * y2;
                y2 = 0;
            }
            if (dx2 < dx3) {
                y1 -= y2;
                y2 -= y3;
                for (y3 = anIntArray1472[y3]; --y2 >= 0; y3 += width) {
                    drawGouraudScanline(pixels, y3, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3, z3, depthSlope);
                    x1 += dx2;
                    x3 += dx3;
                    r1 += dr2;
                    g1 += dg2;
                    b1 += db2;
                    r3 += dr3;
                    g3 += dg3;
                    b3 += db3;
                    z3 += depthScale;
                }
                while (--y1 >= 0) {
                    drawGouraudScanline(pixels, y3, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3, z3, depthSlope);
                    x2 += dx1;
                    x3 += dx3;
                    r2 += dr1;
                    g2 += dg1;
                    b2 += db1;
                    r3 += dr3;
                    g3 += dg3;
                    b3 += db3;
                    z3 += depthScale;
                    y3 += width;
                }
                return;
            }
            y1 -= y2;
            y2 -= y3;
            for (y3 = anIntArray1472[y3]; --y2 >= 0; y3 += width) {
                drawGouraudScanline(pixels, y3, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1, z3, depthSlope);
                x1 += dx2;
                x3 += dx3;
                r1 += dr2;
                g1 += dg2;
                b1 += db2;
                r3 += dr3;
                g3 += dg3;
                b3 += db3;
                z3 += depthScale;
            }
            while (--y1 >= 0) {
                drawGouraudScanline(pixels, y3, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2, z3, depthSlope);
                x2 += dx1;
                x3 += dx3;
                r2 += dr1;
                g2 += dg1;
                b2 += db1;
                r3 += dr3;
                g3 += dg3;
                b3 += db3;
                y3 += width;
                z3 += depthScale;
            }
        }
    
        public static void drawGouraudScanline(int[] dest, int offset, int x1, int x2, int r1, int g1, int b1, int r2, int g2, int b2, float z1, float z2) {
            int n = x2 - x1;
            if (n <= 0) {
                return;
            }
            r2 = (r2 - r1) / n;
            g2 = (g2 - g1) / n;
            b2 = (b2 - b1) / n;
            if (aBoolean1462) {
                if (x2 > centerX) {
                    n -= x2 - centerX;
                    x2 = centerX;
                }
                if (x1 < 0) {
                    n = x2;
                    r1 -= x1 * r2;
                    g1 -= x1 * g2;
                    b1 -= x1 * b2;
                    x1 = 0;
                }
            }
            if (x1 < x2) {
                offset += x1;
                z1 += z2 * x1;
                if (anInt1465 == 0) {
                    while (--n >= 0) {
                        dest[offset] = applyFilter((r1 & 0xff0000) | (g1 >> 8 & 0xff00) | (b1 >> 16 & 0xff), z1);
                        z1 += z2;
                        r1 += r2;
                        g1 += g2;
                        b1 += b2;
                        offset++;
                    }
                } else {
                    final int a1 = anInt1465;
                    final int a2 = 256 - anInt1465;
                    int rgb;
                    while (--n >= 0) {
                        rgb = r1 & 0xff0000 | g1 >> 8 & 0xff00 | b1 >> 16 & 0xff;
                        rgb = ((rgb & 0xff00ff) * a2 >> 8 & 0xff00ff) + ((rgb & 0xff00) * a2 >> 8 & 0xff00);
                        int dst = dest[offset];
                        dest[offset] = applyFilter(rgb + ((dst & 0xff00ff) * a1 >> 8 & 0xff00ff) + ((dst & 0xff00) * a1 >> 8 & 0xff00), z1);
                        offset++;
                        z1 += z2;
                        r1 += r2;
                        g1 += g2;
                        b1 += b2;
                    }
                }
            }
        }
    Model class:
    Code:
    private static int vertexPerspectiveDepth[] = new int[8000];
    Code:
    			Rasterizer.drawGouraudTriangle(...
    				vertexPerspectiveDepth[a], vertexPerspectiveDepth[b], vertexPerspectiveDepth[c]
    			);
    			return;
    Code:
    				if (i8 >= 50) {
    					projected_vertex_x[j7] = l5 + (k7 << 9) / i8;
    					projected_vertex_y[j7] = j6 + (l7 << 9) / i8;
    					vertexPerspectiveDepth[j7] = i8;
    				} else {
    					projected_vertex_x[j7] = -5000;
    					flag = true;
    				}
    WorldController

    method315:
    Code:
    if(class43.anInt718 != 0xbc614e) {
    					Rasterizer.drawGouraudTriangle(..., k3, j3, j2);
    				}
    Code:
    if(class43.anInt720 == -1 && class43.anInt718 != 0xbc614e) {
    				if(class43.anInt716 != 0xbc614e) {
    					Rasterizer.drawGouraudTriangle(..., k2, j2, j3);
    				}
    method316:
    Under:
    Code:
    			Class40.anIntArray688[l1] = Rasterizer.textureInt1 + (i2 << 9) / i3;
    			Class40.anIntArray689[l1] = Rasterizer.textureInt2 + (k2 << 9) / i3;
    add

    Code:
    Class40.depthPoint[l1] = i3;

    Code:
    if(class40.anIntArray682 == null || class40.anIntArray682[j2] == -1) {
    					if(class40.anIntArray676[j2] != 0xbc614e) {
    						Rasterizer.drawGouraudTriangle(..., Class40.depthPoint[l2], Class40.depthPoint[j3], Class40.depthPoint[l3]);
    					}
    Class40:

    Code:
    static final int[] depthPoint = new int[6];
    Reply With Quote  
     

  2. Thankful users:


  3. #2  
    Donator
    Yozgatli's Avatar
    Join Date
    Nov 2016
    Posts
    111
    Thanks given
    9
    Thanks received
    24
    Rep Power
    43
    Nice thanks for sharing this
    Reply With Quote  
     

  4. #3  
    Rune-Server Affiliate

    Join Date
    Apr 2014
    Posts
    1,761
    Thanks given
    75
    Thanks received
    714
    Rep Power
    1073
    No problem
    Reply With Quote  
     

  5. #4  
    Banned

    Join Date
    Mar 2017
    Posts
    293
    Thanks given
    200
    Thanks received
    192
    Rep Power
    0
    You must spread some Reputation around before giving it to Zion again.
    Reply With Quote  
     

  6. #5  
    Registered Member
    excl150's Avatar
    Join Date
    Jul 2014
    Posts
    123
    Thanks given
    46
    Thanks received
    30
    Rep Power
    97
    Well done, thanks for sharing
    Reply With Quote  
     

  7. #6  
    Rune-Server Affiliate

    Join Date
    Apr 2014
    Posts
    1,761
    Thanks given
    75
    Thanks received
    714
    Rep Power
    1073
    No worries
    Reply With Quote  
     

  8. #7  
    🖤Runic Developer🖤
    Castiel's Avatar
    Join Date
    Apr 2013
    Posts
    1,752
    Thanks given
    564
    Thanks received
    288
    Rep Power
    609
    nice work zion bro
    Attached image
    Attached image
    Reply With Quote  
     

  9. #8  
    Rune-Server Affiliate

    Join Date
    Apr 2014
    Posts
    1,761
    Thanks given
    75
    Thanks received
    714
    Rep Power
    1073
    Thanks. Missed a bit of code. I'll add to the thread shortly.

    And if anyone is interested, I can upload a clean 317 deob w/ this added.
    Reply With Quote  
     

  10. #9  
    Registered Member

    Join Date
    Oct 2011
    Posts
    2,084
    Thanks given
    0
    Thanks received
    1,043
    Rep Power
    3608
    Quote Originally Posted by Zion View Post
    Thanks. Missed a bit of code. I'll add to the thread shortly.

    And if anyone is interested, I can upload a clean 317 deob w/ this added.
    please upload a 317 deob with osrs data loading support.
    Reply With Quote  
     

  11. #10  
    Rune-Server Affiliate

    Join Date
    Apr 2014
    Posts
    1,761
    Thanks given
    75
    Thanks received
    714
    Rep Power
    1073
    Quote Originally Posted by Omelete View Post
    please upload a 317 deob with osrs data loading support.
    and this snippet? or just a clean 317 deob w/ the data?
    Reply With Quote  
     

Page 1 of 2 12 LastLast

Thread Information
Users Browsing this Thread

There are currently 1 users browsing this thread. (0 members and 1 guests)


User Tag List

Similar Threads

  1. Fog
    By theotherscape in forum RS2 Client
    Replies: 37
    Last Post: 08-24-2008, 08:36 PM
  2. Who said photoshop filters were useless?
    By Beh3moth in forum Showcase
    Replies: 11
    Last Post: 03-22-2008, 05:56 AM
  3. Decreasing Fog of War
    By Zachera in forum Tutorials
    Replies: 18
    Last Post: 12-19-2007, 06:55 PM
  4. Better NoClip filterer command(server side)
    By wizzyt21 in forum Tutorials
    Replies: 11
    Last Post: 09-19-2007, 06:34 AM
  5. Playername Filters
    By sarah101 in forum Tutorials
    Replies: 4
    Last Post: 05-04-2007, 12:04 AM
Posting Permissions
  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •