API tools faq
paste
Guest User

End Step

a guest
Sep 26th, 2016
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Game Maker 25.05 KB | None | 0 0
raw download clone embed print report
  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();
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!