API tools faq
paste
Guest User

Shading

a guest
Apr 23rd, 2014
2,036
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 83.08 KB | None | 0 0
raw download clone embed print report
  1.  
  2. final class Texture extends DrawingArea {
  3.    
  4.     public static boolean smoothShading = true;
  5.  
  6.     public static void nullLoader()
  7.     {
  8.         anIntArray1468 = null;
  9.         anIntArray1468 = null;
  10.         anIntArray1470 = null;
  11.         anIntArray1471 = null;
  12.         anIntArray1472 = null;
  13.         aBackgroundArray1474s = null;
  14.         aBooleanArray1475 = null;
  15.         anIntArray1476 = null;
  16.         anIntArrayArray1478 = null;
  17.         anIntArrayArray1479 = null;
  18.         anIntArray1480 = null;
  19.         anIntArray1482 = null;
  20.         anIntArrayArray1483 = null;
  21.     }
  22.  
  23.     public static void method364()
  24.     {
  25.         anIntArray1472 = new int[DrawingArea.height];
  26.         for(int j = 0; j < DrawingArea.height; j++)
  27.             anIntArray1472[j] = DrawingArea.width * j;
  28.  
  29.         textureInt1 = DrawingArea.width / 2;
  30.         textureInt2 = DrawingArea.height / 2;
  31.     }
  32.  
  33.     public static void method365(int j, int k)
  34.     {
  35.        anIntArray1472 = new int[k];
  36.         for(int l = 0; l < k; l++)
  37.             anIntArray1472[l] = j * l;
  38.  
  39.         textureInt1 = j / 2;
  40.         textureInt2 = k / 2;
  41.     }
  42.  
  43.     public static void method366()
  44.     {
  45.         anIntArrayArray1478 = null;
  46.         for(int j = 0; j < 50; j++)
  47.             anIntArrayArray1479[j] = null;
  48.  
  49.     }
  50.  
  51.     public static void method367()
  52.     {
  53.         if(anIntArrayArray1478 == null)
  54.         {
  55.             anInt1477 = 20;//was parameter
  56.             if(lowMem)
  57.                 anIntArrayArray1478 = new int[anInt1477][16384];
  58.             else
  59.                 anIntArrayArray1478 = new int[anInt1477][0x10000];
  60.             for(int k = 0; k < 50; k++)
  61.                 anIntArrayArray1479[k] = null;
  62.  
  63.         }
  64.     }
  65.  
  66.     public static void method368(StreamLoader streamLoader)
  67.     {
  68.         anInt1473 = 0;
  69.         for(int j = 0; j < 50; j++)
  70.             try
  71.             {
  72.                 aBackgroundArray1474s[j] = new Background(streamLoader, String.valueOf(j), 0);
  73.                 if(lowMem && aBackgroundArray1474s[j].anInt1456 == 128)
  74.                     aBackgroundArray1474s[j].method356();
  75.                 else
  76.                     aBackgroundArray1474s[j].method357();
  77.                 anInt1473++;
  78.             }
  79.             catch(Exception _ex) { }
  80.  
  81.     }
  82.  
  83.     public static int method369(int i)
  84.     {
  85.         if(anIntArray1476[i] != 0)
  86.             return anIntArray1476[i];
  87.         int k = 0;
  88.         int l = 0;
  89.         int i1 = 0;
  90.         int j1 = anIntArrayArray1483[i].length;
  91.         for(int k1 = 0; k1 < j1; k1++)
  92.         {
  93.             k += anIntArrayArray1483[i][k1] >> 16 & 0xff;
  94.             l += anIntArrayArray1483[i][k1] >> 8 & 0xff;
  95.             i1 += anIntArrayArray1483[i][k1] & 0xff;
  96.         }
  97.  
  98.         int l1 = (k / j1 << 16) + (l / j1 << 8) + i1 / j1;
  99.         l1 = method373(l1, 1.3999999999999999D);
  100.         if(l1 == 0)
  101.             l1 = 1;
  102.         anIntArray1476[i] = l1;
  103.         return l1;
  104.     }
  105.  
  106.     public static void method370(int i)
  107.     {
  108.         if(anIntArrayArray1479[i] == null)
  109.             return;
  110.         anIntArrayArray1478[anInt1477++] = anIntArrayArray1479[i];
  111.         anIntArrayArray1479[i] = null;
  112.     }
  113.  
  114.     private static int[] method371(int i)
  115.     {
  116.         anIntArray1480[i] = anInt1481++;
  117.         if(anIntArrayArray1479[i] != null)
  118.             return anIntArrayArray1479[i];
  119.         int ai[];
  120.         if(anInt1477 > 0)
  121.         {
  122.             ai = anIntArrayArray1478[--anInt1477];
  123.             anIntArrayArray1478[anInt1477] = null;
  124.         } else
  125.         {
  126.             int j = 0;
  127.             int k = -1;
  128.             for(int l = 0; l < anInt1473; l++)
  129.                 if(anIntArrayArray1479[l] != null && (anIntArray1480[l] < j || k == -1))
  130.                 {
  131.                     j = anIntArray1480[l];
  132.                     k = l;
  133.                 }
  134.  
  135.             ai = anIntArrayArray1479[k];
  136.             anIntArrayArray1479[k] = null;
  137.         }
  138.         anIntArrayArray1479[i] = ai;
  139.         Background background = aBackgroundArray1474s[i];
  140.         int ai1[] = anIntArrayArray1483[i];
  141.         if(lowMem)
  142.         {
  143.             aBooleanArray1475[i] = false;
  144.             for(int i1 = 0; i1 < 4096; i1++)
  145.             {
  146.                 int i2 = ai[i1] = ai1[background.aByteArray1450[i1]] & 0xf8f8ff;
  147.                 if(i2 == 0)
  148.                     aBooleanArray1475[i] = true;
  149.                 ai[4096 + i1] = i2 - (i2 >>> 3) & 0xf8f8ff;
  150.                 ai[8192 + i1] = i2 - (i2 >>> 2) & 0xf8f8ff;
  151.                 ai[12288 + i1] = i2 - (i2 >>> 2) - (i2 >>> 3) & 0xf8f8ff;
  152.             }
  153.  
  154.         } else
  155.         {
  156.             if(background.anInt1452 == 64)
  157.             {
  158.                 for(int j1 = 0; j1 < 128; j1++)
  159.                 {
  160.                     for(int j2 = 0; j2 < 128; j2++)
  161.                         ai[j2 + (j1 << 7)] = ai1[background.aByteArray1450[(j2 >> 1) + ((j1 >> 1) << 6)]];
  162.  
  163.                 }
  164.  
  165.             } else
  166.             {
  167.                 for(int k1 = 0; k1 < 16384; k1++)
  168.                     ai[k1] = ai1[background.aByteArray1450[k1]];
  169.  
  170.             }
  171.             aBooleanArray1475[i] = false;
  172.             for(int l1 = 0; l1 < 16384; l1++)
  173.             {
  174.                 ai[l1] &= 0xf8f8ff;
  175.                 int k2 = ai[l1];
  176.                 if(k2 == 0)
  177.                     aBooleanArray1475[i] = true;
  178.                 ai[16384 + l1] = k2 - (k2 >>> 3) & 0xf8f8ff;
  179.                 ai[32768 + l1] = k2 - (k2 >>> 2) & 0xf8f8ff;
  180.                 ai[49152 + l1] = k2 - (k2 >>> 2) - (k2 >>> 3) & 0xf8f8ff;
  181.             }
  182.  
  183.         }
  184.         return ai;
  185.     }
  186.  
  187.     public static void method372(double d)
  188.     {
  189.         d += Math.random() * 0.029999999999999999D - 0.014999999999999999D;
  190.         int j = 0;
  191.         for(int k = 0; k < 512; k++)
  192.         {
  193.             double d1 = (double)(k / 8) / 64D + 0.0078125D;
  194.             double d2 = (double)(k & 7) / 8D + 0.0625D;
  195.             for(int k1 = 0; k1 < 128; k1++)
  196.             {
  197.                 double d3 = (double)k1 / 128D;
  198.                 double d4 = d3;
  199.                 double d5 = d3;
  200.                 double d6 = d3;
  201.                 if(d2 != 0.0D)
  202.                 {
  203.                     double d7;
  204.                     if(d3 < 0.5D)
  205.                         d7 = d3 * (1.0D + d2);
  206.                     else
  207.                         d7 = (d3 + d2) - d3 * d2;
  208.                     double d8 = 2D * d3 - d7;
  209.                     double d9 = d1 + 0.33333333333333331D;
  210.                     if(d9 > 1.0D)
  211.                         d9--;
  212.                     double d10 = d1;
  213.                     double d11 = d1 - 0.33333333333333331D;
  214.                     if(d11 < 0.0D)
  215.                         d11++;
  216.                     if(6D * d9 < 1.0D)
  217.                         d4 = d8 + (d7 - d8) * 6D * d9;
  218.                     else
  219.                     if(2D * d9 < 1.0D)
  220.                         d4 = d7;
  221.                     else
  222.                     if(3D * d9 < 2D)
  223.                         d4 = d8 + (d7 - d8) * (0.66666666666666663D - d9) * 6D;
  224.                     else
  225.                         d4 = d8;
  226.                     if(6D * d10 < 1.0D)
  227.                         d5 = d8 + (d7 - d8) * 6D * d10;
  228.                     else
  229.                     if(2D * d10 < 1.0D)
  230.                         d5 = d7;
  231.                     else
  232.                     if(3D * d10 < 2D)
  233.                         d5 = d8 + (d7 - d8) * (0.66666666666666663D - d10) * 6D;
  234.                     else
  235.                         d5 = d8;
  236.                     if(6D * d11 < 1.0D)
  237.                         d6 = d8 + (d7 - d8) * 6D * d11;
  238.                     else
  239.                     if(2D * d11 < 1.0D)
  240.                         d6 = d7;
  241.                     else
  242.                     if(3D * d11 < 2D)
  243.                         d6 = d8 + (d7 - d8) * (0.66666666666666663D - d11) * 6D;
  244.                     else
  245.                         d6 = d8;
  246.                 }
  247.                 int l1 = (int)(d4 * 256D);
  248.                 int i2 = (int)(d5 * 256D);
  249.                 int j2 = (int)(d6 * 256D);
  250.                 int k2 = (l1 << 16) + (i2 << 8) + j2;
  251.                 k2 = method373(k2, d);
  252.                 if(k2 == 0)
  253.                     k2 = 1;
  254.                 anIntArray1482[j++] = k2;
  255.             }
  256.  
  257.         }
  258.  
  259.         for(int l = 0; l < 50; l++)
  260.             if(aBackgroundArray1474s[l] != null)
  261.             {
  262.                 int ai[] = aBackgroundArray1474s[l].anIntArray1451;
  263.                 anIntArrayArray1483[l] = new int[ai.length];
  264.                 for(int j1 = 0; j1 < ai.length; j1++)
  265.                 {
  266.                     anIntArrayArray1483[l][j1] = method373(ai[j1], d);
  267.                     if((anIntArrayArray1483[l][j1] & 0xf8f8ff) == 0 && j1 != 0)
  268.                         anIntArrayArray1483[l][j1] = 1;
  269.                 }
  270.  
  271.             }
  272.  
  273.         for(int i1 = 0; i1 < 50; i1++)
  274.             method370(i1);
  275.  
  276.     }
  277.  
  278.     private static int method373(int i, double d)
  279.     {
  280.         double d1 = (double)(i >> 16) / 256D;
  281.         double d2 = (double)(i >> 8 & 0xff) / 256D;
  282.         double d3 = (double)(i & 0xff) / 256D;
  283.         d1 = Math.pow(d1, d);
  284.         d2 = Math.pow(d2, d);
  285.         d3 = Math.pow(d3, d);
  286.         int j = (int)(d1 * 256D);
  287.         int k = (int)(d2 * 256D);
  288.         int l = (int)(d3 * 256D);
  289.         return (j << 16) + (k << 8) + l;
  290.     }
  291.    
  292.     public static void method374(int y1, int y2, int y3, int x1, int x2, int x3, int hsl1, int hsl2, int hsl3) {
  293.         if (smoothShading && aBoolean1464) {
  294.             drawHDGouraudTriangle(y1, y2, y3, x1, x2, x3, hsl1, hsl2, hsl3);
  295.         } else {
  296.             drawLDGouraudTriangle(y1, y2, y3, x1, x2, x3, hsl1, hsl2, hsl3);
  297.         }
  298.     }
  299.  
  300.     public static void drawLDGouraudTriangle(int y1, int y2, int y3, int x1, int x2, int x3, int hsl1, int hsl2, int hsl3) {
  301.         int j2 = 0;
  302.         int k2 = 0;
  303.         if(y2 != y1)
  304.         {
  305.             j2 = (x2 - x1 << 16) / (y2 - y1);
  306.             k2 = (hsl2 - hsl1 << 15) / (y2 - y1);
  307.         }
  308.         int l2 = 0;
  309.         int i3 = 0;
  310.         if(y3 != y2)
  311.         {
  312.             l2 = (x3 - x2 << 16) / (y3 - y2);
  313.             i3 = (hsl3 - hsl2 << 15) / (y3 - y2);
  314.         }
  315.         int j3 = 0;
  316.         int k3 = 0;
  317.         if(y3 != y1)
  318.         {
  319.             j3 = (x1 - x3 << 16) / (y1 - y3);
  320.             k3 = (hsl1 - hsl3 << 15) / (y1 - y3);
  321.         }
  322.         if(y1 <= y2 && y1 <= y3)
  323.         {
  324.             if(y1 >= DrawingArea.bottomY)
  325.                 return;
  326.             if(y2 > DrawingArea.bottomY)
  327.                 y2 = DrawingArea.bottomY;
  328.             if(y3 > DrawingArea.bottomY)
  329.                 y3 = DrawingArea.bottomY;
  330.             if(y2 < y3)
  331.             {
  332.                 x3 = x1 <<= 16;
  333.                 hsl3 = hsl1 <<= 15;
  334.                 if(y1 < 0)
  335.                 {
  336.                     x3 -= j3 * y1;
  337.                     x1 -= j2 * y1;
  338.                     hsl3 -= k3 * y1;
  339.                     hsl1 -= k2 * y1;
  340.                     y1 = 0;
  341.                 }
  342.                 x2 <<= 16;
  343.                 hsl2 <<= 15;
  344.                 if(y2 < 0)
  345.                 {
  346.                     x2 -= l2 * y2;
  347.                     hsl2 -= i3 * y2;
  348.                     y2 = 0;
  349.                 }
  350.                 if(y1 != y2 && j3 < j2 || y1 == y2 && j3 > l2)
  351.                 {
  352.                     y3 -= y2;
  353.                     y2 -= y1;
  354.                     for(y1 = anIntArray1472[y1]; --y2 >= 0; y1 += DrawingArea.width)
  355.                     {
  356.                         drawLDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x1 >> 16, hsl3 >> 7, hsl1 >> 7);
  357.                         x3 += j3;
  358.                         x1 += j2;
  359.                         hsl3 += k3;
  360.                         hsl1 += k2;
  361.                     }
  362.  
  363.                     while(--y3 >= 0)
  364.                     {
  365.                         drawLDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x2 >> 16, hsl3 >> 7, hsl2 >> 7);
  366.                         x3 += j3;
  367.                         x2 += l2;
  368.                         hsl3 += k3;
  369.                         hsl2 += i3;
  370.                         y1 += DrawingArea.width;
  371.                     }
  372.                     return;
  373.                 }
  374.                 y3 -= y2;
  375.                 y2 -= y1;
  376.                 for(y1 = anIntArray1472[y1]; --y2 >= 0; y1 += DrawingArea.width)
  377.                 {
  378.                     drawLDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x3 >> 16, hsl1 >> 7, hsl3 >> 7);
  379.                     x3 += j3;
  380.                     x1 += j2;
  381.                     hsl3 += k3;
  382.                     hsl1 += k2;
  383.                 }
  384.  
  385.                 while(--y3 >= 0)
  386.                 {
  387.                     drawLDGouraudScanline(DrawingArea.pixels, y1, x2 >> 16, x3 >> 16, hsl2 >> 7, hsl3 >> 7);
  388.                     x3 += j3;
  389.                     x2 += l2;
  390.                     hsl3 += k3;
  391.                     hsl2 += i3;
  392.                     y1 += DrawingArea.width;
  393.                 }
  394.                 return;
  395.             }
  396.             x2 = x1 <<= 16;
  397.             hsl2 = hsl1 <<= 15;
  398.             if(y1 < 0)
  399.             {
  400.                 x2 -= j3 * y1;
  401.                 x1 -= j2 * y1;
  402.                 hsl2 -= k3 * y1;
  403.                 hsl1 -= k2 * y1;
  404.                 y1 = 0;
  405.             }
  406.             x3 <<= 16;
  407.             hsl3 <<= 15;
  408.             if(y3 < 0)
  409.             {
  410.                 x3 -= l2 * y3;
  411.                 hsl3 -= i3 * y3;
  412.                 y3 = 0;
  413.             }
  414.             if(y1 != y3 && j3 < j2 || y1 == y3 && l2 > j2)
  415.             {
  416.                 y2 -= y3;
  417.                 y3 -= y1;
  418.                 for(y1 = anIntArray1472[y1]; --y3 >= 0; y1 += DrawingArea.width)
  419.                 {
  420.                     drawLDGouraudScanline(DrawingArea.pixels, y1, x2 >> 16, x1 >> 16, hsl2 >> 7, hsl1 >> 7);
  421.                     x2 += j3;
  422.                     x1 += j2;
  423.                     hsl2 += k3;
  424.                     hsl1 += k2;
  425.                 }
  426.  
  427.                 while(--y2 >= 0)
  428.                 {
  429.                     drawLDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x1 >> 16, hsl3 >> 7, hsl1 >> 7);
  430.                     x3 += l2;
  431.                     x1 += j2;
  432.                     hsl3 += i3;
  433.                     hsl1 += k2;
  434.                     y1 += DrawingArea.width;
  435.                 }
  436.                 return;
  437.             }
  438.             y2 -= y3;
  439.             y3 -= y1;
  440.             for(y1 = anIntArray1472[y1]; --y3 >= 0; y1 += DrawingArea.width)
  441.             {
  442.                 drawLDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x2 >> 16, hsl1 >> 7, hsl2 >> 7);
  443.                 x2 += j3;
  444.                 x1 += j2;
  445.                 hsl2 += k3;
  446.                 hsl1 += k2;
  447.             }
  448.  
  449.             while(--y2 >= 0)
  450.             {
  451.                 drawLDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x3 >> 16, hsl1 >> 7, hsl3 >> 7);
  452.                 x3 += l2;
  453.                 x1 += j2;
  454.                 hsl3 += i3;
  455.                 hsl1 += k2;
  456.                 y1 += DrawingArea.width;
  457.             }
  458.             return;
  459.         }
  460.         if(y2 <= y3)
  461.         {
  462.             if(y2 >= DrawingArea.bottomY)
  463.                 return;
  464.             if(y3 > DrawingArea.bottomY)
  465.                 y3 = DrawingArea.bottomY;
  466.             if(y1 > DrawingArea.bottomY)
  467.                 y1 = DrawingArea.bottomY;
  468.             if(y3 < y1)
  469.             {
  470.                 x1 = x2 <<= 16;
  471.                 hsl1 = hsl2 <<= 15;
  472.                 if(y2 < 0)
  473.                 {
  474.                     x1 -= j2 * y2;
  475.                     x2 -= l2 * y2;
  476.                     hsl1 -= k2 * y2;
  477.                     hsl2 -= i3 * y2;
  478.                     y2 = 0;
  479.                 }
  480.                 x3 <<= 16;
  481.                 hsl3 <<= 15;
  482.                 if(y3 < 0)
  483.                 {
  484.                     x3 -= j3 * y3;
  485.                     hsl3 -= k3 * y3;
  486.                     y3 = 0;
  487.                 }
  488.                 if(y2 != y3 && j2 < l2 || y2 == y3 && j2 > j3)
  489.                 {
  490.                     y1 -= y3;
  491.                     y3 -= y2;
  492.                     for(y2 = anIntArray1472[y2]; --y3 >= 0; y2 += DrawingArea.width)
  493.                     {
  494.                         drawLDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x2 >> 16, hsl1 >> 7, hsl2 >> 7);
  495.                         x1 += j2;
  496.                         x2 += l2;
  497.                         hsl1 += k2;
  498.                         hsl2 += i3;
  499.                     }
  500.  
  501.                     while(--y1 >= 0)
  502.                     {
  503.                         drawLDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x3 >> 16, hsl1 >> 7, hsl3 >> 7);
  504.                         x1 += j2;
  505.                         x3 += j3;
  506.                         hsl1 += k2;
  507.                         hsl3 += k3;
  508.                         y2 += DrawingArea.width;
  509.                     }
  510.                     return;
  511.                 }
  512.                 y1 -= y3;
  513.                 y3 -= y2;
  514.                 for(y2 = anIntArray1472[y2]; --y3 >= 0; y2 += DrawingArea.width)
  515.                 {
  516.                     drawLDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x1 >> 16, hsl2 >> 7, hsl1 >> 7);
  517.                     x1 += j2;
  518.                     x2 += l2;
  519.                     hsl1 += k2;
  520.                     hsl2 += i3;
  521.                 }
  522.  
  523.                 while(--y1 >= 0)
  524.                 {
  525.                     drawLDGouraudScanline(DrawingArea.pixels, y2, x3 >> 16, x1 >> 16, hsl3 >> 7, hsl1 >> 7);
  526.                     x1 += j2;
  527.                     x3 += j3;
  528.                     hsl1 += k2;
  529.                     hsl3 += k3;
  530.                     y2 += DrawingArea.width;
  531.                 }
  532.                 return;
  533.             }
  534.             x3 = x2 <<= 16;
  535.             hsl3 = hsl2 <<= 15;
  536.             if(y2 < 0)
  537.             {
  538.                 x3 -= j2 * y2;
  539.                 x2 -= l2 * y2;
  540.                 hsl3 -= k2 * y2;
  541.                 hsl2 -= i3 * y2;
  542.                 y2 = 0;
  543.             }
  544.             x1 <<= 16;
  545.             hsl1 <<= 15;
  546.             if(y1 < 0)
  547.             {
  548.                 x1 -= j3 * y1;
  549.                 hsl1 -= k3 * y1;
  550.                 y1 = 0;
  551.             }
  552.             if(j2 < l2)
  553.             {
  554.                 y3 -= y1;
  555.                 y1 -= y2;
  556.                 for(y2 = anIntArray1472[y2]; --y1 >= 0; y2 += DrawingArea.width)
  557.                 {
  558.                     drawLDGouraudScanline(DrawingArea.pixels, y2, x3 >> 16, x2 >> 16, hsl3 >> 7, hsl2 >> 7);
  559.                     x3 += j2;
  560.                     x2 += l2;
  561.                     hsl3 += k2;
  562.                     hsl2 += i3;
  563.                 }
  564.  
  565.                 while(--y3 >= 0)
  566.                 {
  567.                     drawLDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x2 >> 16, hsl1 >> 7, hsl2 >> 7);
  568.                     x1 += j3;
  569.                     x2 += l2;
  570.                     hsl1 += k3;
  571.                     hsl2 += i3;
  572.                     y2 += DrawingArea.width;
  573.                 }
  574.                 return;
  575.             }
  576.             y3 -= y1;
  577.             y1 -= y2;
  578.             for(y2 = anIntArray1472[y2]; --y1 >= 0; y2 += DrawingArea.width)
  579.             {
  580.                 drawLDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x3 >> 16, hsl2 >> 7, hsl3 >> 7);
  581.                 x3 += j2;
  582.                 x2 += l2;
  583.                 hsl3 += k2;
  584.                 hsl2 += i3;
  585.             }
  586.  
  587.             while(--y3 >= 0)
  588.             {
  589.                 drawLDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x1 >> 16, hsl2 >> 7, hsl1 >> 7);
  590.                 x1 += j3;
  591.                 x2 += l2;
  592.                 hsl1 += k3;
  593.                 hsl2 += i3;
  594.                 y2 += DrawingArea.width;
  595.             }
  596.             return;
  597.         }
  598.         if(y3 >= DrawingArea.bottomY)
  599.             return;
  600.         if(y1 > DrawingArea.bottomY)
  601.             y1 = DrawingArea.bottomY;
  602.         if(y2 > DrawingArea.bottomY)
  603.             y2 = DrawingArea.bottomY;
  604.         if(y1 < y2)
  605.         {
  606.             x2 = x3 <<= 16;
  607.             hsl2 = hsl3 <<= 15;
  608.             if(y3 < 0)
  609.             {
  610.                 x2 -= l2 * y3;
  611.                 x3 -= j3 * y3;
  612.                 hsl2 -= i3 * y3;
  613.                 hsl3 -= k3 * y3;
  614.                 y3 = 0;
  615.             }
  616.             x1 <<= 16;
  617.             hsl1 <<= 15;
  618.             if(y1 < 0)
  619.             {
  620.                 x1 -= j2 * y1;
  621.                 hsl1 -= k2 * y1;
  622.                 y1 = 0;
  623.             }
  624.             if(l2 < j3)
  625.             {
  626.                 y2 -= y1;
  627.                 y1 -= y3;
  628.                 for(y3 = anIntArray1472[y3]; --y1 >= 0; y3 += DrawingArea.width)
  629.                 {
  630.                     drawLDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x3 >> 16, hsl2 >> 7, hsl3 >> 7);
  631.                     x2 += l2;
  632.                     x3 += j3;
  633.                     hsl2 += i3;
  634.                     hsl3 += k3;
  635.                 }
  636.  
  637.                 while(--y2 >= 0)
  638.                 {
  639.                     drawLDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x1 >> 16, hsl2 >> 7, hsl1 >> 7);
  640.                     x2 += l2;
  641.                     x1 += j2;
  642.                     hsl2 += i3;
  643.                     hsl1 += k2;
  644.                     y3 += DrawingArea.width;
  645.                 }
  646.                 return;
  647.             }
  648.             y2 -= y1;
  649.             y1 -= y3;
  650.             for(y3 = anIntArray1472[y3]; --y1 >= 0; y3 += DrawingArea.width)
  651.             {
  652.                 drawLDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x2 >> 16, hsl3 >> 7, hsl2 >> 7);
  653.                 x2 += l2;
  654.                 x3 += j3;
  655.                 hsl2 += i3;
  656.                 hsl3 += k3;
  657.             }
  658.  
  659.             while(--y2 >= 0)
  660.             {
  661.                 drawLDGouraudScanline(DrawingArea.pixels, y3, x1 >> 16, x2 >> 16, hsl1 >> 7, hsl2 >> 7);
  662.                 x2 += l2;
  663.                 x1 += j2;
  664.                 hsl2 += i3;
  665.                 hsl1 += k2;
  666.                 y3 += DrawingArea.width;
  667.             }
  668.             return;
  669.         }
  670.         x1 = x3 <<= 16;
  671.         hsl1 = hsl3 <<= 15;
  672.         if(y3 < 0)
  673.         {
  674.             x1 -= l2 * y3;
  675.             x3 -= j3 * y3;
  676.             hsl1 -= i3 * y3;
  677.             hsl3 -= k3 * y3;
  678.             y3 = 0;
  679.         }
  680.         x2 <<= 16;
  681.         hsl2 <<= 15;
  682.         if(y2 < 0)
  683.         {
  684.             x2 -= j2 * y2;
  685.             hsl2 -= k2 * y2;
  686.             y2 = 0;
  687.         }
  688.         if(l2 < j3)
  689.         {
  690.             y1 -= y2;
  691.             y2 -= y3;
  692.             for(y3 = anIntArray1472[y3]; --y2 >= 0; y3 += DrawingArea.width)
  693.             {
  694.                 drawLDGouraudScanline(DrawingArea.pixels, y3, x1 >> 16, x3 >> 16, hsl1 >> 7, hsl3 >> 7);
  695.                 x1 += l2;
  696.                 x3 += j3;
  697.                 hsl1 += i3;
  698.                 hsl3 += k3;
  699.             }
  700.  
  701.             while(--y1 >= 0)
  702.             {
  703.                 drawLDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x3 >> 16, hsl2 >> 7, hsl3 >> 7);
  704.                 x2 += j2;
  705.                 x3 += j3;
  706.                 hsl2 += k2;
  707.                 hsl3 += k3;
  708.                 y3 += DrawingArea.width;
  709.             }
  710.             return;
  711.         }
  712.         y1 -= y2;
  713.         y2 -= y3;
  714.         for(y3 = anIntArray1472[y3]; --y2 >= 0; y3 += DrawingArea.width)
  715.         {
  716.             drawLDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x1 >> 16, hsl3 >> 7, hsl1 >> 7);
  717.             x1 += l2;
  718.             x3 += j3;
  719.             hsl1 += i3;
  720.             hsl3 += k3;
  721.         }
  722.  
  723.         while(--y1 >= 0)
  724.         {
  725.             drawLDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x2 >> 16, hsl3 >> 7, hsl2 >> 7);
  726.             x2 += j2;
  727.             x3 += j3;
  728.             hsl2 += k2;
  729.             hsl3 += k3;
  730.             y3 += DrawingArea.width;
  731.         }
  732.     }
  733.  
  734.     private static void drawLDGouraudScanline(int ai[], int i, int l, int i1, int j1, int k1)
  735.     {
  736.         int j;//was parameter
  737.         int k;//was parameter
  738.         if(aBoolean1464)
  739.         {
  740.             int l1;
  741.             if(aBoolean1462)
  742.             {
  743.                 if(i1 - l > 3)
  744.                     l1 = (k1 - j1) / (i1 - l);
  745.                 else
  746.                     l1 = 0;
  747.                 if(i1 > DrawingArea.centerX)
  748.                     i1 = DrawingArea.centerX;
  749.                 if(l < 0)
  750.                 {
  751.                     j1 -= l * l1;
  752.                     l = 0;
  753.                 }
  754.                 if(l >= i1)
  755.                     return;
  756.                 i += l;
  757.                 k = i1 - l >> 2;
  758.                 l1 <<= 2;
  759.             } else
  760.             {
  761.                 if(l >= i1)
  762.                     return;
  763.                 i += l;
  764.                 k = i1 - l >> 2;
  765.                 if(k > 0)
  766.                     l1 = (k1 - j1) * anIntArray1468[k] >> 15;
  767.                 else
  768.                     l1 = 0;
  769.             }
  770.             if(anInt1465 == 0)
  771.             {
  772.                 while(--k >= 0)
  773.                 {
  774.                     j = anIntArray1482[j1 >> 8];
  775.                     j1 += l1;
  776.                     ai[i++] = j;
  777.                     ai[i++] = j;
  778.                     ai[i++] = j;
  779.                     ai[i++] = j;
  780.                 }
  781.                 k = i1 - l & 3;
  782.                 if(k > 0)
  783.                 {
  784.                     j = anIntArray1482[j1 >> 8];
  785.                     do
  786.                         ai[i++] = j;
  787.                     while(--k > 0);
  788.                     return;
  789.                 }
  790.             } else
  791.             {
  792.                 int j2 = anInt1465;
  793.                 int l2 = 256 - anInt1465;
  794.                 while(--k >= 0)
  795.                 {
  796.                     j = anIntArray1482[j1 >> 8];
  797.                     j1 += l1;
  798.                     j = ((j & 0xff00ff) * l2 >> 8 & 0xff00ff) + ((j & 0xff00) * l2 >> 8 & 0xff00);
  799.                     ai[i++] = j + ((ai[i] & 0xff00ff) * j2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j2 >> 8 & 0xff00);
  800.                     ai[i++] = j + ((ai[i] & 0xff00ff) * j2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j2 >> 8 & 0xff00);
  801.                     ai[i++] = j + ((ai[i] & 0xff00ff) * j2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j2 >> 8 & 0xff00);
  802.                     ai[i++] = j + ((ai[i] & 0xff00ff) * j2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j2 >> 8 & 0xff00);
  803.                 }
  804.                 k = i1 - l & 3;
  805.                 if(k > 0)
  806.                 {
  807.                     j = anIntArray1482[j1 >> 8];
  808.                     j = ((j & 0xff00ff) * l2 >> 8 & 0xff00ff) + ((j & 0xff00) * l2 >> 8 & 0xff00);
  809.                     do
  810.                         ai[i++] = j + ((ai[i] & 0xff00ff) * j2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j2 >> 8 & 0xff00);
  811.                     while(--k > 0);
  812.                 }
  813.             }
  814.             return;
  815.         }
  816.         if(l >= i1)
  817.             return;
  818.         int i2 = (k1 - j1) / (i1 - l);
  819.         if(aBoolean1462)
  820.         {
  821.             if(i1 > DrawingArea.centerX)
  822.                 i1 = DrawingArea.centerX;
  823.             if(l < 0)
  824.             {
  825.                 j1 -= l * i2;
  826.                 l = 0;
  827.             }
  828.             if(l >= i1)
  829.                 return;
  830.         }
  831.         i += l;
  832.         k = i1 - l;
  833.         if(anInt1465 == 0)
  834.         {
  835.             do
  836.             {
  837.                 ai[i++] = anIntArray1482[j1 >> 8];
  838.                 j1 += i2;
  839.             } while(--k > 0);
  840.             return;
  841.         }
  842.         int k2 = anInt1465;
  843.         int i3 = 256 - anInt1465;
  844.         do
  845.         {
  846.             j = anIntArray1482[j1 >> 8];
  847.             j1 += i2;
  848.             j = ((j & 0xff00ff) * i3 >> 8 & 0xff00ff) + ((j & 0xff00) * i3 >> 8 & 0xff00);
  849.             ai[i++] = j + ((ai[i] & 0xff00ff) * k2 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * k2 >> 8 & 0xff00);
  850.         } while(--k > 0);
  851.     }
  852.  
  853.     public static void drawHDGouraudTriangle(int y1, int y2, int y3, int x1, int x2, int x3, int hsl1, int hsl2, int hsl3) {
  854.         int rgb1 = anIntArray1482[hsl1];
  855.         int rgb2 = anIntArray1482[hsl2];
  856.         int rgb3 = anIntArray1482[hsl3];
  857.         int r1 = rgb1 >> 16 & 0xff;
  858.         int g1 = rgb1 >> 8 & 0xff;
  859.         int b1 = rgb1 & 0xff;
  860.         int r2 = rgb2 >> 16 & 0xff;
  861.         int g2 = rgb2 >> 8 & 0xff;
  862.         int b2 = rgb2 & 0xff;
  863.         int r3 = rgb3 >> 16 & 0xff;
  864.         int g3 = rgb3 >> 8 & 0xff;
  865.         int b3 = rgb3 & 0xff;
  866.         int dx1 = 0;
  867.         int dr1 = 0;
  868.         int dg1 = 0;
  869.         int db1 = 0;
  870.         if (y2 != y1) {
  871.             dx1 = (x2 - x1 << 16) / (y2 - y1);
  872.             dr1 = (r2 - r1 << 16) / (y2 - y1);
  873.             dg1 = (g2 - g1 << 16) / (y2 - y1);
  874.             db1 = (b2 - b1 << 16) / (y2 - y1);
  875.         }
  876.         int dx2 = 0;
  877.         int dr2 = 0;
  878.         int dg2 = 0;
  879.         int db2 = 0;
  880.         if (y3 != y2) {
  881.             dx2 = (x3 - x2 << 16) / (y3 - y2);
  882.             dr2 = (r3 - r2 << 16) / (y3 - y2);
  883.             dg2 = (g3 - g2 << 16) / (y3 - y2);
  884.             db2 = (b3 - b2 << 16) / (y3 - y2);
  885.         }
  886.         int dx3 = 0;
  887.         int dr3 = 0;
  888.         int dg3 = 0;
  889.         int db3 = 0;
  890.         if (y3 != y1) {
  891.             dx3 = (x1 - x3 << 16) / (y1 - y3);
  892.             dr3 = (r1 - r3 << 16) / (y1 - y3);
  893.             dg3 = (g1 - g3 << 16) / (y1 - y3);
  894.             db3 = (b1 - b3 << 16) / (y1 - y3);
  895.         }
  896.         if(y1 <= y2 && y1 <= y3) {
  897.             if(y1 >= DrawingArea.bottomY) {
  898.                 return;
  899.             }
  900.             if(y2 > DrawingArea.bottomY) {
  901.                 y2 = DrawingArea.bottomY;
  902.             }
  903.             if(y3 > DrawingArea.bottomY) {
  904.                 y3 = DrawingArea.bottomY;
  905.             }
  906.             if(y2 < y3) {
  907.                 x3 = x1 <<= 16;
  908.                 r3 = r1 <<= 16;
  909.                 g3 = g1 <<= 16;
  910.                 b3 = b1 <<= 16;
  911.                 if(y1 < 0) {
  912.                     x3 -= dx3 * y1;
  913.                     x1 -= dx1 * y1;
  914.                     r3 -= dr3 * y1;
  915.                     g3 -= dg3 * y1;
  916.                     b3 -= db3 * y1;
  917.                     r1 -= dr1 * y1;
  918.                     g1 -= dg1 * y1;
  919.                     b1 -= db1 * y1;
  920.                     y1 = 0;
  921.                 }
  922.                 x2 <<= 16;
  923.                 r2 <<= 16;
  924.                 g2 <<= 16;
  925.                 b2 <<= 16;
  926.                 if(y2 < 0) {
  927.                     x2 -= dx2 * y2;
  928.                     r2 -= dr2 * y2;
  929.                     g2 -= dg2 * y2;
  930.                     b2 -= db2 * y2;
  931.                     y2 = 0;
  932.                 }
  933.                 if(y1 != y2 && dx3 < dx1 || y1 == y2 && dx3 > dx2) {
  934.                     y3 -= y2;
  935.                     y2 -= y1;
  936.                     for(y1 = anIntArray1472[y1]; --y2 >= 0; y1 += DrawingArea.width) {
  937.                         drawHDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1);
  938.                         x3 += dx3;
  939.                         x1 += dx1;
  940.                         r3 += dr3;
  941.                         g3 += dg3;
  942.                         b3 += db3;
  943.                         r1 += dr1;
  944.                         g1 += dg1;
  945.                         b1 += db1;
  946.                     }
  947.                     while(--y3 >= 0) {
  948.                         drawHDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2);
  949.                         x3 += dx3;
  950.                         x2 += dx2;
  951.                         r3 += dr3;
  952.                         g3 += dg3;
  953.                         b3 += db3;
  954.                         r2 += dr2;
  955.                         g2 += dg2;
  956.                         b2 += db2;
  957.                         y1 += DrawingArea.width;
  958.                     }
  959.                     return;
  960.                 }
  961.                 y3 -= y2;
  962.                 y2 -= y1;
  963.                 for(y1 = anIntArray1472[y1]; --y2 >= 0; y1 += DrawingArea.width) {
  964.                     drawHDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3);
  965.                     x3 += dx3;
  966.                     x1 += dx1;
  967.                     r3 += dr3;
  968.                     g3 += dg3;
  969.                     b3 += db3;
  970.                     r1 += dr1;
  971.                     g1 += dg1;
  972.                     b1 += db1;
  973.                 }
  974.                 while(--y3 >= 0) {
  975.                     drawHDGouraudScanline(DrawingArea.pixels, y1, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3);
  976.                     x3 += dx3;
  977.                     x2 += dx2;
  978.                     r3 += dr3;
  979.                     g3 += dg3;
  980.                     b3 += db3;
  981.                     r2 += dr2;
  982.                     g2 += dg2;
  983.                     b2 += db2;
  984.                     y1 += DrawingArea.width;
  985.                 }
  986.                 return;
  987.             }
  988.             x2 = x1 <<= 16;
  989.             r2 = r1 <<= 16;
  990.             g2 = g1 <<= 16;
  991.             b2 = b1 <<= 16;
  992.             if(y1 < 0) {
  993.                 x2 -= dx3 * y1;
  994.                 x1 -= dx1 * y1;
  995.                 r2 -= dr3 * y1;
  996.                 g2 -= dg3 * y1;
  997.                 b2 -= db3 * y1;
  998.                 r1 -= dr1 * y1;
  999.                 g1 -= dg1 * y1;
  1000.                 b1 -= db1 * y1;
  1001.                 y1 = 0;
  1002.             }
  1003.             x3 <<= 16;
  1004.             r3 <<= 16;
  1005.             g3 <<= 16;
  1006.             b3 <<= 16;
  1007.             if(y3 < 0) {
  1008.                 x3 -= dx2 * y3;
  1009.                 r3 -= dr2 * y3;
  1010.                 g3 -= dg2 * y3;
  1011.                 b3 -= db2 * y3;
  1012.                 y3 = 0;
  1013.             }
  1014.             if(y1 != y3 && dx3 < dx1 || y1 == y3 && dx2 > dx1) {
  1015.                 y2 -= y3;
  1016.                 y3 -= y1;
  1017.                 for(y1 = anIntArray1472[y1]; --y3 >= 0; y1 += DrawingArea.width) {
  1018.                     drawHDGouraudScanline(DrawingArea.pixels, y1, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1);
  1019.                     x2 += dx3;
  1020.                     x1 += dx1;
  1021.                     r2 += dr3;
  1022.                     g2 += dg3;
  1023.                     b2 += db3;
  1024.                     r1 += dr1;
  1025.                     g1 += dg1;
  1026.                     b1 += db1;
  1027.                 }
  1028.                 while(--y2 >= 0) {
  1029.                     drawHDGouraudScanline(DrawingArea.pixels, y1, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1);
  1030.                     x3 += dx2;
  1031.                     x1 += dx1;
  1032.                     r3 += dr2;
  1033.                     g3 += dg2;
  1034.                     b3 += db2;
  1035.                     r1 += dr1;
  1036.                     g1 += dg1;
  1037.                     b1 += db1;
  1038.                     y1 += DrawingArea.width;
  1039.                 }
  1040.                 return;
  1041.             }
  1042.             y2 -= y3;
  1043.             y3 -= y1;
  1044.             for(y1 = anIntArray1472[y1]; --y3 >= 0; y1 += DrawingArea.width) {
  1045.                 drawHDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2);
  1046.                 x2 += dx3;
  1047.                 x1 += dx1;
  1048.                 r2 += dr3;
  1049.                 g2 += dg3;
  1050.                 b2 += db3;
  1051.                 r1 += dr1;
  1052.                 g1 += dg1;
  1053.                 b1 += db1;
  1054.             }
  1055.             while(--y2 >= 0) {
  1056.                 drawHDGouraudScanline(DrawingArea.pixels, y1, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3);
  1057.                 x3 += dx2;
  1058.                 x1 += dx1;
  1059.                 r3 += dr2;
  1060.                 g3 += dg2;
  1061.                 b3 += db2;
  1062.                 r1 += dr1;
  1063.                 g1 += dg1;
  1064.                 b1 += db1;
  1065.                 y1 += DrawingArea.width;
  1066.             }
  1067.             return;
  1068.         }
  1069.         if(y2 <= y3) {
  1070.             if(y2 >= DrawingArea.bottomY) {
  1071.                 return;
  1072.             }
  1073.             if(y3 > DrawingArea.bottomY) {
  1074.                 y3 = DrawingArea.bottomY;
  1075.             }
  1076.             if(y1 > DrawingArea.bottomY) {
  1077.                 y1 = DrawingArea.bottomY;
  1078.             }
  1079.             if(y3 < y1) {
  1080.                 x1 = x2 <<= 16;
  1081.                 r1 = r2 <<= 16;
  1082.                 g1 = g2 <<= 16;
  1083.                 b1 = b2 <<= 16;
  1084.                 if(y2 < 0) {
  1085.                     x1 -= dx1 * y2;
  1086.                     x2 -= dx2 * y2;
  1087.                     r1 -= dr1 * y2;
  1088.                     g1 -= dg1 * y2;
  1089.                     b1 -= db1 * y2;
  1090.                     r2 -= dr2 * y2;
  1091.                     g2 -= dg2 * y2;
  1092.                     b2 -= db2 * y2;
  1093.                     y2 = 0;
  1094.                 }
  1095.                 x3 <<= 16;
  1096.                 r3 <<= 16;
  1097.                 g3 <<= 16;
  1098.                 b3 <<= 16;
  1099.                 if(y3 < 0) {
  1100.                     x3 -= dx3 * y3;
  1101.                     r3 -= dr3 * y3;
  1102.                     g3 -= dg3 * y3;
  1103.                     b3 -= db3 * y3;
  1104.                     y3 = 0;
  1105.                 }
  1106.                 if(y2 != y3 && dx1 < dx2 || y2 == y3 && dx1 > dx3) {
  1107.                     y1 -= y3;
  1108.                     y3 -= y2;
  1109.                     for(y2 = anIntArray1472[y2]; --y3 >= 0; y2 += DrawingArea.width) {
  1110.                         drawHDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2);
  1111.                         x1 += dx1;
  1112.                         x2 += dx2;
  1113.                         r1 += dr1;
  1114.                         g1 += dg1;
  1115.                         b1 += db1;
  1116.                         r2 += dr2;
  1117.                         g2 += dg2;
  1118.                         b2 += db2;
  1119.                     }
  1120.                     while(--y1 >= 0) {
  1121.                         drawHDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3);
  1122.                         x1 += dx1;
  1123.                         x3 += dx3;
  1124.                         r1 += dr1;
  1125.                         g1 += dg1;
  1126.                         b1 += db1;
  1127.                         r3 += dr3;
  1128.                         g3 += dg3;
  1129.                         b3 += db3;
  1130.                         y2 += DrawingArea.width;
  1131.                     }
  1132.                     return;
  1133.                 }
  1134.                 y1 -= y3;
  1135.                 y3 -= y2;
  1136.                 for(y2 = anIntArray1472[y2]; --y3 >= 0; y2 += DrawingArea.width) {
  1137.                     drawHDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1);
  1138.                     x1 += dx1;
  1139.                     x2 += dx2;
  1140.                     r1 += dr1;
  1141.                     g1 += dg1;
  1142.                     b1 += db1;
  1143.                     r2 += dr2;
  1144.                     g2 += dg2;
  1145.                     b2 += db2;
  1146.                 }
  1147.                 while(--y1 >= 0) {
  1148.                     drawHDGouraudScanline(DrawingArea.pixels, y2, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1);
  1149.                     x1 += dx1;
  1150.                     x3 += dx3;
  1151.                     r1 += dr1;
  1152.                     g1 += dg1;
  1153.                     b1 += db1;
  1154.                     r3 += dr3;
  1155.                     g3 += dg3;
  1156.                     b3 += db3;
  1157.                     y2 += DrawingArea.width;
  1158.                 }
  1159.                 return;
  1160.             }
  1161.             x3 = x2 <<= 16;
  1162.             r3 = r2 <<= 16;
  1163.             g3 = g2 <<= 16;
  1164.             b3 = b2 <<= 16;
  1165.             if(y2 < 0) {
  1166.                 x3 -= dx1 * y2;
  1167.                 x2 -= dx2 * y2;
  1168.                 r3 -= dr1 * y2;
  1169.                 g3 -= dg1 * y2;
  1170.                 b3 -= db1 * y2;
  1171.                 r2 -= dr2 * y2;
  1172.                 g2 -= dg2 * y2;
  1173.                 b2 -= db2 * y2;
  1174.                 y2 = 0;
  1175.             }
  1176.             x1 <<= 16;
  1177.             r1 <<= 16;
  1178.             g1 <<= 16;
  1179.             b1 <<= 16;
  1180.             if(y1 < 0) {
  1181.                 x1 -= dx3 * y1;
  1182.                 r1 -= dr3 * y1;
  1183.                 g1 -= dg3 * y1;
  1184.                 b1 -= db3 * y1;
  1185.                 y1 = 0;
  1186.             }
  1187.             if(dx1 < dx2) {
  1188.                 y3 -= y1;
  1189.                 y1 -= y2;
  1190.                 for(y2 = anIntArray1472[y2]; --y1 >= 0; y2 += DrawingArea.width) {
  1191.                     drawHDGouraudScanline(DrawingArea.pixels, y2, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2);
  1192.                     x3 += dx1;
  1193.                     x2 += dx2;
  1194.                     r3 += dr1;
  1195.                     g3 += dg1;
  1196.                     b3 += db1;
  1197.                     r2 += dr2;
  1198.                     g2 += dg2;
  1199.                     b2 += db2;
  1200.                 }
  1201.                 while(--y3 >= 0) {
  1202.                     drawHDGouraudScanline(DrawingArea.pixels, y2, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2);
  1203.                     x1 += dx3;
  1204.                     x2 += dx2;
  1205.                     r1 += dr3;
  1206.                     g1 += dg3;
  1207.                     b1 += db3;
  1208.                     r2 += dr2;
  1209.                     g2 += dg2;
  1210.                     b2 += db2;
  1211.                     y2 += DrawingArea.width;
  1212.                 }
  1213.                 return;
  1214.             }
  1215.             y3 -= y1;
  1216.             y1 -= y2;
  1217.             for(y2 = anIntArray1472[y2]; --y1 >= 0; y2 += DrawingArea.width) {
  1218.                 drawHDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3);
  1219.                 x3 += dx1;
  1220.                 x2 += dx2;
  1221.                 r3 += dr1;
  1222.                 g3 += dg1;
  1223.                 b3 += db1;
  1224.                 r2 += dr2;
  1225.                 g2 += dg2;
  1226.                 b2 += db2;
  1227.             }
  1228.             while(--y3 >= 0) {
  1229.                 drawHDGouraudScanline(DrawingArea.pixels, y2, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1);
  1230.                 x1 += dx3;
  1231.                 x2 += dx2;
  1232.                 r1 += dr3;
  1233.                 g1 += dg3;
  1234.                 b1 += db3;
  1235.                 r2 += dr2;
  1236.                 g2 += dg2;
  1237.                 b2 += db2;
  1238.                 y2 += DrawingArea.width;
  1239.             }
  1240.             return;
  1241.         }
  1242.         if(y3 >= DrawingArea.bottomY) {
  1243.             return;
  1244.         }
  1245.         if(y1 > DrawingArea.bottomY) {
  1246.             y1 = DrawingArea.bottomY;
  1247.         }
  1248.         if(y2 > DrawingArea.bottomY) {
  1249.             y2 = DrawingArea.bottomY;
  1250.         }
  1251.         if(y1 < y2) {
  1252.             x2 = x3 <<= 16;
  1253.             r2 = r3 <<= 16;
  1254.             g2 = g3 <<= 16;
  1255.             b2 = b3 <<= 16;
  1256.             if(y3 < 0) {
  1257.                 x2 -= dx2 * y3;
  1258.                 x3 -= dx3 * y3;
  1259.                 r2 -= dr2 * y3;
  1260.                 g2 -= dg2 * y3;
  1261.                 b2 -= db2 * y3;
  1262.                 r3 -= dr3 * y3;
  1263.                 g3 -= dg3 * y3;
  1264.                 b3 -= db3 * y3;
  1265.                 y3 = 0;
  1266.             }
  1267.             x1 <<= 16;
  1268.             r1 <<= 16;
  1269.             g1 <<= 16;
  1270.             b1 <<= 16;
  1271.             if(y1 < 0) {
  1272.                 x1 -= dx1 * y1;
  1273.                 r1 -= dr1 * y1;
  1274.                 g1 -= dg1 * y1;
  1275.                 b1 -= db1 * y1;
  1276.                 y1 = 0;
  1277.             }
  1278.             if(dx2 < dx3) {
  1279.                 y2 -= y1;
  1280.                 y1 -= y3;
  1281.                 for(y3 = anIntArray1472[y3]; --y1 >= 0; y3 += DrawingArea.width) {
  1282.                     drawHDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3);
  1283.                     x2 += dx2;
  1284.                     x3 += dx3;
  1285.                     r2 += dr2;
  1286.                     g2 += dg2;
  1287.                     b2 += db2;
  1288.                     r3 += dr3;
  1289.                     g3 += dg3;
  1290.                     b3 += db3;
  1291.                 }
  1292.                 while(--y2 >= 0) {
  1293.                     drawHDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x1 >> 16, r2, g2, b2, r1, g1, b1);
  1294.                     x2 += dx2;
  1295.                     x1 += dx1;
  1296.                     r2 += dr2;
  1297.                     g2 += dg2;
  1298.                     b2 += db2;
  1299.                     r1 += dr1;
  1300.                     g1 += dg1;
  1301.                     b1 += db1;
  1302.                     y3 += DrawingArea.width;
  1303.                 }
  1304.                 return;
  1305.             }
  1306.             y2 -= y1;
  1307.             y1 -= y3;
  1308.             for(y3 = anIntArray1472[y3]; --y1 >= 0; y3 += DrawingArea.width) {
  1309.                 drawHDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2);
  1310.                 x2 += dx2;
  1311.                 x3 += dx3;
  1312.                 r2 += dr2;
  1313.                 g2 += dg2;
  1314.                 b2 += db2;
  1315.                 r3 += dr3;
  1316.                 g3 += dg3;
  1317.                 b3 += db3;
  1318.             }
  1319.             while(--y2 >= 0) {
  1320.                 drawHDGouraudScanline(DrawingArea.pixels, y3, x1 >> 16, x2 >> 16, r1, g1, b1, r2, g2, b2);
  1321.                 x2 += dx2;
  1322.                 x1 += dx1;
  1323.                 r2 += dr2;
  1324.                 g2 += dg2;
  1325.                 b2 += db2;
  1326.                 r1 += dr1;
  1327.                 g1 += dg1;
  1328.                 b1 += db1;
  1329.                 y3 += DrawingArea.width;
  1330.             }
  1331.             return;
  1332.         }
  1333.         x1 = x3 <<= 16;
  1334.         r1 = r3 <<= 16;
  1335.         g1 = g3 <<= 16;
  1336.         b1 = b3 <<= 16;
  1337.         if(y3 < 0) {
  1338.             x1 -= dx2 * y3;
  1339.             x3 -= dx3 * y3;
  1340.             r1 -= dr2 * y3;
  1341.             g1 -= dg2 * y3;
  1342.             b1 -= db2 * y3;
  1343.             r3 -= dr3 * y3;
  1344.             g3 -= dg3 * y3;
  1345.             b3 -= db3 * y3;
  1346.             y3 = 0;
  1347.         }
  1348.         x2 <<= 16;
  1349.         r2 <<= 16;
  1350.         g2 <<= 16;
  1351.         b2 <<= 16;
  1352.         if(y2 < 0) {
  1353.             x2 -= dx1 * y2;
  1354.             r2 -= dr1 * y2;
  1355.             g2 -= dg1 * y2;
  1356.             b2 -= db1 * y2;
  1357.             y2 = 0;
  1358.         }
  1359.         if(dx2 < dx3) {
  1360.             y1 -= y2;
  1361.             y2 -= y3;
  1362.             for(y3 = anIntArray1472[y3]; --y2 >= 0; y3 += DrawingArea.width) {
  1363.                 drawHDGouraudScanline(DrawingArea.pixels, y3, x1 >> 16, x3 >> 16, r1, g1, b1, r3, g3, b3);
  1364.                 x1 += dx2;
  1365.                 x3 += dx3;
  1366.                 r1 += dr2;
  1367.                 g1 += dg2;
  1368.                 b1 += db2;
  1369.                 r3 += dr3;
  1370.                 g3 += dg3;
  1371.                 b3 += db3;
  1372.             }
  1373.             while(--y1 >= 0) {
  1374.                 drawHDGouraudScanline(DrawingArea.pixels, y3, x2 >> 16, x3 >> 16, r2, g2, b2, r3, g3, b3);
  1375.                 x2 += dx1;
  1376.                 x3 += dx3;
  1377.                 r2 += dr1;
  1378.                 g2 += dg1;
  1379.                 b2 += db1;
  1380.                 r3 += dr3;
  1381.                 g3 += dg3;
  1382.                 b3 += db3;
  1383.                 y3 += DrawingArea.width;
  1384.             }
  1385.             return;
  1386.         }
  1387.         y1 -= y2;
  1388.         y2 -= y3;
  1389.         for(y3 = anIntArray1472[y3]; --y2 >= 0; y3 += DrawingArea.width) {
  1390.             drawHDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x1 >> 16, r3, g3, b3, r1, g1, b1);
  1391.             x1 += dx2;
  1392.             x3 += dx3;
  1393.             r1 += dr2;
  1394.             g1 += dg2;
  1395.             b1 += db2;
  1396.             r3 += dr3;
  1397.             g3 += dg3;
  1398.             b3 += db3;
  1399.         }
  1400.         while(--y1 >= 0) {
  1401.             drawHDGouraudScanline(DrawingArea.pixels, y3, x3 >> 16, x2 >> 16, r3, g3, b3, r2, g2, b2);
  1402.             x2 += dx1;
  1403.             x3 += dx3;
  1404.             r2 += dr1;
  1405.             g2 += dg1;
  1406.             b2 += db1;
  1407.             r3 += dr3;
  1408.             g3 += dg3;
  1409.             b3 += db3;
  1410.             y3 += DrawingArea.width;
  1411.         }
  1412.     }
  1413.  
  1414.    
  1415.     public static void drawHDGouraudScanline(int[] dest, int offset, int x1, int x2, int r1, int g1, int b1, int r2, int g2, int b2) {
  1416.         int n = x2 - x1;
  1417.         if (n <= 0) {
  1418.             return;
  1419.         }
  1420.         r2 = (r2 - r1) / n;
  1421.         g2 = (g2 - g1) / n;
  1422.         b2 = (b2 - b1) / n;
  1423.         if (aBoolean1462) {
  1424.             if (x2 > DrawingArea.centerX) {
  1425.                 n -= x2 - DrawingArea.centerX;
  1426.                 x2 = DrawingArea.centerX;
  1427.             }
  1428.             if (x1 < 0) {
  1429.                 n = x2;
  1430.                 r1 -= x1 * r2;
  1431.                 g1 -= x1 * g2;
  1432.                 b1 -= x1 * b2;
  1433.                 x1 = 0;
  1434.             }
  1435.         }
  1436.         if (x1 < x2) {
  1437.             offset += x1;
  1438.             if (anInt1465 == 0) {
  1439.                 while (--n >= 0) {
  1440.                     dest[offset] = (r1 & 0xff0000) | (g1 >> 8 & 0xff00) | (b1 >> 16 & 0xff);
  1441.                     r1 += r2;
  1442.                     g1 += g2;
  1443.                     b1 += b2;
  1444.                     offset++;
  1445.                 }
  1446.             } else {
  1447.                 final int a1 = anInt1465;
  1448.                 final int a2 = 256 - anInt1465;
  1449.                 int rgb;
  1450.                 int dst;
  1451.                 while (--n >= 0) {
  1452.                     rgb = (r1 & 0xff0000) | (g1 >> 8 & 0xff00) | (b1 >> 16 & 0xff);
  1453.                     rgb = ((rgb & 0xff00ff) * a2 >> 8 & 0xff00ff) + ((rgb & 0xff00) * a2 >> 8 & 0xff00);
  1454.                     dst = dest[offset];
  1455.                     dest[offset] = rgb + ((dst & 0xff00ff) * a1 >> 8 & 0xff00ff) + ((dst & 0xff00) * a1 >> 8 & 0xff00);
  1456.                     r1 += r2;
  1457.                     g1 += g2;
  1458.                     b1 += b2;
  1459.                     offset++;
  1460.                 }
  1461.             }
  1462.         }
  1463.     }
  1464.  
  1465.     public static void method376(int i, int j, int k, int l, int i1, int j1, int k1)
  1466.     {
  1467.         int l1 = 0;
  1468.         if(j != i)
  1469.             l1 = (i1 - l << 16) / (j - i);
  1470.         int i2 = 0;
  1471.         if(k != j)
  1472.             i2 = (j1 - i1 << 16) / (k - j);
  1473.         int j2 = 0;
  1474.         if(k != i)
  1475.             j2 = (l - j1 << 16) / (i - k);
  1476.         if(i <= j && i <= k)
  1477.         {
  1478.             if(i >= DrawingArea.bottomY)
  1479.                 return;
  1480.             if(j > DrawingArea.bottomY)
  1481.                 j = DrawingArea.bottomY;
  1482.             if(k > DrawingArea.bottomY)
  1483.                 k = DrawingArea.bottomY;
  1484.             if(j < k)
  1485.             {
  1486.                 j1 = l <<= 16;
  1487.                 if(i < 0)
  1488.                 {
  1489.                     j1 -= j2 * i;
  1490.                     l -= l1 * i;
  1491.                     i = 0;
  1492.                 }
  1493.                 i1 <<= 16;
  1494.                 if(j < 0)
  1495.                 {
  1496.                     i1 -= i2 * j;
  1497.                     j = 0;
  1498.                 }
  1499.                 if(i != j && j2 < l1 || i == j && j2 > i2)
  1500.                 {
  1501.                     k -= j;
  1502.                     j -= i;
  1503.                     for(i = anIntArray1472[i]; --j >= 0; i += DrawingArea.width)
  1504.                     {
  1505.                         method377(DrawingArea.pixels, i, k1, j1 >> 16, l >> 16);
  1506.                         j1 += j2;
  1507.                         l += l1;
  1508.                     }
  1509.  
  1510.                     while(--k >= 0)
  1511.                     {
  1512.                         method377(DrawingArea.pixels, i, k1, j1 >> 16, i1 >> 16);
  1513.                         j1 += j2;
  1514.                         i1 += i2;
  1515.                         i += DrawingArea.width;
  1516.                     }
  1517.                     return;
  1518.                 }
  1519.                 k -= j;
  1520.                 j -= i;
  1521.                 for(i = anIntArray1472[i]; --j >= 0; i += DrawingArea.width)
  1522.                 {
  1523.                     method377(DrawingArea.pixels, i, k1, l >> 16, j1 >> 16);
  1524.                     j1 += j2;
  1525.                     l += l1;
  1526.                 }
  1527.  
  1528.                 while(--k >= 0)
  1529.                 {
  1530.                     method377(DrawingArea.pixels, i, k1, i1 >> 16, j1 >> 16);
  1531.                     j1 += j2;
  1532.                     i1 += i2;
  1533.                     i += DrawingArea.width;
  1534.                 }
  1535.                 return;
  1536.             }
  1537.             i1 = l <<= 16;
  1538.             if(i < 0)
  1539.             {
  1540.                 i1 -= j2 * i;
  1541.                 l -= l1 * i;
  1542.                 i = 0;
  1543.             }
  1544.             j1 <<= 16;
  1545.             if(k < 0)
  1546.             {
  1547.                 j1 -= i2 * k;
  1548.                 k = 0;
  1549.             }
  1550.             if(i != k && j2 < l1 || i == k && i2 > l1)
  1551.             {
  1552.                 j -= k;
  1553.                 k -= i;
  1554.                 for(i = anIntArray1472[i]; --k >= 0; i += DrawingArea.width)
  1555.                 {
  1556.                     method377(DrawingArea.pixels, i, k1, i1 >> 16, l >> 16);
  1557.                     i1 += j2;
  1558.                     l += l1;
  1559.                 }
  1560.  
  1561.                 while(--j >= 0)
  1562.                 {
  1563.                     method377(DrawingArea.pixels, i, k1, j1 >> 16, l >> 16);
  1564.                     j1 += i2;
  1565.                     l += l1;
  1566.                     i += DrawingArea.width;
  1567.                 }
  1568.                 return;
  1569.             }
  1570.             j -= k;
  1571.             k -= i;
  1572.             for(i = anIntArray1472[i]; --k >= 0; i += DrawingArea.width)
  1573.             {
  1574.                 method377(DrawingArea.pixels, i, k1, l >> 16, i1 >> 16);
  1575.                 i1 += j2;
  1576.                 l += l1;
  1577.             }
  1578.  
  1579.             while(--j >= 0)
  1580.             {
  1581.                 method377(DrawingArea.pixels, i, k1, l >> 16, j1 >> 16);
  1582.                 j1 += i2;
  1583.                 l += l1;
  1584.                 i += DrawingArea.width;
  1585.             }
  1586.             return;
  1587.         }
  1588.         if(j <= k)
  1589.         {
  1590.             if(j >= DrawingArea.bottomY)
  1591.                 return;
  1592.             if(k > DrawingArea.bottomY)
  1593.                 k = DrawingArea.bottomY;
  1594.             if(i > DrawingArea.bottomY)
  1595.                 i = DrawingArea.bottomY;
  1596.             if(k < i)
  1597.             {
  1598.                 l = i1 <<= 16;
  1599.                 if(j < 0)
  1600.                 {
  1601.                     l -= l1 * j;
  1602.                     i1 -= i2 * j;
  1603.                     j = 0;
  1604.                 }
  1605.                 j1 <<= 16;
  1606.                 if(k < 0)
  1607.                 {
  1608.                     j1 -= j2 * k;
  1609.                     k = 0;
  1610.                 }
  1611.                 if(j != k && l1 < i2 || j == k && l1 > j2)
  1612.                 {
  1613.                     i -= k;
  1614.                     k -= j;
  1615.                     for(j = anIntArray1472[j]; --k >= 0; j += DrawingArea.width)
  1616.                     {
  1617.                         method377(DrawingArea.pixels, j, k1, l >> 16, i1 >> 16);
  1618.                         l += l1;
  1619.                         i1 += i2;
  1620.                     }
  1621.  
  1622.                     while(--i >= 0)
  1623.                     {
  1624.                         method377(DrawingArea.pixels, j, k1, l >> 16, j1 >> 16);
  1625.                         l += l1;
  1626.                         j1 += j2;
  1627.                         j += DrawingArea.width;
  1628.                     }
  1629.                     return;
  1630.                 }
  1631.                 i -= k;
  1632.                 k -= j;
  1633.                 for(j = anIntArray1472[j]; --k >= 0; j += DrawingArea.width)
  1634.                 {
  1635.                     method377(DrawingArea.pixels, j, k1, i1 >> 16, l >> 16);
  1636.                     l += l1;
  1637.                     i1 += i2;
  1638.                 }
  1639.  
  1640.                 while(--i >= 0)
  1641.                 {
  1642.                     method377(DrawingArea.pixels, j, k1, j1 >> 16, l >> 16);
  1643.                     l += l1;
  1644.                     j1 += j2;
  1645.                     j += DrawingArea.width;
  1646.                 }
  1647.                 return;
  1648.             }
  1649.             j1 = i1 <<= 16;
  1650.             if(j < 0)
  1651.             {
  1652.                 j1 -= l1 * j;
  1653.                 i1 -= i2 * j;
  1654.                 j = 0;
  1655.             }
  1656.             l <<= 16;
  1657.             if(i < 0)
  1658.             {
  1659.                 l -= j2 * i;
  1660.                 i = 0;
  1661.             }
  1662.             if(l1 < i2)
  1663.             {
  1664.                 k -= i;
  1665.                 i -= j;
  1666.                 for(j = anIntArray1472[j]; --i >= 0; j += DrawingArea.width)
  1667.                 {
  1668.                     method377(DrawingArea.pixels, j, k1, j1 >> 16, i1 >> 16);
  1669.                     j1 += l1;
  1670.                     i1 += i2;
  1671.                 }
  1672.  
  1673.                 while(--k >= 0)
  1674.                 {
  1675.                     method377(DrawingArea.pixels, j, k1, l >> 16, i1 >> 16);
  1676.                     l += j2;
  1677.                     i1 += i2;
  1678.                     j += DrawingArea.width;
  1679.                 }
  1680.                 return;
  1681.             }
  1682.             k -= i;
  1683.             i -= j;
  1684.             for(j = anIntArray1472[j]; --i >= 0; j += DrawingArea.width)
  1685.             {
  1686.                 method377(DrawingArea.pixels, j, k1, i1 >> 16, j1 >> 16);
  1687.                 j1 += l1;
  1688.                 i1 += i2;
  1689.             }
  1690.  
  1691.             while(--k >= 0)
  1692.             {
  1693.                 method377(DrawingArea.pixels, j, k1, i1 >> 16, l >> 16);
  1694.                 l += j2;
  1695.                 i1 += i2;
  1696.                 j += DrawingArea.width;
  1697.             }
  1698.             return;
  1699.         }
  1700.         if(k >= DrawingArea.bottomY)
  1701.             return;
  1702.         if(i > DrawingArea.bottomY)
  1703.             i = DrawingArea.bottomY;
  1704.         if(j > DrawingArea.bottomY)
  1705.             j = DrawingArea.bottomY;
  1706.         if(i < j)
  1707.         {
  1708.             i1 = j1 <<= 16;
  1709.             if(k < 0)
  1710.             {
  1711.                 i1 -= i2 * k;
  1712.                 j1 -= j2 * k;
  1713.                 k = 0;
  1714.             }
  1715.             l <<= 16;
  1716.             if(i < 0)
  1717.             {
  1718.                 l -= l1 * i;
  1719.                 i = 0;
  1720.             }
  1721.             if(i2 < j2)
  1722.             {
  1723.                 j -= i;
  1724.                 i -= k;
  1725.                 for(k = anIntArray1472[k]; --i >= 0; k += DrawingArea.width)
  1726.                 {
  1727.                     method377(DrawingArea.pixels, k, k1, i1 >> 16, j1 >> 16);
  1728.                     i1 += i2;
  1729.                     j1 += j2;
  1730.                 }
  1731.  
  1732.                 while(--j >= 0)
  1733.                 {
  1734.                     method377(DrawingArea.pixels, k, k1, i1 >> 16, l >> 16);
  1735.                     i1 += i2;
  1736.                     l += l1;
  1737.                     k += DrawingArea.width;
  1738.                 }
  1739.                 return;
  1740.             }
  1741.             j -= i;
  1742.             i -= k;
  1743.             for(k = anIntArray1472[k]; --i >= 0; k += DrawingArea.width)
  1744.             {
  1745.                 method377(DrawingArea.pixels, k, k1, j1 >> 16, i1 >> 16);
  1746.                 i1 += i2;
  1747.                 j1 += j2;
  1748.             }
  1749.  
  1750.             while(--j >= 0)
  1751.             {
  1752.                 method377(DrawingArea.pixels, k, k1, l >> 16, i1 >> 16);
  1753.                 i1 += i2;
  1754.                 l += l1;
  1755.                 k += DrawingArea.width;
  1756.             }
  1757.             return;
  1758.         }
  1759.         l = j1 <<= 16;
  1760.         if(k < 0)
  1761.         {
  1762.             l -= i2 * k;
  1763.             j1 -= j2 * k;
  1764.             k = 0;
  1765.         }
  1766.         i1 <<= 16;
  1767.         if(j < 0)
  1768.         {
  1769.             i1 -= l1 * j;
  1770.             j = 0;
  1771.         }
  1772.         if(i2 < j2)
  1773.         {
  1774.             i -= j;
  1775.             j -= k;
  1776.             for(k = anIntArray1472[k]; --j >= 0; k += DrawingArea.width)
  1777.             {
  1778.                 method377(DrawingArea.pixels, k, k1, l >> 16, j1 >> 16);
  1779.                 l += i2;
  1780.                 j1 += j2;
  1781.             }
  1782.  
  1783.             while(--i >= 0)
  1784.             {
  1785.                 method377(DrawingArea.pixels, k, k1, i1 >> 16, j1 >> 16);
  1786.                 i1 += l1;
  1787.                 j1 += j2;
  1788.                 k += DrawingArea.width;
  1789.             }
  1790.             return;
  1791.         }
  1792.         i -= j;
  1793.         j -= k;
  1794.         for(k = anIntArray1472[k]; --j >= 0; k += DrawingArea.width)
  1795.         {
  1796.             method377(DrawingArea.pixels, k, k1, j1 >> 16, l >> 16);
  1797.             l += i2;
  1798.             j1 += j2;
  1799.         }
  1800.  
  1801.         while(--i >= 0)
  1802.         {
  1803.             method377(DrawingArea.pixels, k, k1, j1 >> 16, i1 >> 16);
  1804.             i1 += l1;
  1805.             j1 += j2;
  1806.             k += DrawingArea.width;
  1807.         }
  1808.     }
  1809.  
  1810.     private static void method377(int ai[], int i, int j, int l, int i1)
  1811.     {
  1812.         int k;//was parameter
  1813.         if(aBoolean1462)
  1814.         {
  1815.             if(i1 > DrawingArea.centerX)
  1816.                 i1 = DrawingArea.centerX;
  1817.             if(l < 0)
  1818.                 l = 0;
  1819.         }
  1820.         if(l >= i1)
  1821.             return;
  1822.         i += l;
  1823.         k = i1 - l >> 2;
  1824.         if(anInt1465 == 0)
  1825.         {
  1826.             while(--k >= 0)
  1827.             {
  1828.                 ai[i++] = j;
  1829.                 ai[i++] = j;
  1830.                 ai[i++] = j;
  1831.                 ai[i++] = j;
  1832.             }
  1833.             for(k = i1 - l & 3; --k >= 0;)
  1834.                 ai[i++] = j;
  1835.  
  1836.             return;
  1837.         }
  1838.         int j1 = anInt1465;
  1839.         int k1 = 256 - anInt1465;
  1840.         j = ((j & 0xff00ff) * k1 >> 8 & 0xff00ff) + ((j & 0xff00) * k1 >> 8 & 0xff00);
  1841.         while(--k >= 0)
  1842.         {
  1843.             ai[i++] = j + ((ai[i] & 0xff00ff) * j1 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j1 >> 8 & 0xff00);
  1844.             ai[i++] = j + ((ai[i] & 0xff00ff) * j1 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j1 >> 8 & 0xff00);
  1845.             ai[i++] = j + ((ai[i] & 0xff00ff) * j1 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j1 >> 8 & 0xff00);
  1846.             ai[i++] = j + ((ai[i] & 0xff00ff) * j1 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j1 >> 8 & 0xff00);
  1847.         }
  1848.         for(k = i1 - l & 3; --k >= 0;)
  1849.             ai[i++] = j + ((ai[i] & 0xff00ff) * j1 >> 8 & 0xff00ff) + ((ai[i] & 0xff00) * j1 >> 8 & 0xff00);
  1850.  
  1851.     }
  1852.    
  1853.     public static void method378(int i, int j, int k, int l, int i1, int j1, int k1, int l1,
  1854.             int i2, int j2, int k2, int l2, int i3, int j3, int k3,
  1855.             int l3, int i4, int j4, int k4) {
  1856.         if (smoothShading && aBoolean1464) {
  1857.             drawHDTexturedTriangle(i, j, k, l, i1, j1, k1, l1, i2, j2, k2, l2, i3, j3, k3, l3, i4, j4, k4);
  1858.         } else {
  1859.             drawLDTexturedTriangle(i, j, k, l, i1, j1, k1, l1, i2, j2, k2, l2, i3, j3, k3, l3, i4, j4, k4);
  1860.         }
  1861.     }
  1862.  
  1863.     public static void drawLDTexturedTriangle(int i, int j, int k, int l, int i1, int j1, int k1, int l1,
  1864.             int i2, int j2, int k2, int l2, int i3, int j3, int k3,
  1865.             int l3, int i4, int j4, int k4)
  1866.     {
  1867.         int ai[] = method371(k4);
  1868.         aBoolean1463 = !aBooleanArray1475[k4];
  1869.         k2 = j2 - k2;
  1870.         j3 = i3 - j3;
  1871.         i4 = l3 - i4;
  1872.         l2 -= j2;
  1873.         k3 -= i3;
  1874.         j4 -= l3;
  1875.         int l4 = l2 * i3 - k3 * j2 << 14;
  1876.         int i5 = k3 * l3 - j4 * i3 << 8;
  1877.         int j5 = j4 * j2 - l2 * l3 << 5;
  1878.         int k5 = k2 * i3 - j3 * j2 << 14;
  1879.         int l5 = j3 * l3 - i4 * i3 << 8;
  1880.         int i6 = i4 * j2 - k2 * l3 << 5;
  1881.         int j6 = j3 * l2 - k2 * k3 << 14;
  1882.         int k6 = i4 * k3 - j3 * j4 << 8;
  1883.         int l6 = k2 * j4 - i4 * l2 << 5;
  1884.         int i7 = 0;
  1885.         int j7 = 0;
  1886.         if(j != i)
  1887.         {
  1888.             i7 = (i1 - l << 16) / (j - i);
  1889.             j7 = (l1 - k1 << 16) / (j - i);
  1890.         }
  1891.         int k7 = 0;
  1892.         int l7 = 0;
  1893.         if(k != j)
  1894.         {
  1895.             k7 = (j1 - i1 << 16) / (k - j);
  1896.             l7 = (i2 - l1 << 16) / (k - j);
  1897.         }
  1898.         int i8 = 0;
  1899.         int j8 = 0;
  1900.         if(k != i)
  1901.         {
  1902.             i8 = (l - j1 << 16) / (i - k);
  1903.             j8 = (k1 - i2 << 16) / (i - k);
  1904.         }
  1905.         if(i <= j && i <= k)
  1906.         {
  1907.             if(i >= DrawingArea.bottomY)
  1908.                 return;
  1909.             if(j > DrawingArea.bottomY)
  1910.                 j = DrawingArea.bottomY;
  1911.             if(k > DrawingArea.bottomY)
  1912.                 k = DrawingArea.bottomY;
  1913.             if(j < k)
  1914.             {
  1915.                 j1 = l <<= 16;
  1916.                 i2 = k1 <<= 16;
  1917.                 if(i < 0)
  1918.                 {
  1919.                     j1 -= i8 * i;
  1920.                     l -= i7 * i;
  1921.                     i2 -= j8 * i;
  1922.                     k1 -= j7 * i;
  1923.                     i = 0;
  1924.                 }
  1925.                 i1 <<= 16;
  1926.                 l1 <<= 16;
  1927.                 if(j < 0)
  1928.                 {
  1929.                     i1 -= k7 * j;
  1930.                     l1 -= l7 * j;
  1931.                     j = 0;
  1932.                 }
  1933.                 int k8 = i - textureInt2;
  1934.                 l4 += j5 * k8;
  1935.                 k5 += i6 * k8;
  1936.                 j6 += l6 * k8;
  1937.                 if(i != j && i8 < i7 || i == j && i8 > k7)
  1938.                 {
  1939.                     k -= j;
  1940.                     j -= i;
  1941.                     i = anIntArray1472[i];
  1942.                     while(--j >= 0)
  1943.                     {
  1944.                         drawLDTexturedScanline(DrawingArea.pixels, ai, i, j1 >> 16, l >> 16, i2 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  1945.                         j1 += i8;
  1946.                         l += i7;
  1947.                         i2 += j8;
  1948.                         k1 += j7;
  1949.                         i += DrawingArea.width;
  1950.                         l4 += j5;
  1951.                         k5 += i6;
  1952.                         j6 += l6;
  1953.                     }
  1954.                     while(--k >= 0)
  1955.                     {
  1956.                         drawLDTexturedScanline(DrawingArea.pixels, ai, i, j1 >> 16, i1 >> 16, i2 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  1957.                         j1 += i8;
  1958.                         i1 += k7;
  1959.                         i2 += j8;
  1960.                         l1 += l7;
  1961.                         i += DrawingArea.width;
  1962.                         l4 += j5;
  1963.                         k5 += i6;
  1964.                         j6 += l6;
  1965.                     }
  1966.                     return;
  1967.                 }
  1968.                 k -= j;
  1969.                 j -= i;
  1970.                 i = anIntArray1472[i];
  1971.                 while(--j >= 0)
  1972.                 {
  1973.                     drawLDTexturedScanline(DrawingArea.pixels, ai, i, l >> 16, j1 >> 16, k1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  1974.                     j1 += i8;
  1975.                     l += i7;
  1976.                     i2 += j8;
  1977.                     k1 += j7;
  1978.                     i += DrawingArea.width;
  1979.                     l4 += j5;
  1980.                     k5 += i6;
  1981.                     j6 += l6;
  1982.                 }
  1983.                 while(--k >= 0)
  1984.                 {
  1985.                     drawLDTexturedScanline(DrawingArea.pixels, ai, i, i1 >> 16, j1 >> 16, l1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  1986.                     j1 += i8;
  1987.                     i1 += k7;
  1988.                     i2 += j8;
  1989.                     l1 += l7;
  1990.                     i += DrawingArea.width;
  1991.                     l4 += j5;
  1992.                     k5 += i6;
  1993.                     j6 += l6;
  1994.                 }
  1995.                 return;
  1996.             }
  1997.             i1 = l <<= 16;
  1998.             l1 = k1 <<= 16;
  1999.             if(i < 0)
  2000.             {
  2001.                 i1 -= i8 * i;
  2002.                 l -= i7 * i;
  2003.                 l1 -= j8 * i;
  2004.                 k1 -= j7 * i;
  2005.                 i = 0;
  2006.             }
  2007.             j1 <<= 16;
  2008.             i2 <<= 16;
  2009.             if(k < 0)
  2010.             {
  2011.                 j1 -= k7 * k;
  2012.                 i2 -= l7 * k;
  2013.                 k = 0;
  2014.             }
  2015.             int l8 = i - textureInt2;
  2016.             l4 += j5 * l8;
  2017.             k5 += i6 * l8;
  2018.             j6 += l6 * l8;
  2019.             if(i != k && i8 < i7 || i == k && k7 > i7)
  2020.             {
  2021.                 j -= k;
  2022.                 k -= i;
  2023.                 i = anIntArray1472[i];
  2024.                 while(--k >= 0)
  2025.                 {
  2026.                     drawLDTexturedScanline(DrawingArea.pixels, ai, i, i1 >> 16, l >> 16, l1 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2027.                     i1 += i8;
  2028.                     l += i7;
  2029.                     l1 += j8;
  2030.                     k1 += j7;
  2031.                     i += DrawingArea.width;
  2032.                     l4 += j5;
  2033.                     k5 += i6;
  2034.                     j6 += l6;
  2035.                 }
  2036.                 while(--j >= 0)
  2037.                 {
  2038.                     drawLDTexturedScanline(DrawingArea.pixels, ai, i, j1 >> 16, l >> 16, i2 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2039.                     j1 += k7;
  2040.                     l += i7;
  2041.                     i2 += l7;
  2042.                     k1 += j7;
  2043.                     i += DrawingArea.width;
  2044.                     l4 += j5;
  2045.                     k5 += i6;
  2046.                     j6 += l6;
  2047.                 }
  2048.                 return;
  2049.             }
  2050.             j -= k;
  2051.             k -= i;
  2052.             i = anIntArray1472[i];
  2053.             while(--k >= 0)
  2054.             {
  2055.                 drawLDTexturedScanline(DrawingArea.pixels, ai, i, l >> 16, i1 >> 16, k1 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2056.                 i1 += i8;
  2057.                 l += i7;
  2058.                 l1 += j8;
  2059.                 k1 += j7;
  2060.                 i += DrawingArea.width;
  2061.                 l4 += j5;
  2062.                 k5 += i6;
  2063.                 j6 += l6;
  2064.             }
  2065.             while(--j >= 0)
  2066.             {
  2067.                 drawLDTexturedScanline(DrawingArea.pixels, ai, i, l >> 16, j1 >> 16, k1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2068.                 j1 += k7;
  2069.                 l += i7;
  2070.                 i2 += l7;
  2071.                 k1 += j7;
  2072.                 i += DrawingArea.width;
  2073.                 l4 += j5;
  2074.                 k5 += i6;
  2075.                 j6 += l6;
  2076.             }
  2077.             return;
  2078.         }
  2079.         if(j <= k)
  2080.         {
  2081.             if(j >= DrawingArea.bottomY)
  2082.                 return;
  2083.             if(k > DrawingArea.bottomY)
  2084.                 k = DrawingArea.bottomY;
  2085.             if(i > DrawingArea.bottomY)
  2086.                 i = DrawingArea.bottomY;
  2087.             if(k < i)
  2088.             {
  2089.                 l = i1 <<= 16;
  2090.                 k1 = l1 <<= 16;
  2091.                 if(j < 0)
  2092.                 {
  2093.                     l -= i7 * j;
  2094.                     i1 -= k7 * j;
  2095.                     k1 -= j7 * j;
  2096.                     l1 -= l7 * j;
  2097.                     j = 0;
  2098.                 }
  2099.                 j1 <<= 16;
  2100.                 i2 <<= 16;
  2101.                 if(k < 0)
  2102.                 {
  2103.                     j1 -= i8 * k;
  2104.                     i2 -= j8 * k;
  2105.                     k = 0;
  2106.                 }
  2107.                 int i9 = j - textureInt2;
  2108.                 l4 += j5 * i9;
  2109.                 k5 += i6 * i9;
  2110.                 j6 += l6 * i9;
  2111.                 if(j != k && i7 < k7 || j == k && i7 > i8)
  2112.                 {
  2113.                     i -= k;
  2114.                     k -= j;
  2115.                     j = anIntArray1472[j];
  2116.                     while(--k >= 0)
  2117.                     {
  2118.                         drawLDTexturedScanline(DrawingArea.pixels, ai, j, l >> 16, i1 >> 16, k1 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2119.                         l += i7;
  2120.                         i1 += k7;
  2121.                         k1 += j7;
  2122.                         l1 += l7;
  2123.                         j += DrawingArea.width;
  2124.                         l4 += j5;
  2125.                         k5 += i6;
  2126.                         j6 += l6;
  2127.                     }
  2128.                     while(--i >= 0)
  2129.                     {
  2130.                         drawLDTexturedScanline(DrawingArea.pixels, ai, j, l >> 16, j1 >> 16, k1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2131.                         l += i7;
  2132.                         j1 += i8;
  2133.                         k1 += j7;
  2134.                         i2 += j8;
  2135.                         j += DrawingArea.width;
  2136.                         l4 += j5;
  2137.                         k5 += i6;
  2138.                         j6 += l6;
  2139.                     }
  2140.                     return;
  2141.                 }
  2142.                 i -= k;
  2143.                 k -= j;
  2144.                 j = anIntArray1472[j];
  2145.                 while(--k >= 0)
  2146.                 {
  2147.                     drawLDTexturedScanline(DrawingArea.pixels, ai, j, i1 >> 16, l >> 16, l1 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2148.                     l += i7;
  2149.                     i1 += k7;
  2150.                     k1 += j7;
  2151.                     l1 += l7;
  2152.                     j += DrawingArea.width;
  2153.                     l4 += j5;
  2154.                     k5 += i6;
  2155.                     j6 += l6;
  2156.                 }
  2157.                 while(--i >= 0)
  2158.                 {
  2159.                     drawLDTexturedScanline(DrawingArea.pixels, ai, j, j1 >> 16, l >> 16, i2 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2160.                     l += i7;
  2161.                     j1 += i8;
  2162.                     k1 += j7;
  2163.                     i2 += j8;
  2164.                     j += DrawingArea.width;
  2165.                     l4 += j5;
  2166.                     k5 += i6;
  2167.                     j6 += l6;
  2168.                 }
  2169.                 return;
  2170.             }
  2171.             j1 = i1 <<= 16;
  2172.             i2 = l1 <<= 16;
  2173.             if(j < 0)
  2174.             {
  2175.                 j1 -= i7 * j;
  2176.                 i1 -= k7 * j;
  2177.                 i2 -= j7 * j;
  2178.                 l1 -= l7 * j;
  2179.                 j = 0;
  2180.             }
  2181.             l <<= 16;
  2182.             k1 <<= 16;
  2183.             if(i < 0)
  2184.             {
  2185.                 l -= i8 * i;
  2186.                 k1 -= j8 * i;
  2187.                 i = 0;
  2188.             }
  2189.             int j9 = j - textureInt2;
  2190.             l4 += j5 * j9;
  2191.             k5 += i6 * j9;
  2192.             j6 += l6 * j9;
  2193.             if(i7 < k7)
  2194.             {
  2195.                 k -= i;
  2196.                 i -= j;
  2197.                 j = anIntArray1472[j];
  2198.                 while(--i >= 0)
  2199.                 {
  2200.                     drawLDTexturedScanline(DrawingArea.pixels, ai, j, j1 >> 16, i1 >> 16, i2 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2201.                     j1 += i7;
  2202.                     i1 += k7;
  2203.                     i2 += j7;
  2204.                     l1 += l7;
  2205.                     j += DrawingArea.width;
  2206.                     l4 += j5;
  2207.                     k5 += i6;
  2208.                     j6 += l6;
  2209.                 }
  2210.                 while(--k >= 0)
  2211.                 {
  2212.                     drawLDTexturedScanline(DrawingArea.pixels, ai, j, l >> 16, i1 >> 16, k1 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2213.                     l += i8;
  2214.                     i1 += k7;
  2215.                     k1 += j8;
  2216.                     l1 += l7;
  2217.                     j += DrawingArea.width;
  2218.                     l4 += j5;
  2219.                     k5 += i6;
  2220.                     j6 += l6;
  2221.                 }
  2222.                 return;
  2223.             }
  2224.             k -= i;
  2225.             i -= j;
  2226.             j = anIntArray1472[j];
  2227.             while(--i >= 0)
  2228.             {
  2229.                 drawLDTexturedScanline(DrawingArea.pixels, ai, j, i1 >> 16, j1 >> 16, l1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2230.                 j1 += i7;
  2231.                 i1 += k7;
  2232.                 i2 += j7;
  2233.                 l1 += l7;
  2234.                 j += DrawingArea.width;
  2235.                 l4 += j5;
  2236.                 k5 += i6;
  2237.                 j6 += l6;
  2238.             }
  2239.             while(--k >= 0)
  2240.             {
  2241.                 drawLDTexturedScanline(DrawingArea.pixels, ai, j, i1 >> 16, l >> 16, l1 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2242.                 l += i8;
  2243.                 i1 += k7;
  2244.                 k1 += j8;
  2245.                 l1 += l7;
  2246.                 j += DrawingArea.width;
  2247.                 l4 += j5;
  2248.                 k5 += i6;
  2249.                 j6 += l6;
  2250.             }
  2251.             return;
  2252.         }
  2253.         if(k >= DrawingArea.bottomY)
  2254.             return;
  2255.         if(i > DrawingArea.bottomY)
  2256.             i = DrawingArea.bottomY;
  2257.         if(j > DrawingArea.bottomY)
  2258.             j = DrawingArea.bottomY;
  2259.         if(i < j)
  2260.         {
  2261.             i1 = j1 <<= 16;
  2262.             l1 = i2 <<= 16;
  2263.             if(k < 0)
  2264.             {
  2265.                 i1 -= k7 * k;
  2266.                 j1 -= i8 * k;
  2267.                 l1 -= l7 * k;
  2268.                 i2 -= j8 * k;
  2269.                 k = 0;
  2270.             }
  2271.             l <<= 16;
  2272.             k1 <<= 16;
  2273.             if(i < 0)
  2274.             {
  2275.                 l -= i7 * i;
  2276.                 k1 -= j7 * i;
  2277.                 i = 0;
  2278.             }
  2279.             int k9 = k - textureInt2;
  2280.             l4 += j5 * k9;
  2281.             k5 += i6 * k9;
  2282.             j6 += l6 * k9;
  2283.             if(k7 < i8)
  2284.             {
  2285.                 j -= i;
  2286.                 i -= k;
  2287.                 k = anIntArray1472[k];
  2288.                 while(--i >= 0)
  2289.                 {
  2290.                     drawLDTexturedScanline(DrawingArea.pixels, ai, k, i1 >> 16, j1 >> 16, l1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2291.                     i1 += k7;
  2292.                     j1 += i8;
  2293.                     l1 += l7;
  2294.                     i2 += j8;
  2295.                     k += DrawingArea.width;
  2296.                     l4 += j5;
  2297.                     k5 += i6;
  2298.                     j6 += l6;
  2299.                 }
  2300.                 while(--j >= 0)
  2301.                 {
  2302.                     drawLDTexturedScanline(DrawingArea.pixels, ai, k, i1 >> 16, l >> 16, l1 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2303.                     i1 += k7;
  2304.                     l += i7;
  2305.                     l1 += l7;
  2306.                     k1 += j7;
  2307.                     k += DrawingArea.width;
  2308.                     l4 += j5;
  2309.                     k5 += i6;
  2310.                     j6 += l6;
  2311.                 }
  2312.                 return;
  2313.             }
  2314.             j -= i;
  2315.             i -= k;
  2316.             k = anIntArray1472[k];
  2317.             while(--i >= 0)
  2318.             {
  2319.                 drawLDTexturedScanline(DrawingArea.pixels, ai, k, j1 >> 16, i1 >> 16, i2 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2320.                 i1 += k7;
  2321.                 j1 += i8;
  2322.                 l1 += l7;
  2323.                 i2 += j8;
  2324.                 k += DrawingArea.width;
  2325.                 l4 += j5;
  2326.                 k5 += i6;
  2327.                 j6 += l6;
  2328.             }
  2329.             while(--j >= 0)
  2330.             {
  2331.                 drawLDTexturedScanline(DrawingArea.pixels, ai, k, l >> 16, i1 >> 16, k1 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2332.                 i1 += k7;
  2333.                 l += i7;
  2334.                 l1 += l7;
  2335.                 k1 += j7;
  2336.                 k += DrawingArea.width;
  2337.                 l4 += j5;
  2338.                 k5 += i6;
  2339.                 j6 += l6;
  2340.             }
  2341.             return;
  2342.         }
  2343.         l = j1 <<= 16;
  2344.         k1 = i2 <<= 16;
  2345.         if(k < 0)
  2346.         {
  2347.             l -= k7 * k;
  2348.             j1 -= i8 * k;
  2349.             k1 -= l7 * k;
  2350.             i2 -= j8 * k;
  2351.             k = 0;
  2352.         }
  2353.         i1 <<= 16;
  2354.         l1 <<= 16;
  2355.         if(j < 0)
  2356.         {
  2357.             i1 -= i7 * j;
  2358.             l1 -= j7 * j;
  2359.             j = 0;
  2360.         }
  2361.         int l9 = k - textureInt2;
  2362.         l4 += j5 * l9;
  2363.         k5 += i6 * l9;
  2364.         j6 += l6 * l9;
  2365.         if(k7 < i8)
  2366.         {
  2367.             i -= j;
  2368.             j -= k;
  2369.             k = anIntArray1472[k];
  2370.             while(--j >= 0)
  2371.             {
  2372.                 drawLDTexturedScanline(DrawingArea.pixels, ai, k, l >> 16, j1 >> 16, k1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2373.                 l += k7;
  2374.                 j1 += i8;
  2375.                 k1 += l7;
  2376.                 i2 += j8;
  2377.                 k += DrawingArea.width;
  2378.                 l4 += j5;
  2379.                 k5 += i6;
  2380.                 j6 += l6;
  2381.             }
  2382.             while(--i >= 0)
  2383.             {
  2384.                 drawLDTexturedScanline(DrawingArea.pixels, ai, k, i1 >> 16, j1 >> 16, l1 >> 8, i2 >> 8, l4, k5, j6, i5, l5, k6);
  2385.                 i1 += i7;
  2386.                 j1 += i8;
  2387.                 l1 += j7;
  2388.                 i2 += j8;
  2389.                 k += DrawingArea.width;
  2390.                 l4 += j5;
  2391.                 k5 += i6;
  2392.                 j6 += l6;
  2393.             }
  2394.             return;
  2395.         }
  2396.         i -= j;
  2397.         j -= k;
  2398.         k = anIntArray1472[k];
  2399.         while(--j >= 0)
  2400.         {
  2401.             drawLDTexturedScanline(DrawingArea.pixels, ai, k, j1 >> 16, l >> 16, i2 >> 8, k1 >> 8, l4, k5, j6, i5, l5, k6);
  2402.             l += k7;
  2403.             j1 += i8;
  2404.             k1 += l7;
  2405.             i2 += j8;
  2406.             k += DrawingArea.width;
  2407.             l4 += j5;
  2408.             k5 += i6;
  2409.             j6 += l6;
  2410.         }
  2411.         while(--i >= 0)
  2412.         {
  2413.             drawLDTexturedScanline(DrawingArea.pixels, ai, k, j1 >> 16, i1 >> 16, i2 >> 8, l1 >> 8, l4, k5, j6, i5, l5, k6);
  2414.             i1 += i7;
  2415.             j1 += i8;
  2416.             l1 += j7;
  2417.             i2 += j8;
  2418.             k += DrawingArea.width;
  2419.             l4 += j5;
  2420.             k5 += i6;
  2421.             j6 += l6;
  2422.         }
  2423.     }
  2424.  
  2425.     private static void drawLDTexturedScanline(int ai[], int ai1[], int k, int l, int i1, int j1,
  2426.                                   int k1, int l1, int i2, int j2, int k2, int l2, int i3)
  2427.     {
  2428.         int i = 0;//was parameter
  2429.         int j = 0;//was parameter
  2430.         if(l >= i1)
  2431.             return;
  2432.         int j3;
  2433.         int k3;
  2434.         if(aBoolean1462)
  2435.         {
  2436.             j3 = (k1 - j1) / (i1 - l);
  2437.             if(i1 > DrawingArea.centerX)
  2438.                 i1 = DrawingArea.centerX;
  2439.             if(l < 0)
  2440.             {
  2441.                 j1 -= l * j3;
  2442.                 l = 0;
  2443.             }
  2444.             if(l >= i1)
  2445.                 return;
  2446.             k3 = i1 - l >> 3;
  2447.             j3 <<= 12;
  2448.             j1 <<= 9;
  2449.         } else
  2450.         {
  2451.             if(i1 - l > 7)
  2452.             {
  2453.                 k3 = i1 - l >> 3;
  2454.                 j3 = (k1 - j1) * anIntArray1468[k3] >> 6;
  2455.             } else
  2456.             {
  2457.                 k3 = 0;
  2458.                 j3 = 0;
  2459.             }
  2460.             j1 <<= 9;
  2461.         }
  2462.         k += l;
  2463.         if(lowMem)
  2464.         {
  2465.             int i4 = 0;
  2466.             int k4 = 0;
  2467.             int k6 = l - textureInt1;
  2468.             l1 += (k2 >> 3) * k6;
  2469.             i2 += (l2 >> 3) * k6;
  2470.             j2 += (i3 >> 3) * k6;
  2471.             int i5 = j2 >> 12;
  2472.             if(i5 != 0)
  2473.             {
  2474.                 i = l1 / i5;
  2475.                 j = i2 / i5;
  2476.                 if(i < 0)
  2477.                     i = 0;
  2478.                 else
  2479.                 if(i > 4032)
  2480.                     i = 4032;
  2481.             }
  2482.             l1 += k2;
  2483.             i2 += l2;
  2484.             j2 += i3;
  2485.             i5 = j2 >> 12;
  2486.             if(i5 != 0)
  2487.             {
  2488.                 i4 = l1 / i5;
  2489.                 k4 = i2 / i5;
  2490.                 if(i4 < 7)
  2491.                     i4 = 7;
  2492.                 else
  2493.                 if(i4 > 4032)
  2494.                     i4 = 4032;
  2495.             }
  2496.             int i7 = i4 - i >> 3;
  2497.             int k7 = k4 - j >> 3;
  2498.             i += (j1 & 0x600000) >> 3;
  2499.             int i8 = j1 >> 23;
  2500.             if(aBoolean1463)
  2501.             {
  2502.                 while(k3-- > 0)
  2503.                 {
  2504.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2505.                     i += i7;
  2506.                     j += k7;
  2507.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2508.                     i += i7;
  2509.                     j += k7;
  2510.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2511.                     i += i7;
  2512.                     j += k7;
  2513.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2514.                     i += i7;
  2515.                     j += k7;
  2516.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2517.                     i += i7;
  2518.                     j += k7;
  2519.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2520.                     i += i7;
  2521.                     j += k7;
  2522.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2523.                     i += i7;
  2524.                     j += k7;
  2525.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2526.                     i = i4;
  2527.                     j = k4;
  2528.                     l1 += k2;
  2529.                     i2 += l2;
  2530.                     j2 += i3;
  2531.                     int j5 = j2 >> 12;
  2532.                     if(j5 != 0)
  2533.                     {
  2534.                         i4 = l1 / j5;
  2535.                         k4 = i2 / j5;
  2536.                         if(i4 < 7)
  2537.                             i4 = 7;
  2538.                         else
  2539.                         if(i4 > 4032)
  2540.                             i4 = 4032;
  2541.                     }
  2542.                     i7 = i4 - i >> 3;
  2543.                     k7 = k4 - j >> 3;
  2544.                     j1 += j3;
  2545.                     i += (j1 & 0x600000) >> 3;
  2546.                     i8 = j1 >> 23;
  2547.                 }
  2548.                 for(k3 = i1 - l & 7; k3-- > 0;)
  2549.                 {
  2550.                     ai[k++] = ai1[(j & 0xfc0) + (i >> 6)] >>> i8;
  2551.                     i += i7;
  2552.                     j += k7;
  2553.                 }
  2554.  
  2555.                 return;
  2556.             }
  2557.             while(k3-- > 0)
  2558.             {
  2559.                 int k8;
  2560.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2561.                     ai[k] = k8;
  2562.                 k++;
  2563.                 i += i7;
  2564.                 j += k7;
  2565.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2566.                     ai[k] = k8;
  2567.                 k++;
  2568.                 i += i7;
  2569.                 j += k7;
  2570.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2571.                     ai[k] = k8;
  2572.                 k++;
  2573.                 i += i7;
  2574.                 j += k7;
  2575.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2576.                     ai[k] = k8;
  2577.                 k++;
  2578.                 i += i7;
  2579.                 j += k7;
  2580.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2581.                     ai[k] = k8;
  2582.                 k++;
  2583.                 i += i7;
  2584.                 j += k7;
  2585.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2586.                     ai[k] = k8;
  2587.                 k++;
  2588.                 i += i7;
  2589.                 j += k7;
  2590.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2591.                     ai[k] = k8;
  2592.                 k++;
  2593.                 i += i7;
  2594.                 j += k7;
  2595.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2596.                     ai[k] = k8;
  2597.                 k++;
  2598.                 i = i4;
  2599.                 j = k4;
  2600.                 l1 += k2;
  2601.                 i2 += l2;
  2602.                 j2 += i3;
  2603.                 int k5 = j2 >> 12;
  2604.                 if(k5 != 0)
  2605.                 {
  2606.                     i4 = l1 / k5;
  2607.                     k4 = i2 / k5;
  2608.                     if(i4 < 7)
  2609.                         i4 = 7;
  2610.                     else
  2611.                     if(i4 > 4032)
  2612.                         i4 = 4032;
  2613.                 }
  2614.                 i7 = i4 - i >> 3;
  2615.                 k7 = k4 - j >> 3;
  2616.                 j1 += j3;
  2617.                 i += (j1 & 0x600000) >> 3;
  2618.                 i8 = j1 >> 23;
  2619.             }
  2620.             for(k3 = i1 - l & 7; k3-- > 0;)
  2621.             {
  2622.                 int l8;
  2623.                 if((l8 = ai1[(j & 0xfc0) + (i >> 6)] >>> i8) != 0)
  2624.                     ai[k] = l8;
  2625.                 k++;
  2626.                 i += i7;
  2627.                 j += k7;
  2628.             }
  2629.  
  2630.             return;
  2631.         }
  2632.         int j4 = 0;
  2633.         int l4 = 0;
  2634.         int l6 = l - textureInt1;
  2635.         l1 += (k2 >> 3) * l6;
  2636.         i2 += (l2 >> 3) * l6;
  2637.         j2 += (i3 >> 3) * l6;
  2638.         int l5 = j2 >> 14;
  2639.         if(l5 != 0)
  2640.         {
  2641.             i = l1 / l5;
  2642.             j = i2 / l5;
  2643.             if(i < 0)
  2644.                 i = 0;
  2645.             else
  2646.             if(i > 16256)
  2647.                 i = 16256;
  2648.         }
  2649.         l1 += k2;
  2650.         i2 += l2;
  2651.         j2 += i3;
  2652.         l5 = j2 >> 14;
  2653.         if(l5 != 0)
  2654.         {
  2655.             j4 = l1 / l5;
  2656.             l4 = i2 / l5;
  2657.             if(j4 < 7)
  2658.                 j4 = 7;
  2659.             else
  2660.             if(j4 > 16256)
  2661.                 j4 = 16256;
  2662.         }
  2663.         int j7 = j4 - i >> 3;
  2664.         int l7 = l4 - j >> 3;
  2665.         i += j1 & 0x600000;
  2666.         int j8 = j1 >> 23;
  2667.         if(aBoolean1463)
  2668.         {
  2669.             while(k3-- > 0)
  2670.             {
  2671.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2672.                 i += j7;
  2673.                 j += l7;
  2674.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2675.                 i += j7;
  2676.                 j += l7;
  2677.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2678.                 i += j7;
  2679.                 j += l7;
  2680.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2681.                 i += j7;
  2682.                 j += l7;
  2683.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2684.                 i += j7;
  2685.                 j += l7;
  2686.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2687.                 i += j7;
  2688.                 j += l7;
  2689.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2690.                 i += j7;
  2691.                 j += l7;
  2692.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2693.                 i = j4;
  2694.                 j = l4;
  2695.                 l1 += k2;
  2696.                 i2 += l2;
  2697.                 j2 += i3;
  2698.                 int i6 = j2 >> 14;
  2699.                 if(i6 != 0)
  2700.                 {
  2701.                     j4 = l1 / i6;
  2702.                     l4 = i2 / i6;
  2703.                     if(j4 < 7)
  2704.                         j4 = 7;
  2705.                     else
  2706.                     if(j4 > 16256)
  2707.                         j4 = 16256;
  2708.                 }
  2709.                 j7 = j4 - i >> 3;
  2710.                 l7 = l4 - j >> 3;
  2711.                 j1 += j3;
  2712.                 i += j1 & 0x600000;
  2713.                 j8 = j1 >> 23;
  2714.             }
  2715.             for(k3 = i1 - l & 7; k3-- > 0;)
  2716.             {
  2717.                 ai[k++] = ai1[(j & 0x3f80) + (i >> 7)] >>> j8;
  2718.                 i += j7;
  2719.                 j += l7;
  2720.             }
  2721.  
  2722.             return;
  2723.         }
  2724.         while(k3-- > 0)
  2725.         {
  2726.             int i9;
  2727.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2728.                 ai[k] = i9;
  2729.             k++;
  2730.             i += j7;
  2731.             j += l7;
  2732.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2733.                 ai[k] = i9;
  2734.             k++;
  2735.             i += j7;
  2736.             j += l7;
  2737.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2738.                 ai[k] = i9;
  2739.             k++;
  2740.             i += j7;
  2741.             j += l7;
  2742.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2743.                 ai[k] = i9;
  2744.             k++;
  2745.             i += j7;
  2746.             j += l7;
  2747.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2748.                 ai[k] = i9;
  2749.             k++;
  2750.             i += j7;
  2751.             j += l7;
  2752.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2753.                 ai[k] = i9;
  2754.             k++;
  2755.             i += j7;
  2756.             j += l7;
  2757.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2758.                 ai[k] = i9;
  2759.             k++;
  2760.             i += j7;
  2761.             j += l7;
  2762.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2763.                 ai[k] = i9;
  2764.             k++;
  2765.             i = j4;
  2766.             j = l4;
  2767.             l1 += k2;
  2768.             i2 += l2;
  2769.             j2 += i3;
  2770.             int j6 = j2 >> 14;
  2771.             if(j6 != 0)
  2772.             {
  2773.                 j4 = l1 / j6;
  2774.                 l4 = i2 / j6;
  2775.                 if(j4 < 7)
  2776.                     j4 = 7;
  2777.                 else
  2778.                 if(j4 > 16256)
  2779.                     j4 = 16256;
  2780.             }
  2781.             j7 = j4 - i >> 3;
  2782.             l7 = l4 - j >> 3;
  2783.             j1 += j3;
  2784.             i += j1 & 0x600000;
  2785.             j8 = j1 >> 23;
  2786.         }
  2787.         for(int l3 = i1 - l & 7; l3-- > 0;)
  2788.         {
  2789.             int j9;
  2790.             if((j9 = ai1[(j & 0x3f80) + (i >> 7)] >>> j8) != 0)
  2791.                 ai[k] = j9;
  2792.             k++;
  2793.             i += j7;
  2794.             j += l7;
  2795.         }
  2796.  
  2797.     }
  2798.    
  2799.     public static void drawHDTexturedTriangle(int y1, int y2, int y3, int x1, int x2, int x3, int l1, int l2,
  2800.             int l3, int tx1, int tx2, int tx3, int ty1, int ty2, int ty3,
  2801.             int tz1, int tz2, int tz3, int tex)
  2802.     {
  2803.         l1 = 0x7f - l1 << 1;
  2804.         l2 = 0x7f - l2 << 1;
  2805.         l3 = 0x7f - l3 << 1;
  2806.         int ai[] = method371(tex);
  2807.         aBoolean1463 = !aBooleanArray1475[tex];
  2808.         tx2 = tx1 - tx2;
  2809.         ty2 = ty1 - ty2;
  2810.         tz2 = tz1 - tz2;
  2811.         tx3 -= tx1;
  2812.         ty3 -= ty1;
  2813.         tz3 -= tz1;
  2814.         int l4 = tx3 * ty1 - ty3 * tx1 << 14;
  2815.         int i5 = ty3 * tz1 - tz3 * ty1 << 8;
  2816.         int j5 = tz3 * tx1 - tx3 * tz1 << 5;
  2817.         int k5 = tx2 * ty1 - ty2 * tx1 << 14;
  2818.         int l5 = ty2 * tz1 - tz2 * ty1 << 8;
  2819.         int i6 = tz2 * tx1 - tx2 * tz1 << 5;
  2820.         int j6 = ty2 * tx3 - tx2 * ty3 << 14;
  2821.         int k6 = tz2 * ty3 - ty2 * tz3 << 8;
  2822.         int l6 = tx2 * tz3 - tz2 * tx3 << 5;
  2823.         int i7 = 0;
  2824.         int j7 = 0;
  2825.         if(y2 != y1)
  2826.         {
  2827.             i7 = (x2 - x1 << 16) / (y2 - y1);
  2828.             j7 = (l2 - l1 << 16) / (y2 - y1);
  2829.         }
  2830.         int k7 = 0;
  2831.         int l7 = 0;
  2832.         if(y3 != y2)
  2833.         {
  2834.             k7 = (x3 - x2 << 16) / (y3 - y2);
  2835.             l7 = (l3 - l2 << 16) / (y3 - y2);
  2836.         }
  2837.         int i8 = 0;
  2838.         int j8 = 0;
  2839.         if(y3 != y1)
  2840.         {
  2841.             i8 = (x1 - x3 << 16) / (y1 - y3);
  2842.             j8 = (l1 - l3 << 16) / (y1 - y3);
  2843.         }
  2844.         if(y1 <= y2 && y1 <= y3)
  2845.         {
  2846.             if(y1 >= DrawingArea.bottomY)
  2847.                 return;
  2848.             if(y2 > DrawingArea.bottomY)
  2849.                 y2 = DrawingArea.bottomY;
  2850.             if(y3 > DrawingArea.bottomY)
  2851.                 y3 = DrawingArea.bottomY;
  2852.             if(y2 < y3)
  2853.             {
  2854.                 x3 = x1 <<= 16;
  2855.                 l3 = l1 <<= 16;
  2856.                 if(y1 < 0)
  2857.                 {
  2858.                     x3 -= i8 * y1;
  2859.                     x1 -= i7 * y1;
  2860.                     l3 -= j8 * y1;
  2861.                     l1 -= j7 * y1;
  2862.                     y1 = 0;
  2863.                 }
  2864.                 x2 <<= 16;
  2865.                 l2 <<= 16;
  2866.                 if(y2 < 0)
  2867.                 {
  2868.                     x2 -= k7 * y2;
  2869.                     l2 -= l7 * y2;
  2870.                     y2 = 0;
  2871.                 }
  2872.                 int k8 = y1 - textureInt2;
  2873.                 l4 += j5 * k8;
  2874.                 k5 += i6 * k8;
  2875.                 j6 += l6 * k8;
  2876.                 if(y1 != y2 && i8 < i7 || y1 == y2 && i8 > k7)
  2877.                 {
  2878.                     y3 -= y2;
  2879.                     y2 -= y1;
  2880.                     y1 = anIntArray1472[y1];
  2881.                     while(--y2 >= 0)
  2882.                     {
  2883.                         drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x3 >> 16, x1 >> 16, l3, l1, l4, k5, j6, i5, l5, k6);
  2884.                         x3 += i8;
  2885.                         x1 += i7;
  2886.                         l3 += j8;
  2887.                         l1 += j7;
  2888.                         y1 += DrawingArea.width;
  2889.                         l4 += j5;
  2890.                         k5 += i6;
  2891.                         j6 += l6;
  2892.                     }
  2893.                     while(--y3 >= 0)
  2894.                     {
  2895.                         drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x3 >> 16, x2 >> 16, l3, l2, l4, k5, j6, i5, l5, k6);
  2896.                         x3 += i8;
  2897.                         x2 += k7;
  2898.                         l3 += j8;
  2899.                         l2 += l7;
  2900.                         y1 += DrawingArea.width;
  2901.                         l4 += j5;
  2902.                         k5 += i6;
  2903.                         j6 += l6;
  2904.                     }
  2905.                     return;
  2906.                 }
  2907.                 y3 -= y2;
  2908.                 y2 -= y1;
  2909.                 y1 = anIntArray1472[y1];
  2910.                 while(--y2 >= 0)
  2911.                 {
  2912.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x1 >> 16, x3 >> 16, l1, l3, l4, k5, j6, i5, l5, k6);
  2913.                     x3 += i8;
  2914.                     x1 += i7;
  2915.                     l3 += j8;
  2916.                     l1 += j7;
  2917.                     y1 += DrawingArea.width;
  2918.                     l4 += j5;
  2919.                     k5 += i6;
  2920.                     j6 += l6;
  2921.                 }
  2922.                 while(--y3 >= 0)
  2923.                 {
  2924.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x2 >> 16, x3 >> 16, l2, l3, l4, k5, j6, i5, l5, k6);
  2925.                     x3 += i8;
  2926.                     x2 += k7;
  2927.                     l3 += j8;
  2928.                     l2 += l7;
  2929.                     y1 += DrawingArea.width;
  2930.                     l4 += j5;
  2931.                     k5 += i6;
  2932.                     j6 += l6;
  2933.                 }
  2934.                 return;
  2935.             }
  2936.             x2 = x1 <<= 16;
  2937.             l2 = l1 <<= 16;
  2938.             if(y1 < 0)
  2939.             {
  2940.                 x2 -= i8 * y1;
  2941.                 x1 -= i7 * y1;
  2942.                 l2 -= j8 * y1;
  2943.                 l1 -= j7 * y1;
  2944.                 y1 = 0;
  2945.             }
  2946.             x3 <<= 16;
  2947.             l3 <<= 16;
  2948.             if(y3 < 0)
  2949.             {
  2950.                 x3 -= k7 * y3;
  2951.                 l3 -= l7 * y3;
  2952.                 y3 = 0;
  2953.             }
  2954.             int l8 = y1 - textureInt2;
  2955.             l4 += j5 * l8;
  2956.             k5 += i6 * l8;
  2957.             j6 += l6 * l8;
  2958.             if(y1 != y3 && i8 < i7 || y1 == y3 && k7 > i7)
  2959.             {
  2960.                 y2 -= y3;
  2961.                 y3 -= y1;
  2962.                 y1 = anIntArray1472[y1];
  2963.                 while(--y3 >= 0)
  2964.                 {
  2965.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x2 >> 16, x1 >> 16, l2, l1, l4, k5, j6, i5, l5, k6);
  2966.                     x2 += i8;
  2967.                     x1 += i7;
  2968.                     l2 += j8;
  2969.                     l1 += j7;
  2970.                     y1 += DrawingArea.width;
  2971.                     l4 += j5;
  2972.                     k5 += i6;
  2973.                     j6 += l6;
  2974.                 }
  2975.                 while(--y2 >= 0)
  2976.                 {
  2977.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x3 >> 16, x1 >> 16, l3, l1, l4, k5, j6, i5, l5, k6);
  2978.                     x3 += k7;
  2979.                     x1 += i7;
  2980.                     l3 += l7;
  2981.                     l1 += j7;
  2982.                     y1 += DrawingArea.width;
  2983.                     l4 += j5;
  2984.                     k5 += i6;
  2985.                     j6 += l6;
  2986.                 }
  2987.                 return;
  2988.             }
  2989.             y2 -= y3;
  2990.             y3 -= y1;
  2991.             y1 = anIntArray1472[y1];
  2992.             while(--y3 >= 0)
  2993.             {
  2994.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x1 >> 16, x2 >> 16, l1, l2, l4, k5, j6, i5, l5, k6);
  2995.                 x2 += i8;
  2996.                 x1 += i7;
  2997.                 l2 += j8;
  2998.                 l1 += j7;
  2999.                 y1 += DrawingArea.width;
  3000.                 l4 += j5;
  3001.                 k5 += i6;
  3002.                 j6 += l6;
  3003.             }
  3004.             while(--y2 >= 0)
  3005.             {
  3006.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y1, x1 >> 16, x3 >> 16, l1, l3, l4, k5, j6, i5, l5, k6);
  3007.                 x3 += k7;
  3008.                 x1 += i7;
  3009.                 l3 += l7;
  3010.                 l1 += j7;
  3011.                 y1 += DrawingArea.width;
  3012.                 l4 += j5;
  3013.                 k5 += i6;
  3014.                 j6 += l6;
  3015.             }
  3016.             return;
  3017.         }
  3018.         if(y2 <= y3)
  3019.         {
  3020.             if(y2 >= DrawingArea.bottomY)
  3021.                 return;
  3022.             if(y3 > DrawingArea.bottomY)
  3023.                 y3 = DrawingArea.bottomY;
  3024.             if(y1 > DrawingArea.bottomY)
  3025.                 y1 = DrawingArea.bottomY;
  3026.             if(y3 < y1)
  3027.             {
  3028.                 x1 = x2 <<= 16;
  3029.                 l1 = l2 <<= 16;
  3030.                 if(y2 < 0)
  3031.                 {
  3032.                     x1 -= i7 * y2;
  3033.                     x2 -= k7 * y2;
  3034.                     l1 -= j7 * y2;
  3035.                     l2 -= l7 * y2;
  3036.                     y2 = 0;
  3037.                 }
  3038.                 x3 <<= 16;
  3039.                 l3 <<= 16;
  3040.                 if(y3 < 0)
  3041.                 {
  3042.                     x3 -= i8 * y3;
  3043.                     l3 -= j8 * y3;
  3044.                     y3 = 0;
  3045.                 }
  3046.                 int i9 = y2 - textureInt2;
  3047.                 l4 += j5 * i9;
  3048.                 k5 += i6 * i9;
  3049.                 j6 += l6 * i9;
  3050.                 if(y2 != y3 && i7 < k7 || y2 == y3 && i7 > i8)
  3051.                 {
  3052.                     y1 -= y3;
  3053.                     y3 -= y2;
  3054.                     y2 = anIntArray1472[y2];
  3055.                     while(--y3 >= 0)
  3056.                     {
  3057.                         drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x1 >> 16, x2 >> 16, l1, l2, l4, k5, j6, i5, l5, k6);
  3058.                         x1 += i7;
  3059.                         x2 += k7;
  3060.                         l1 += j7;
  3061.                         l2 += l7;
  3062.                         y2 += DrawingArea.width;
  3063.                         l4 += j5;
  3064.                         k5 += i6;
  3065.                         j6 += l6;
  3066.                     }
  3067.                     while(--y1 >= 0)
  3068.                     {
  3069.                         drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x1 >> 16, x3 >> 16, l1, l3, l4, k5, j6, i5, l5, k6);
  3070.                         x1 += i7;
  3071.                         x3 += i8;
  3072.                         l1 += j7;
  3073.                         l3 += j8;
  3074.                         y2 += DrawingArea.width;
  3075.                         l4 += j5;
  3076.                         k5 += i6;
  3077.                         j6 += l6;
  3078.                     }
  3079.                     return;
  3080.                 }
  3081.                 y1 -= y3;
  3082.                 y3 -= y2;
  3083.                 y2 = anIntArray1472[y2];
  3084.                 while(--y3 >= 0)
  3085.                 {
  3086.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x2 >> 16, x1 >> 16, l2, l1, l4, k5, j6, i5, l5, k6);
  3087.                     x1 += i7;
  3088.                     x2 += k7;
  3089.                     l1 += j7;
  3090.                     l2 += l7;
  3091.                     y2 += DrawingArea.width;
  3092.                     l4 += j5;
  3093.                     k5 += i6;
  3094.                     j6 += l6;
  3095.                 }
  3096.                 while(--y1 >= 0)
  3097.                 {
  3098.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x3 >> 16, x1 >> 16, l3, l1, l4, k5, j6, i5, l5, k6);
  3099.                     x1 += i7;
  3100.                     x3 += i8;
  3101.                     l1 += j7;
  3102.                     l3 += j8;
  3103.                     y2 += DrawingArea.width;
  3104.                     l4 += j5;
  3105.                     k5 += i6;
  3106.                     j6 += l6;
  3107.                 }
  3108.                 return;
  3109.             }
  3110.             x3 = x2 <<= 16;
  3111.             l3 = l2 <<= 16;
  3112.             if(y2 < 0)
  3113.             {
  3114.                 x3 -= i7 * y2;
  3115.                 x2 -= k7 * y2;
  3116.                 l3 -= j7 * y2;
  3117.                 l2 -= l7 * y2;
  3118.                 y2 = 0;
  3119.             }
  3120.             x1 <<= 16;
  3121.             l1 <<= 16;
  3122.             if(y1 < 0)
  3123.             {
  3124.                 x1 -= i8 * y1;
  3125.                 l1 -= j8 * y1;
  3126.                 y1 = 0;
  3127.             }
  3128.             int j9 = y2 - textureInt2;
  3129.             l4 += j5 * j9;
  3130.             k5 += i6 * j9;
  3131.             j6 += l6 * j9;
  3132.             if(i7 < k7)
  3133.             {
  3134.                 y3 -= y1;
  3135.                 y1 -= y2;
  3136.                 y2 = anIntArray1472[y2];
  3137.                 while(--y1 >= 0)
  3138.                 {
  3139.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x3 >> 16, x2 >> 16, l3, l2, l4, k5, j6, i5, l5, k6);
  3140.                     x3 += i7;
  3141.                     x2 += k7;
  3142.                     l3 += j7;
  3143.                     l2 += l7;
  3144.                     y2 += DrawingArea.width;
  3145.                     l4 += j5;
  3146.                     k5 += i6;
  3147.                     j6 += l6;
  3148.                 }
  3149.                 while(--y3 >= 0)
  3150.                 {
  3151.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x1 >> 16, x2 >> 16, l1, l2, l4, k5, j6, i5, l5, k6);
  3152.                     x1 += i8;
  3153.                     x2 += k7;
  3154.                     l1 += j8;
  3155.                     l2 += l7;
  3156.                     y2 += DrawingArea.width;
  3157.                     l4 += j5;
  3158.                     k5 += i6;
  3159.                     j6 += l6;
  3160.                 }
  3161.                 return;
  3162.             }
  3163.             y3 -= y1;
  3164.             y1 -= y2;
  3165.             y2 = anIntArray1472[y2];
  3166.             while(--y1 >= 0)
  3167.             {
  3168.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x2 >> 16, x3 >> 16, l2, l3, l4, k5, j6, i5, l5, k6);
  3169.                 x3 += i7;
  3170.                 x2 += k7;
  3171.                 l3 += j7;
  3172.                 l2 += l7;
  3173.                 y2 += DrawingArea.width;
  3174.                 l4 += j5;
  3175.                 k5 += i6;
  3176.                 j6 += l6;
  3177.             }
  3178.             while(--y3 >= 0)
  3179.             {
  3180.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y2, x2 >> 16, x1 >> 16, l2, l1, l4, k5, j6, i5, l5, k6);
  3181.                 x1 += i8;
  3182.                 x2 += k7;
  3183.                 l1 += j8;
  3184.                 l2 += l7;
  3185.                 y2 += DrawingArea.width;
  3186.                 l4 += j5;
  3187.                 k5 += i6;
  3188.                 j6 += l6;
  3189.             }
  3190.             return;
  3191.         }
  3192.         if(y3 >= DrawingArea.bottomY)
  3193.             return;
  3194.         if(y1 > DrawingArea.bottomY)
  3195.             y1 = DrawingArea.bottomY;
  3196.         if(y2 > DrawingArea.bottomY)
  3197.             y2 = DrawingArea.bottomY;
  3198.         if(y1 < y2)
  3199.         {
  3200.             x2 = x3 <<= 16;
  3201.             l2 = l3 <<= 16;
  3202.             if(y3 < 0)
  3203.             {
  3204.                 x2 -= k7 * y3;
  3205.                 x3 -= i8 * y3;
  3206.                 l2 -= l7 * y3;
  3207.                 l3 -= j8 * y3;
  3208.                 y3 = 0;
  3209.             }
  3210.             x1 <<= 16;
  3211.             l1 <<= 16;
  3212.             if(y1 < 0)
  3213.             {
  3214.                 x1 -= i7 * y1;
  3215.                 l1 -= j7 * y1;
  3216.                 y1 = 0;
  3217.             }
  3218.             int k9 = y3 - textureInt2;
  3219.             l4 += j5 * k9;
  3220.             k5 += i6 * k9;
  3221.             j6 += l6 * k9;
  3222.             if(k7 < i8)
  3223.             {
  3224.                 y2 -= y1;
  3225.                 y1 -= y3;
  3226.                 y3 = anIntArray1472[y3];
  3227.                 while(--y1 >= 0)
  3228.                 {
  3229.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x2 >> 16, x3 >> 16, l2, l3, l4, k5, j6, i5, l5, k6);
  3230.                     x2 += k7;
  3231.                     x3 += i8;
  3232.                     l2 += l7;
  3233.                     l3 += j8;
  3234.                     y3 += DrawingArea.width;
  3235.                     l4 += j5;
  3236.                     k5 += i6;
  3237.                     j6 += l6;
  3238.                 }
  3239.                 while(--y2 >= 0)
  3240.                 {
  3241.                     drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x2 >> 16, x1 >> 16, l2, l1, l4, k5, j6, i5, l5, k6);
  3242.                     x2 += k7;
  3243.                     x1 += i7;
  3244.                     l2 += l7;
  3245.                     l1 += j7;
  3246.                     y3 += DrawingArea.width;
  3247.                     l4 += j5;
  3248.                     k5 += i6;
  3249.                     j6 += l6;
  3250.                 }
  3251.                 return;
  3252.             }
  3253.             y2 -= y1;
  3254.             y1 -= y3;
  3255.             y3 = anIntArray1472[y3];
  3256.             while(--y1 >= 0)
  3257.             {
  3258.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x3 >> 16, x2 >> 16, l3, l2, l4, k5, j6, i5, l5, k6);
  3259.                 x2 += k7;
  3260.                 x3 += i8;
  3261.                 l2 += l7;
  3262.                 l3 += j8;
  3263.                 y3 += DrawingArea.width;
  3264.                 l4 += j5;
  3265.                 k5 += i6;
  3266.                 j6 += l6;
  3267.             }
  3268.             while(--y2 >= 0)
  3269.             {
  3270.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x1 >> 16, x2 >> 16, l1, l2, l4, k5, j6, i5, l5, k6);
  3271.                 x2 += k7;
  3272.                 x1 += i7;
  3273.                 l2 += l7;
  3274.                 l1 += j7;
  3275.                 y3 += DrawingArea.width;
  3276.                 l4 += j5;
  3277.                 k5 += i6;
  3278.                 j6 += l6;
  3279.             }
  3280.             return;
  3281.         }
  3282.         x1 = x3 <<= 16;
  3283.         l1 = l3 <<= 16;
  3284.         if(y3 < 0)
  3285.         {
  3286.             x1 -= k7 * y3;
  3287.             x3 -= i8 * y3;
  3288.             l1 -= l7 * y3;
  3289.             l3 -= j8 * y3;
  3290.             y3 = 0;
  3291.         }
  3292.         x2 <<= 16;
  3293.         l2 <<= 16;
  3294.         if(y2 < 0)
  3295.         {
  3296.             x2 -= i7 * y2;
  3297.             l2 -= j7 * y2;
  3298.             y2 = 0;
  3299.         }
  3300.         int l9 = y3 - textureInt2;
  3301.         l4 += j5 * l9;
  3302.         k5 += i6 * l9;
  3303.         j6 += l6 * l9;
  3304.         if(k7 < i8)
  3305.         {
  3306.             y1 -= y2;
  3307.             y2 -= y3;
  3308.             y3 = anIntArray1472[y3];
  3309.             while(--y2 >= 0)
  3310.             {
  3311.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x1 >> 16, x3 >> 16, l1, l3, l4, k5, j6, i5, l5, k6);
  3312.                 x1 += k7;
  3313.                 x3 += i8;
  3314.                 l1 += l7;
  3315.                 l3 += j8;
  3316.                 y3 += DrawingArea.width;
  3317.                 l4 += j5;
  3318.                 k5 += i6;
  3319.                 j6 += l6;
  3320.             }
  3321.             while(--y1 >= 0)
  3322.             {
  3323.                 drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x2 >> 16, x3 >> 16, l2, l3, l4, k5, j6, i5, l5, k6);
  3324.                 x2 += i7;
  3325.                 x3 += i8;
  3326.                 l2 += j7;
  3327.                 l3 += j8;
  3328.                 y3 += DrawingArea.width;
  3329.                 l4 += j5;
  3330.                 k5 += i6;
  3331.                 j6 += l6;
  3332.             }
  3333.             return;
  3334.         }
  3335.         y1 -= y2;
  3336.         y2 -= y3;
  3337.         y3 = anIntArray1472[y3];
  3338.         while(--y2 >= 0)
  3339.         {
  3340.             drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x3 >> 16, x1 >> 16, l3, l1, l4, k5, j6, i5, l5, k6);
  3341.             x1 += k7;
  3342.             x3 += i8;
  3343.             l1 += l7;
  3344.             l3 += j8;
  3345.             y3 += DrawingArea.width;
  3346.             l4 += j5;
  3347.             k5 += i6;
  3348.             j6 += l6;
  3349.         }
  3350.         while(--y1 >= 0)
  3351.         {
  3352.             drawHDTexturedScanline(DrawingArea.pixels, ai, y3, x3 >> 16, x2 >> 16, l3, l2, l4, k5, j6, i5, l5, k6);
  3353.             x2 += i7;
  3354.             x3 += i8;
  3355.             l2 += j7;
  3356.             l3 += j8;
  3357.             y3 += DrawingArea.width;
  3358.             l4 += j5;
  3359.             k5 += i6;
  3360.             j6 += l6;
  3361.         }
  3362.     }
  3363.  
  3364.     private static void drawHDTexturedScanline(int ai[], int ai1[], int k, int x1, int x2, int l1,
  3365.                                   int l2, int a1, int i2, int j2, int k2, int a2, int i3)
  3366.     {
  3367.         int i = 0;//was parameter
  3368.         int j = 0;//was parameter
  3369.         if(x1 >= x2)
  3370.             return;
  3371.         int dl = (l2 - l1) / (x2 - x1);
  3372.         int n;
  3373.         if(aBoolean1462)
  3374.         {
  3375.             if(x2 > DrawingArea.centerX)
  3376.                 x2 = DrawingArea.centerX;
  3377.             if(x1 < 0)
  3378.             {
  3379.                 l1 -= x1 * dl;
  3380.                 x1 = 0;
  3381.             }
  3382.         }
  3383.         if(x1 >= x2)
  3384.             return;
  3385.         n = x2 - x1 >> 3;
  3386.         k += x1;
  3387.         if(lowMem)
  3388.         {
  3389.             int i4 = 0;
  3390.             int k4 = 0;
  3391.             int k6 = x1 - textureInt1;
  3392.             a1 += (k2 >> 3) * k6;
  3393.             i2 += (a2 >> 3) * k6;
  3394.             j2 += (i3 >> 3) * k6;
  3395.             int i5 = j2 >> 12;
  3396.             if(i5 != 0)
  3397.             {
  3398.                 i = a1 / i5;
  3399.                 j = i2 / i5;
  3400.                 if(i < 0)
  3401.                     i = 0;
  3402.                 else
  3403.                 if(i > 4032)
  3404.                     i = 4032;
  3405.             }
  3406.             a1 += k2;
  3407.             i2 += a2;
  3408.             j2 += i3;
  3409.             i5 = j2 >> 12;
  3410.             if(i5 != 0)
  3411.             {
  3412.                 i4 = a1 / i5;
  3413.                 k4 = i2 / i5;
  3414.                 if(i4 < 7)
  3415.                     i4 = 7;
  3416.                 else
  3417.                 if(i4 > 4032)
  3418.                     i4 = 4032;
  3419.             }
  3420.             int i7 = i4 - i >> 3;
  3421.             int k7 = k4 - j >> 3;
  3422.             if(aBoolean1463)
  3423.             {
  3424.                 int rgb;
  3425.                 int l;
  3426.                 while(n-- > 0)
  3427.                 {
  3428.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3429.                     l = l1 >> 16;
  3430.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3431.                     i += i7;
  3432.                     j += k7;
  3433.                     l1 += dl;
  3434.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3435.                     l = l1 >> 16;
  3436.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3437.                     i += i7;
  3438.                     j += k7;
  3439.                     l1 += dl;
  3440.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3441.                     l = l1 >> 16;
  3442.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3443.                     i += i7;
  3444.                     j += k7;
  3445.                     l1 += dl;
  3446.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3447.                     l = l1 >> 16;
  3448.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3449.                     i += i7;
  3450.                     j += k7;
  3451.                     l1 += dl;
  3452.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3453.                     l = l1 >> 16;
  3454.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3455.                     i += i7;
  3456.                     j += k7;
  3457.                     l1 += dl;
  3458.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3459.                     l = l1 >> 16;
  3460.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3461.                     i += i7;
  3462.                     j += k7;
  3463.                     l1 += dl;
  3464.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3465.                     l = l1 >> 16;
  3466.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3467.                     i += i7;
  3468.                     j += k7;
  3469.                     l1 += dl;
  3470.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3471.                     l = l1 >> 16;
  3472.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3473.                     i += i7;
  3474.                     j += k7;
  3475.                     l1 += dl;
  3476.                     a1 += k2;
  3477.                     i2 += a2;
  3478.                     j2 += i3;
  3479.                     int j5 = j2 >> 12;
  3480.                     if(j5 != 0)
  3481.                     {
  3482.                         i4 = a1 / j5;
  3483.                         k4 = i2 / j5;
  3484.                         if(i4 < 7)
  3485.                             i4 = 7;
  3486.                         else
  3487.                         if(i4 > 4032)
  3488.                             i4 = 4032;
  3489.                     }
  3490.                     i7 = i4 - i >> 3;
  3491.                     k7 = k4 - j >> 3;
  3492.                     l1 += dl;
  3493.                 }
  3494.                 for(n = x2 - x1 & 7; n-- > 0;)
  3495.                 {
  3496.                     rgb = ai1[(j & 0xfc0) + (i >> 6)];
  3497.                     l = l1 >> 16;
  3498.                     ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3499.                     i += i7;
  3500.                     j += k7;
  3501.                     l1 += dl;
  3502.                 }
  3503.                 return;
  3504.             }
  3505.             while(n-- > 0)
  3506.             {
  3507.                 int k8;
  3508.                 int l;
  3509.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3510.                     l = l1 >> 16;
  3511.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3512.                 }
  3513.                 k++;
  3514.                 i += i7;
  3515.                 j += k7;
  3516.                 l1 += dl;
  3517.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3518.                     l = l1 >> 16;
  3519.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3520.                 }
  3521.                 k++;
  3522.                 i += i7;
  3523.                 j += k7;
  3524.                 l1 += dl;
  3525.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3526.                     l = l1 >> 16;
  3527.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3528.                 }
  3529.                 k++;
  3530.                 i += i7;
  3531.                 j += k7;
  3532.                 l1 += dl;
  3533.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3534.                     l = l1 >> 16;
  3535.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3536.                 }
  3537.                 k++;
  3538.                 i += i7;
  3539.                 j += k7;
  3540.                 l1 += dl;
  3541.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3542.                     l = l1 >> 16;
  3543.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3544.                 }
  3545.                 k++;
  3546.                 i += i7;
  3547.                 j += k7;
  3548.                 l1 += dl;
  3549.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3550.                     l = l1 >> 16;
  3551.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3552.                 }
  3553.                 k++;
  3554.                 i += i7;
  3555.                 j += k7;
  3556.                 l1 += dl;
  3557.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3558.                     l = l1 >> 16;
  3559.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3560.                 }
  3561.                 k++;
  3562.                 i += i7;
  3563.                 j += k7;
  3564.                 l1 += dl;
  3565.                 if((k8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3566.                     l = l1 >> 16;
  3567.                     ai[k] = ((k8 & 0xff00ff) * l & ~0xff00ff) + ((k8 & 0xff00) * l & 0xff0000) >> 8;
  3568.                 }
  3569.                 k++;
  3570.                 i += i7;
  3571.                 j += k7;
  3572.                 l1 += dl;
  3573.                 a1 += k2;
  3574.                 i2 += a2;
  3575.                 j2 += i3;
  3576.                 int k5 = j2 >> 12;
  3577.                 if(k5 != 0)
  3578.                 {
  3579.                     i4 = a1 / k5;
  3580.                     k4 = i2 / k5;
  3581.                     if(i4 < 7)
  3582.                         i4 = 7;
  3583.                     else
  3584.                     if(i4 > 4032)
  3585.                         i4 = 4032;
  3586.                 }
  3587.                 i7 = i4 - i >> 3;
  3588.                 k7 = k4 - j >> 3;
  3589.                 l1 += dl;
  3590.             }
  3591.             for(n = x2 - x1 & 7; n-- > 0;)
  3592.             {
  3593.                 int l8;
  3594.                 int l;
  3595.                 if((l8 = ai1[(j & 0xfc0) + (i >> 6)]) != 0) {
  3596.                     l = l1 >> 16;
  3597.                     ai[k] = ((l8 & 0xff00ff) * l & ~0xff00ff) + ((l8 & 0xff00) * l & 0xff0000) >> 8;
  3598.                 }
  3599.                 k++;
  3600.                 i += i7;
  3601.                 j += k7;
  3602.                 l1 += dl;
  3603.             }
  3604.  
  3605.             return;
  3606.         }
  3607.         int j4 = 0;
  3608.         int l4 = 0;
  3609.         int l6 = x1 - textureInt1;
  3610.         a1 += (k2 >> 3) * l6;
  3611.         i2 += (a2 >> 3) * l6;
  3612.         j2 += (i3 >> 3) * l6;
  3613.         int l5 = j2 >> 14;
  3614.         if(l5 != 0)
  3615.         {
  3616.             i = a1 / l5;
  3617.             j = i2 / l5;
  3618.             if(i < 0)
  3619.                 i = 0;
  3620.             else
  3621.             if(i > 16256)
  3622.                 i = 16256;
  3623.         }
  3624.         a1 += k2;
  3625.         i2 += a2;
  3626.         j2 += i3;
  3627.         l5 = j2 >> 14;
  3628.         if(l5 != 0)
  3629.         {
  3630.             j4 = a1 / l5;
  3631.             l4 = i2 / l5;
  3632.             if(j4 < 7)
  3633.                 j4 = 7;
  3634.             else
  3635.             if(j4 > 16256)
  3636.                 j4 = 16256;
  3637.         }
  3638.         int j7 = j4 - i >> 3;
  3639.         int l7 = l4 - j >> 3;
  3640.         if(aBoolean1463)
  3641.         {
  3642.             while(n-- > 0)
  3643.             {
  3644.                 int rgb;
  3645.                 int l;
  3646.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3647.                 l = l1 >> 16;
  3648.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3649.                 i += j7;
  3650.                 j += l7;
  3651.                 l1 += dl;
  3652.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3653.                 l = l1 >> 16;
  3654.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3655.                 i += j7;
  3656.                 j += l7;
  3657.                 l1 += dl;
  3658.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3659.                 l = l1 >> 16;
  3660.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3661.                 i += j7;
  3662.                 j += l7;
  3663.                 l1 += dl;
  3664.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3665.                 l = l1 >> 16;
  3666.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3667.                 i += j7;
  3668.                 j += l7;
  3669.                 l1 += dl;
  3670.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3671.                 l = l1 >> 16;
  3672.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3673.                 i += j7;
  3674.                 j += l7;
  3675.                 l1 += dl;
  3676.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3677.                 l = l1 >> 16;
  3678.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3679.                 i += j7;
  3680.                 j += l7;
  3681.                 l1 += dl;
  3682.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3683.                 l = l1 >> 16;
  3684.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3685.                 i += j7;
  3686.                 j += l7;
  3687.                 l1 += dl;
  3688.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3689.                 l = l1 >> 16;
  3690.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3691.                 i += j7;
  3692.                 j += l7;
  3693.                 l1 += dl;
  3694.                 a1 += k2;
  3695.                 i2 += a2;
  3696.                 j2 += i3;
  3697.                 int i6 = j2 >> 14;
  3698.                 if(i6 != 0)
  3699.                 {
  3700.                     j4 = a1 / i6;
  3701.                     l4 = i2 / i6;
  3702.                     if(j4 < 7)
  3703.                         j4 = 7;
  3704.                     else
  3705.                     if(j4 > 16256)
  3706.                         j4 = 16256;
  3707.                 }
  3708.                 j7 = j4 - i >> 3;
  3709.                 l7 = l4 - j >> 3;
  3710.                 l1 += dl;
  3711.             }
  3712.             for(n = x2 - x1 & 7; n-- > 0;)
  3713.             {
  3714.                 int rgb;
  3715.                 int l;
  3716.                 rgb = ai1[(j & 0x3f80) + (i >> 7)];
  3717.                 l = l1 >> 16;
  3718.                 ai[k++] = ((rgb & 0xff00ff) * l & ~0xff00ff) + ((rgb & 0xff00) * l & 0xff0000) >> 8;
  3719.                 i += j7;
  3720.                 j += l7;
  3721.                 l1 += dl;
  3722.             }
  3723.  
  3724.             return;
  3725.         }
  3726.         while(n-- > 0)
  3727.         {
  3728.             int i9;
  3729.             int l;
  3730.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3731.                 l = l1 >> 16;
  3732.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3733.             }
  3734.             k++;
  3735.             i += j7;
  3736.             j += l7;
  3737.             l1 += dl;
  3738.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3739.                 l = l1 >> 16;
  3740.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3741.             }
  3742.             k++;
  3743.             i += j7;
  3744.             j += l7;
  3745.             l1 += dl;
  3746.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3747.                 l = l1 >> 16;
  3748.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3749.             }
  3750.             k++;
  3751.             i += j7;
  3752.             j += l7;
  3753.             l1 += dl;
  3754.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3755.                 l = l1 >> 16;
  3756.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3757.             }
  3758.             k++;
  3759.             i += j7;
  3760.             j += l7;
  3761.             l1 += dl;
  3762.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3763.                 l = l1 >> 16;
  3764.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3765.             }
  3766.             k++;
  3767.             i += j7;
  3768.             j += l7;
  3769.             l1 += dl;
  3770.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3771.                 l = l1 >> 16;
  3772.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3773.             }
  3774.             k++;
  3775.             i += j7;
  3776.             j += l7;
  3777.             l1 += dl;
  3778.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3779.                 l = l1 >> 16;
  3780.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3781.             }
  3782.             k++;
  3783.             i += j7;
  3784.             j += l7;
  3785.             l1 += dl;
  3786.             if((i9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3787.                 l = l1 >> 16;
  3788.                 ai[k] = ((i9 & 0xff00ff) * l & ~0xff00ff) + ((i9 & 0xff00) * l & 0xff0000) >> 8;;
  3789.             }
  3790.             k++;
  3791.             i += j7;
  3792.             j += l7;
  3793.             l1 += dl;
  3794.             a1 += k2;
  3795.             i2 += a2;
  3796.             j2 += i3;
  3797.             int j6 = j2 >> 14;
  3798.             if(j6 != 0)
  3799.             {
  3800.                 j4 = a1 / j6;
  3801.                 l4 = i2 / j6;
  3802.                 if(j4 < 7)
  3803.                     j4 = 7;
  3804.                 else
  3805.                 if(j4 > 16256)
  3806.                     j4 = 16256;
  3807.             }
  3808.             j7 = j4 - i >> 3;
  3809.             l7 = l4 - j >> 3;
  3810.             l1 += dl;
  3811.         }
  3812.         for(int l3 = x2 - x1 & 7; l3-- > 0;)
  3813.         {
  3814.             int j9;
  3815.             int l;
  3816.             if((j9 = ai1[(j & 0x3f80) + (i >> 7)]) != 0) {
  3817.                 l = l1 >> 16;
  3818.                 ai[k] = ((j9 & 0xff00ff) * l & ~0xff00ff) + ((j9 & 0xff00) * l & 0xff0000) >> 8;;
  3819.             }
  3820.             k++;
  3821.             i += j7;
  3822.             j += l7;
  3823.             l1 += dl;
  3824.         }
  3825.  
  3826.     }
  3827.  
  3828.     public static final int anInt1459 = -477;
  3829.     public static boolean lowMem = true;
  3830.     static boolean aBoolean1462;
  3831.     private static boolean aBoolean1463;
  3832.     public static boolean aBoolean1464 = true;
  3833.     public static int anInt1465;
  3834.     public static int textureInt1;
  3835.     public static int textureInt2;
  3836.     private static int[] anIntArray1468;
  3837.     public static final int[] anIntArray1469;
  3838.     public static int anIntArray1470[];
  3839.     public static int anIntArray1471[];
  3840.     public static int anIntArray1472[];
  3841.     private static int anInt1473;
  3842.     public static Background aBackgroundArray1474s[] = new Background[50];
  3843.     private static boolean[] aBooleanArray1475 = new boolean[50];
  3844.     private static int[] anIntArray1476 = new int[50];
  3845.     private static int anInt1477;
  3846.     private static int[][] anIntArrayArray1478;
  3847.     private static int[][] anIntArrayArray1479 = new int[50][];
  3848.     public static int anIntArray1480[] = new int[50];
  3849.     public static int anInt1481;
  3850.     public static int anIntArray1482[] = new int[0x10000];
  3851.     private static int[][] anIntArrayArray1483 = new int[50][];
  3852.  
  3853.     static
  3854.     {
  3855.         anIntArray1468 = new int[512];
  3856.         anIntArray1469 = new int[2048];
  3857.         anIntArray1470 = new int[2048];
  3858.         anIntArray1471 = new int[2048];
  3859.         for(int i = 1; i < 512; i++)
  3860.             anIntArray1468[i] = 32768 / i;
  3861.  
  3862.         for(int j = 1; j < 2048; j++)
  3863.             anIntArray1469[j] = 0x10000 / j;
  3864.  
  3865.         for(int k = 0; k < 2048; k++)
  3866.         {
  3867.             anIntArray1470[k] = (int)(65536D * Math.sin((double)k * 0.0030679614999999999D));
  3868.             anIntArray1471[k] = (int)(65536D * Math.cos((double)k * 0.0030679614999999999D));
  3869.         }
  3870.  
  3871.     }
  3872. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!