Guest User

End Step

a guest
Sep 26th, 2016
56
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //draw to surface
  2. surface_set_target(global.surid);
  3.  
  4. //list stuff
  5. var aAC,aBC,aAB,bpassed,t,zAC,zAB,zBC,ABDiff,BCDiff,ACDiff,y1,y2,z1,z2,drawn;
  6. m = 0;
  7. n = 0;
  8. a = 0;
  9. b = 0;
  10. c = 0;
  11. count = 0;
  12. drawn = false;
  13.  
  14. //start loop through vertices
  15. repeat(12)
  16. {
  17. bpassed = false;
  18.  
  19. sxt[0] = round((vertex_x[count]*Ez)/(-vertex_z[count]+Ez)+Ex);
  20. syt[0] = round((vertex_y[count]*Ez)/(-vertex_z[count]+Ez)+Ey);
  21. sxt[1] = round((vertex_x[count+1]*Ez)/(-vertex_z[count+1]+Ez)+Ex);
  22. syt[1] = round((vertex_y[count+1]*Ez)/(-vertex_z[count+1]+Ez)+Ey);
  23. sxt[2] = round((vertex_x[count+2]*Ez)/(-vertex_z[count+2]+Ez)+Ex);
  24. syt[2] = round((vertex_y[count+2]*Ez)/(-vertex_z[count+2]+Ez)+Ey);
  25. vertex_z[count] = 1/vertex_z[count];
  26. vertex_z[count+1] = 1/vertex_z[count+1];
  27. vertex_z[count+2] = 1/vertex_z[count+2];
  28.  
  29.     switch count
  30.     {
  31.     case 0:
  32.     draw_set_color(c_red); coly = c_red; break;
  33.     case 3:
  34.     draw_set_color(c_red); coly = c_red; break;
  35.     case 6:
  36.     draw_set_color(c_yellow); coly = c_yellow; break;
  37.     case 9:
  38.     draw_set_color(c_blue); coly = c_blue; break;
  39.     case 12:
  40.     draw_set_color(c_yellow); coly = c_yellow; break;
  41.     case 15:
  42.     draw_set_color(c_blue); coly = c_blue; break;
  43.     case 18:
  44.     draw_set_color(c_green); coly = c_green; break;
  45.     case 21:
  46.     draw_set_color(c_purple); coly = c_purple; break;
  47.     case 24:
  48.     draw_set_color(c_green); coly = c_green; break;
  49.     case 27:
  50.     draw_set_color(c_purple); coly = c_purple; break;
  51.     case 30:
  52.     draw_set_color(c_orange); coly = c_orange; break;
  53.     case 33:
  54.     draw_set_color(c_orange); coly = c_orange; break;
  55.     }
  56.    
  57. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  58.     if sxt[0]<sxt[1]
  59.     {
  60.         if sxt[1]<sxt[2]
  61.         {
  62.         a = 0;
  63.         b = 1;
  64.         c = 2;
  65.         }
  66.     }
  67.     if sxt[0]<sxt[2]
  68.     {
  69.         if sxt[2]<sxt[1]
  70.         {
  71.         a = 0;
  72.         b = 2;
  73.         c = 1;
  74.         }
  75.     }
  76.     if sxt[1]<sxt[2]
  77.     {
  78.         if sxt[2]<sxt[0]
  79.         {
  80.         a = 1;
  81.         b = 2;
  82.         c = 0;
  83.         }
  84.     }
  85.     if sxt[1]<sxt[0]
  86.     {
  87.         if sxt[0]<sxt[2]
  88.         {
  89.         a = 1;
  90.         b = 0;
  91.         c = 2;
  92.         }
  93.     }
  94.     if sxt[2]<sxt[1]
  95.     {
  96.         if sxt[1]<sxt[0]
  97.         {
  98.         a = 2;
  99.         b = 1;
  100.         c = 0;
  101.         }
  102.     }
  103.     if sxt[2]<sxt[0]
  104.     {
  105.         if sxt[0]<sxt[1]
  106.         {
  107.         a = 2;
  108.         b = 0;
  109.         c = 1;
  110.         }
  111.     }
  112.  
  113. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  114.     if a != 0 or b != 0 or c != 0
  115.     {
  116.     m = sxt[a];
  117.     n = syt[a];
  118.     tempz = vertex_z[count+a];
  119.     y1 = n//v3.x; the main helper
  120.     y2 = n + 0.5 //v3.x + 0.5f; the other helper
  121.     aAC = (syt[c] - syt[a] )/(sxt[c] - sxt[a]);
  122.     aAB = (syt[a] - syt[b] )/(sxt[a] - sxt[b]);
  123.     aBC = (syt[b] - syt[c] )/(sxt[b] - sxt[c]);
  124.     ABDiff = sxt[b] - sxt[a];
  125.     BCDiff = sxt[c] - sxt[b];
  126.     ACDiff = sxt[c] - sxt[a];
  127.     zAC = (vertex_z[count+a] - vertex_z[count+c])/ACDiff;
  128.     zAB = (vertex_z[count+a] - vertex_z[count+b])/ABDiff;
  129.     zBC = (vertex_z[count+b] - vertex_z[count+c])/BCDiff;
  130.  
  131.     /* get the change of color components along edge (v3,v1) */
  132.     //v3v1Diff = (v3.y - v1.y);
  133.     //colorSlopeBlue1 = (a.getBlue() - c1.getBlue()) / v3v1Diff;
  134.     //colorSlopeRed1 = (a.getRed() - c1.getRed()) / v3v1Diff;
  135.     //colorSlopeGreen1 = (a.getGreen() - c1.getGreen()) / v3v1Diff;
  136.     /* get the change of color components along edge (v3,v2) */
  137.     //v3v2Diff = (v3.y - v2.y);
  138.     //colorSlopeBlue2 = (a.getBlue() - c2.getBlue()) / v3v2Diff;
  139.     //colorSlopeRed2 = (a.getRed() - c2.getRed()) / v3v2Diff;
  140.     //colorSlopeGreen2 = (a.getGreen() - c2.getGreen()) / v3v2Diff;
  141.  
  142.     /* set starting values */
  143.     /*
  144.     cBlue1 = a.getBlue();
  145.     cRed1 = a.getRed();
  146.     cGreen1 = a.getGreen();
  147.     cBlue2 = a.getBlue();
  148.     cRed2 = a.getRed();
  149.     cGreen2 = a.getGreen();
  150.     */
  151.     z1 = tempz;
  152.     z2 = tempz;
  153.    
  154.         if aAC*sxt[b] + (syt[c] - aAC * sxt[c]) < syt[b]
  155.         {
  156.         /* makes sense with situations
  157.             if (aAB < slope2)
  158.             {
  159.             float slopeTmp = aAB;
  160.             aAB = slope2;
  161.             slope2 = slopeTmp;
  162.            
  163.             slopeTmp = colorSlopeRed1;
  164.             colorSlopeRed1 = colorSlopeRed2;
  165.             colorSlopeRed2 = slopeTmp;
  166.            
  167.             slopeTmp = colorSlopeGreen1;
  168.             colorSlopeGreen1 = colorSlopeGreen2;
  169.             colorSlopeGreen2 = slopeTmp;
  170.            
  171.             slopeTmp = colorSlopeBlue1;
  172.             colorSlopeBlue1 = colorSlopeBlue2;
  173.             colorSlopeBlue2 = slopeTmp;
  174.             }*/
  175.             repeat(sxt[b] - sxt[a])//x until b
  176.             {
  177.                 if m < view_wport
  178.                 {
  179.                     if m >= 0
  180.                     {
  181.                         repeat(round(y2)-round(y1))//y
  182.                         {
  183.                             if n < view_hport
  184.                             {
  185.                                 if n >= 0
  186.                                 {
  187.                                     if global.Zbuffer[m,n] < tempz
  188.                                     {
  189.                                     //int red = (int)((1 - t) * cRed1 + t * cRed2);
  190.                                     //write to z-buffer
  191.                                     global.Zbuffer[m,n] = tempz
  192.                                     //draw pixel
  193.                                     scr_render();
  194.                                     }
  195.                                 }
  196.                             }
  197.                             else
  198.                             break;
  199.                         t = (n - y1) / (y2 - y1);
  200.                         tempz = (1-t)* z1 + t * z2;
  201.                         n += 1;
  202.                         }
  203.                     }  
  204.                 }
  205.                 else
  206.                 break;
  207.             y1 += aAC;
  208.             z1 -= zAC;
  209.             //if n > testo or n < testu
  210.             //show_message(string(bpassed)+"A"+string(count)+"_"+string(y1)+"_"+string(y2)+"_"+string(aAC)+"_"+string(aBC)+"_"+string(aAB));
  211.             n = round(y1);
  212.             y2 += aAB;
  213.             z2 -= zAB;
  214.             /* get new color of left endpoint of vertical line */
  215.             //cRed1 -= colorSlopeRed1;
  216.             //cGreen1 -= colorSlopeGreen1;
  217.             //cBlue1 -= colorSlopeBlue1;
  218.             /* get new color of right endpoint of horizontal line */
  219.             //cRed2 -= colorSlopeRed2;
  220.             //cGreen2 -= colorSlopeGreen2;
  221.             //cBlue2 -= colorSlopeBlue2;
  222.             m +=1;
  223.             }
  224.             repeat(sxt[c] - sxt[b])//x until c
  225.             {
  226.                 if m < view_wport
  227.                 {
  228.                     if m >= 0
  229.                     {
  230.                         repeat(round(y2)-round(y1))//y
  231.                         {
  232.  
  233.                             if n < view_hport
  234.                             {
  235.                                 if n >= 0
  236.                                 {
  237.                                     if global.Zbuffer[m,n] < tempz
  238.                                     {
  239.                                     //int red = (int)((1 - t) * cRed1 + t * cRed2);
  240.                                     //write to z-buffer
  241.                                     global.Zbuffer[m,n] = tempz
  242.                                     //draw pixel
  243.                                     scr_render();
  244.                                     }
  245.                                 }
  246.                             }
  247.                             else
  248.                             break;
  249.                         t = (n - y1) / (y2 - y1);
  250.                         tempz = (1-t)* z1 + t * z2;
  251.                         n += 1;
  252.                         }
  253.                     }  
  254.                 }
  255.                 else
  256.                 break;
  257.             y1 += aAC;
  258.             z1 -= zAC;
  259.             n = round(y1);
  260.             y2 += aBC;
  261.             z2 -= zBC;
  262.             m +=1;
  263.             }
  264.         }
  265.         else
  266.         {
  267.         /* makes sense with situations
  268.             if (aAB < slope2)
  269.             {
  270.             float slopeTmp = aAB;
  271.             aAB = slope2;
  272.             slope2 = slopeTmp;
  273.            
  274.             slopeTmp = colorSlopeRed1;
  275.             colorSlopeRed1 = colorSlopeRed2;
  276.             colorSlopeRed2 = slopeTmp;
  277.            
  278.             slopeTmp = colorSlopeGreen1;
  279.             colorSlopeGreen1 = colorSlopeGreen2;
  280.             colorSlopeGreen2 = slopeTmp;
  281.            
  282.             slopeTmp = colorSlopeBlue1;
  283.             colorSlopeBlue1 = colorSlopeBlue2;
  284.             colorSlopeBlue2 = slopeTmp;
  285.             }*/
  286.             repeat(sxt[b] - sxt[a])//x until b
  287.             {
  288.                 if m < view_wport
  289.                 {
  290.                     if m >= 0
  291.                     {
  292.                         repeat(round(y1)-round(y2))//y
  293.                         {
  294.                             if n >= 0
  295.                             {
  296.                                 if n < view_hport
  297.                                 {
  298.                                     if global.Zbuffer[m,n] < tempz
  299.                                     {
  300.                                     //int red = (int)((1 - t) * cRed1 + t * cRed2);
  301.                                     //write to z-buffer
  302.                                     global.Zbuffer[m,n] = tempz
  303.                                     //draw pixel
  304.                                     scr_render();
  305.                                     }
  306.                                 }
  307.                             }
  308.                             else
  309.                             break;
  310.                         t = (n - y1) / (y2 - y1);
  311.                         tempz = (1-t)* z1 + t * z2;
  312.                         n -= 1;
  313.                         }
  314.                     }  
  315.                 }
  316.                 else
  317.                 break;
  318.             y1 += aAC;
  319.             z1 -= zAC;
  320.             //if n > testo or n < testu
  321.             //show_message(string(bpassed)+"A"+string(count)+"_"+string(y1)+"_"+string(y2)+"_"+string(aAC)+"_"+string(aBC)+"_"+string(aAB));
  322.             n = round(y1);
  323.             y2 += aAB;
  324.             z2 -= zAB;
  325.             /* get new color of left endpoint of vertical line */
  326.             //cRed1 -= colorSlopeRed1;
  327.             //cGreen1 -= colorSlopeGreen1;
  328.             //cBlue1 -= colorSlopeBlue1;
  329.             /* get new color of right endpoint of horizontal line */
  330.             //cRed2 -= colorSlopeRed2;
  331.             //cGreen2 -= colorSlopeGreen2;
  332.             //cBlue2 -= colorSlopeBlue2;
  333.             m +=1;
  334.             }
  335.             repeat(sxt[c] - sxt[b])//x until c
  336.             {
  337.                 if m < view_wport
  338.                 {
  339.                     if m >= 0
  340.                     {
  341.                         repeat(round(y1)-round(y2))//y
  342.                         {
  343.                             if n >= 0
  344.                             {
  345.                                 if n < view_hport
  346.                                 {
  347.                                     if global.Zbuffer[m,n] < tempz
  348.                                     {
  349.                                     //int red = (int)((1 - t) * cRed1 + t * cRed2);
  350.                                     //write to z-buffer
  351.                                     global.Zbuffer[m,n] = tempz
  352.                                     //draw pixel
  353.                                     scr_render();
  354.                                     }
  355.                                 }
  356.                             }
  357.                             else
  358.                             break;
  359.                         t = (n - y1) / (y2 - y1);
  360.                         tempz = (1-t)* z1 + t * z2;
  361.                         n -= 1;
  362.                         }
  363.                     }  
  364.                 }
  365.                 else
  366.                 break;
  367.             y1 += aAC;
  368.             z1 -= zAC;
  369.             n = round(y1);
  370.             y2 += aBC;
  371.             z2 -= zBC;
  372.             m +=1;
  373.             }
  374.         }
  375.         drawn = true;
  376.         a = 0;
  377.         b = 0;
  378.         c = 0;
  379.     }
  380.     else
  381.     {            
  382.     if sxt[1]<sxt[2]/////////////////////////////////////////////////////////////////////////////////////////////////////////////
  383.     {
  384.         if sxt[0]=sxt[1]
  385.         {  
  386.             if syt[0] < syt[1]
  387.             {
  388.             a = 0;
  389.             b = 1;
  390.             c = 2;
  391.             }
  392.             else
  393.             {
  394.             a = 1;
  395.             b = 0;
  396.             c = 2;
  397.             }
  398.         }
  399.         else if sxt[2]=sxt[0]
  400.         {
  401.             if syt[2] < syt[0]
  402.             {
  403.             a = 1;
  404.             b = 0;
  405.             c = 2;
  406.             }
  407.             else
  408.             {
  409.             a = 1;
  410.             b = 2;
  411.             c = 0;
  412.             }
  413.         }
  414.     }
  415.     else if sxt[2]<sxt[1]
  416.     {
  417.         if sxt[0]=sxt[2]
  418.         {  
  419.             if syt[0] < syt[2]
  420.             {
  421.             a = 0;
  422.             b = 2;
  423.             c = 1;
  424.             }
  425.             else
  426.             {
  427.             a = 2;
  428.             b = 0;
  429.             c = 1;
  430.             }
  431.         }
  432.         else if sxt[1]=sxt[0]
  433.         {  
  434.             if syt[1] < syt[0]
  435.             {
  436.             a = 2;
  437.             b = 0;
  438.             c = 1;
  439.             }
  440.             else
  441.             {
  442.             a = 2;
  443.             b = 1;
  444.             c = 0;
  445.             }
  446.         }
  447.     }
  448.     else if sxt[2]<sxt[0]
  449.     {
  450.         if sxt[1]=sxt[2]
  451.         {  
  452.             if syt[1] < syt[2]
  453.             {
  454.             a = 1;
  455.             b = 2;
  456.             c = 0;
  457.             }
  458.             else
  459.             {
  460.             a = 2;
  461.             b = 1;
  462.             c = 0;
  463.             }
  464.         }
  465.     }
  466.     else if sxt[0]<sxt[1]
  467.     {
  468.         if sxt[1]=sxt[2]
  469.         {  
  470.             if syt[1] < syt[2]
  471.             {
  472.             a = 0;
  473.             b = 2;
  474.             c = 1;
  475.             }
  476.             else
  477.             {
  478.             a = 0;
  479.             b = 1;
  480.             c = 2;
  481.             }
  482.         }
  483.     }
  484. }
  485. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  486.     if (a != 0 or b != 0 or c != 0) and drawn = false
  487.     {
  488.     m = sxt[a];
  489.     n = syt[a];
  490.     tempz = vertex_z[count+a];
  491.     y1 = n//v3.x; the main helper
  492.     y2 = n+ 0.5 //v3.x + 0.5f; the other helper
  493.     /* get the change of color components along edge (v3,v1) */
  494.     //v3v1Diff = (v3.y - v1.y);
  495.     //colorSlopeBlue1 = (a.getBlue() - c1.getBlue()) / v3v1Diff;
  496.     //colorSlopeRed1 = (a.getRed() - c1.getRed()) / v3v1Diff;
  497.     //colorSlopeGreen1 = (a.getGreen() - c1.getGreen()) / v3v1Diff;
  498.     /* get the change of color components along edge (v3,v2) */
  499.     //v3v2Diff = (v3.y - v2.y);
  500.     //colorSlopeBlue2 = (a.getBlue() - c2.getBlue()) / v3v2Diff;
  501.     //colorSlopeRed2 = (a.getRed() - c2.getRed()) / v3v2Diff;
  502.     //colorSlopeGreen2 = (a.getGreen() - c2.getGreen()) / v3v2Diff;
  503.  
  504.     /* set starting values */
  505.     /*
  506.     cBlue1 = a.getBlue();
  507.     cRed1 = a.getRed();
  508.     cGreen1 = a.getGreen();
  509.     cBlue2 = a.getBlue();
  510.     cRed2 = a.getRed();
  511.     cGreen2 = a.getGreen();
  512.     */
  513.     z1 = tempz;
  514.     z2 = tempz;
  515.         if sxt[a] = sxt[b]
  516.         {
  517.         aBC = (syt[b] - syt[c] )/(sxt[b] - sxt[c]);
  518.         aAC = (syt[c] - syt[a] )/(sxt[c] - sxt[a]);
  519.         BCDiff = sxt[c] - sxt[b];
  520.         ACDiff = sxt[c] - sxt[a];
  521.         y2 = syt[b];
  522.         zAC = (vertex_z[count+a] - vertex_z[count+c])/ACDiff;
  523.         zBC = (vertex_z[count+b] - vertex_z[count+c])/BCDiff
  524.             repeat(sxt[c] - sxt[a])
  525.             {
  526.                 if m < view_wport
  527.                 {
  528.                     if m >= 0
  529.                     {
  530.                         repeat(round(y2)-round(y1))
  531.                         {
  532.  
  533.                             if n < view_hport
  534.                             {
  535.                                 if n >= 0
  536.                                 {
  537.                                     if global.Zbuffer[m,n] < tempz
  538.                                     {
  539.                                     //write to z-buffer
  540.                                     global.Zbuffer[m,n] = tempz
  541.                                     //draw pixel
  542.                                     scr_render();
  543.                                     }
  544.                                 }
  545.                             }
  546.                             else
  547.                             break;
  548.                         t = (n - y1) / (y2 - y1);
  549.                         tempz = (1-t)* z1 + t * z2;
  550.                         n += 1;
  551.                         }
  552.                     }
  553.                 }
  554.                 else
  555.                 break;
  556.                
  557.             y1 += aAC;
  558.             z1 -= zAC;
  559.             n = round(y1);
  560.             y2 += aBC;
  561.             z2 -= zBC;
  562.             m += 1;
  563.             }//loop until last point is reached
  564.         }
  565.         else
  566.         {
  567.         //pre calculating slopes for interpolation
  568.         aAB = (syt[a] - syt[b] )/(sxt[a] - sxt[b]) ;
  569.         aAC = (syt[c] - syt[a] )/(sxt[c] - sxt[a]);
  570.         ABDiff = sxt[b] - sxt[a];
  571.         ACDiff = sxt[c] - sxt[a];
  572.         zAC = (vertex_z[count+a] - vertex_z[count+c])/ACDiff;
  573.         zAB = (vertex_z[count+a] - vertex_z[count+b])/ABDiff
  574.             repeat(sxt[c] - sxt[a])
  575.             {
  576.                 if  m < view_wport
  577.                 {
  578.                     if m >= 0
  579.                     {
  580.                         repeat(round(y2)-round(y1))
  581.                         {
  582.  
  583.                             if n < view_hport
  584.                             {
  585.                                 if n >= 0
  586.                                 {
  587.                                     if global.Zbuffer[m,n] < tempz
  588.                                     {
  589.                                     //write to z-buffer
  590.                                     global.Zbuffer[m,n] = tempz
  591.                                     //draw pixel
  592.                                     scr_render();
  593.                                     }
  594.                                 }
  595.                             }
  596.                             else
  597.                             break;
  598.                         t = (n - y1) / (y2 - y1);
  599.                         tempz = (1-t)* z1 + t * z2;
  600.                         n += 1;
  601.                         }
  602.                     }
  603.                 }
  604.                 else
  605.                 break;    
  606.             y1 += aAC;
  607.             z1 -= zAC;
  608.             n = round(y1);
  609.             y2 += aAB;
  610.             z2 -= zAB;
  611.             m += 1;
  612.             }//loop until last point is reached
  613.         }
  614.     }//if sxt[2]=sxt[1]and sxt[1]=sxt[0] and sxt[0] >= 0 and sxt[0] < view_wport///////////////////////////////////////////////////
  615.     else if drawn = false//the last and most bull-shit draw
  616.     {
  617.     m = sxt[0]
  618.         if syt[0] > syt[1] and syt[1] > syt[2]
  619.         {
  620.         a = 2;
  621.         b = 1;
  622.         c = 0;
  623.         }
  624.         else if syt[0] > syt[2] and syt[2] > syt[1]
  625.         {
  626.         a = 1;
  627.         b = 2;
  628.         c = 0;
  629.         }
  630.         else if syt[1] > syt[0] and syt[0] > syt[2]
  631.         {
  632.         a = 2;
  633.         b = 0;
  634.         c = 1;
  635.         }
  636.         else if syt[1] > syt[2] and syt[2] > syt[0]
  637.         {
  638.         a = 0;
  639.         b = 2;
  640.         c = 1;
  641.         }
  642.         else if syt[2] > syt[0] and syt[0] > syt[1]
  643.         {
  644.         a = 1;
  645.         b = 0;
  646.         c = 2;
  647.         }
  648.         else if syt[2] > syt[1] and syt[1] > syt[0]
  649.         {
  650.         a = 0;
  651.         b = 1;
  652.         c = 2;
  653.         }
  654.         tempz = vertex_z[count+a];
  655.         n = syt[a];
  656.        
  657.         if round(vertex_z[count+a] - vertex_z[count+c]) != 0
  658.         {
  659.             if syt[b] > (syt[a] - syt[c])/(vertex_z[count+a] - vertex_z[count+c]) * vertex_z[count+b] + (syt[a] - vertex_z[count+a] * (syt[a] - syt[c])/(vertex_z[count+a] - vertex_z[count+c]))
  660.             {
  661.             ABDiff = syt[b] - syt[a];
  662.             BCDiff = syt[c] - syt[b];
  663.             zAB = (vertex_z[count+a] - vertex_z[count+b])/ABDiff
  664.             zBC = (vertex_z[count+b] - vertex_z[count+c])/BCDiff
  665.                 repeat(ABDiff)
  666.                 {
  667.                     if n <= view_hport
  668.                     {
  669.                         if n >= 0
  670.                         {
  671.                             if global.Zbuffer[sxt[c],n] < 1/tempz
  672.                             {
  673.                             //write to z-buffer
  674.                             global.Zbuffer[sxt[c],n] = 1/tempz
  675.                             //draw pixel
  676.                             scr_render();
  677.                             }
  678.                         }
  679.                     }
  680.                     else
  681.                     break;
  682.                 n += 1;
  683.                 tempz -= zAB
  684.                 }
  685.                 repeat(BCDiff)
  686.                 {
  687.                     if n <= view_hport
  688.                     {
  689.                         if n >= 0
  690.                         {
  691.                             if global.Zbuffer[sxt[c],n] < 1/tempz
  692.                             {
  693.                             //write to z-buffer
  694.                             global.Zbuffer[sxt[c],n] = 1/tempz
  695.                             //draw pixel
  696.                             scr_render();
  697.                             }
  698.                         }
  699.                     }
  700.                     else
  701.                     break;
  702.                 n += 1;
  703.                 tempz -= zBC
  704.                 }
  705.             }
  706.             else
  707.             {
  708.             ACDiff = syt[c] - syt[a];
  709.                 if vertex_z[count+c] > vertex_z[count+a]
  710.                 zAC = (vertex_z[count+c] - vertex_z[count+a])/ACDiff
  711.                 else
  712.                 zAC = (vertex_z[count+a] - vertex_z[count+c])/ACDiff
  713.    
  714.                 repeat(ACDiff)
  715.                 {
  716.                     if n <= view_hport
  717.                     {
  718.                         if n >= 0
  719.                         {
  720.                             if global.Zbuffer[sxt[c],n] < tempz
  721.                             {
  722.                             //write to z-buffer
  723.                             global.Zbuffer[sxt[c],n] = tempz
  724.                             //draw pixel
  725.                             scr_render();
  726.                             }
  727.                         }
  728.                     }
  729.                     else
  730.                     break;
  731.                 n += 1;
  732.                 tempz -= zAC
  733.                 }
  734.             }
  735.         }
  736.         else if vertex_z[a] < vertex_z[b]
  737.         {
  738.         ABDiff = syt[b] - syt[a];
  739.         BCDiff = syt[c] - syt[b];
  740.             if vertex_z[count+c] > vertex_z[count+a]
  741.             zAB = (vertex_z[count+b] - vertex_z[count+a])/ABDiff
  742.             else
  743.             zAB = (vertex_z[count+a] - vertex_z[count+b])/ABDiff
  744.             if vertex_z[count+c] > vertex_z[count+b]
  745.             zBC = (vertex_z[count+c] - vertex_z[count+b])/BCDiff
  746.             else
  747.             zBC = (vertex_z[count+b] - vertex_z[count+c])/BCDiff
  748.        
  749.             repeat(ABDiff)
  750.             {
  751.                 if n <= view_hport
  752.                 {
  753.                     if n >= 0
  754.                     {
  755.                         if global.Zbuffer[sxt[c],n] < 1/tempz
  756.                         {
  757.                         //write to z-buffer
  758.                         global.Zbuffer[sxt[c],n] = 1/tempz
  759.                         //draw pixel
  760.                         scr_render();
  761.                         }
  762.                     }
  763.                 }
  764.                 else
  765.                 break;
  766.             n += 1;
  767.             tempz -= zAB
  768.             }
  769.             repeat(BCDiff)
  770.             {
  771.                 if n <= view_hport
  772.                 {
  773.                     if n >= 0
  774.                     {
  775.                         if global.Zbuffer[sxt[c],n] < 1/tempz
  776.                         {
  777.                         //write to z-buffer
  778.                         global.Zbuffer[sxt[c],n] = 1/tempz
  779.                         //draw pixel
  780.                         scr_render();
  781.                         }
  782.                     }
  783.                 }
  784.                 else
  785.                 break;
  786.             n += 1;
  787.             tempz -= zBC
  788.             }
  789.         }
  790.         else
  791.         {
  792.             repeat(syt[c]-syt[a])
  793.             {
  794.                 if n <= view_hport
  795.                 {
  796.                     if n >= 0
  797.                     {
  798.                         if global.Zbuffer[sxt[c],n] < tempz
  799.                         {
  800.                         //write to z-buffer
  801.                         global.Zbuffer[sxt[c],n] = tempz
  802.                         //draw pixel
  803.                         scr_render();
  804.                         }
  805.                     }
  806.                 }
  807.                 else
  808.                 break;
  809.             n += 1;
  810.             }
  811.         }
  812.     }
  813. //all drawing end here.
  814. //some variables are cleared and the loop continues
  815. count += 3;
  816. draw_set_alpha(1);
  817. a = 0;
  818. b = 0;
  819. c = 0;
  820. drawn = false;
  821. }
  822. //once all vertices are done, stop drawing on this surface and go to the draw output
  823. surface_reset_target();
RAW Paste Data