API tools faq
paste
Advertisement
TheGhastModding

MCTest.c

TheGhastModding
Feb 24th, 2019
549
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 25.13 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * MCTest.c
  3.  *
  4.  * Created: 2/23/2019 4:41:28 PM
  5.  *  Author: lucah
  6.  */
  7.  
  8. #ifndef F_CPU
  9. #define F_CPU 20000000
  10. #endif
  11.  
  12. #include <avr/io.h>
  13. #include <util/delay.h>
  14. #include <stdlib.h>
  15. #include <stdio.h>
  16. #include <stdfix.h>
  17. #include "ff.h"
  18. #include "textures.h"
  19.  
  20. //Don't make any of these larger then 120 and make sure that the world can even still fit into RAM
  21. //world size (in bytes) = WORLD_WIDTH * WORLD_HEIGHT * WORLD_DEPTH
  22. #define WORLD_WIDTH 16
  23. #define WORLD_HEIGHT 16
  24. #define WORLD_DEPTH 16
  25.  
  26. //debug things
  27. static int uart_putchar(char c, FILE *stream){
  28.    
  29.     while(!(UCSR0A & (1<<UDRE0)));
  30.     UDR0 = c;
  31.    
  32.     return 0;
  33. }
  34.  
  35. #ifdef FLOATING_POINT
  36. float toRadians(float deg){
  37.     return deg * 0.017453292519943295f;
  38. }
  39. #else
  40. accum toRadians(accum deg){
  41.     return deg * 0.017453292519943295K;
  42. }
  43. #endif
  44.  
  45. //The World
  46. uint8_t blocks[WORLD_WIDTH][WORLD_HEIGHT][WORLD_DEPTH];
  47.  
  48. int main(void){
  49.    
  50.     int width = 160;
  51.     int height = 128;
  52.     //This controls the quality of the rays. The higher, the better the quality
  53.     //Decreasing this too much will also increase the amount of glitches in the render
  54.     uint8_t stepResolution = 16;
  55.    
  56.     CLKPR = (1 << CLKPCE);
  57.     CLKPR = 0;
  58.     DDRD |= (1 << PD4);
  59.     DDRD |= (1 << PD1);
  60.     DDRB |= (1 << PB6);
  61.     DDRB |= (1 << PB5);
  62.    
  63.     UBRR0H = 0;
  64.     UBRR0L = 173;
  65.     UCSR0A = (1 << U2X0);
  66.     UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
  67.     UCSR0B = (1 << TXEN0);
  68.    
  69.     {
  70.         static FILE uart_str = FDEV_SETUP_STREAM(uart_putchar, NULL, _FDEV_SETUP_WRITE);
  71.         stdout = stderr = &uart_str;
  72.     }
  73.    
  74.     //Put some stuff in the world to be rendered
  75.     for(uint8_t i = 0; i < WORLD_WIDTH; i++) {
  76.         for(uint8_t j = 0; j < WORLD_DEPTH; j++) {
  77.             for(uint8_t k = 0; k < 5; k++) blocks[i][k][j] = 1;
  78.             blocks[i][5][j] = 2;
  79.             blocks[i][6][j] = 3;
  80.         }
  81.     }
  82.     //A "Hill"
  83.     /*blocks[5][6][5] = 2;
  84.     blocks[6][6][5] = 2;
  85.     blocks[5][6][6] = 2;
  86.     blocks[5][7][5] = 3;
  87.     blocks[6][7][5] = 3;
  88.     blocks[5][7][6] = 3;*/
  89.    
  90.     //Some random rocks
  91.     blocks[12][6][3] = 2;
  92.     blocks[12][7][3] = 1;
  93.     blocks[12][6][2] = 2;
  94.     blocks[12][7][2] = 1;
  95.    
  96.     //A hole
  97.     /*blocks[7][6][7] = 0;
  98.     blocks[6][6][7] = 0;
  99.     blocks[7][6][6] = 0;
  100.     blocks[6][6][6] = 0;*/
  101.     //House
  102.     for(uint8_t i = 1; i < 7; i++) {
  103.         blocks[i + 8][7][1 + 4] = 4;
  104.         blocks[i + 8][7][6 + 4] = 4;
  105.         blocks[i + 8][8][1 + 4] = 4;
  106.         blocks[i + 8][8][6 + 4] = 4;
  107.         blocks[i + 8][9][1 + 4] = 4;
  108.         blocks[i + 8][9][6 + 4] = 4;
  109.     }
  110.     for(uint8_t i = 1; i < 7; i++) {
  111.         blocks[6 + 8][7][i + 4] = 4;
  112.         blocks[6 + 8][8][i + 4] = 4;
  113.         if(i != 3) {
  114.             blocks[1 + 8][7][i + 4] = 4;
  115.             if(i != 5) blocks[1 + 8][8][i + 4] = 4;
  116.         }
  117.         blocks[1 + 8][9][i + 4] = 4;
  118.         blocks[6 + 8][9][i + 4] = 4;
  119.         blocks[1 + 8][6][i + 4] = 2;
  120.         blocks[6 + 8][6][i + 4] = 2;
  121.     }
  122.     for(uint8_t i = 2; i < 6; i++) {
  123.         blocks[i + 8][10][1 + 5] = 4;
  124.         blocks[i + 8][10][6 + 3] = 4;
  125.     }
  126.     for(uint8_t i = 2; i < 6; i++) {
  127.         blocks[1 + 9][10][i + 4] = 4;
  128.         blocks[6 + 7][10][i + 4] = 4;
  129.     }
  130.     for(uint8_t i = 3; i < 5; i++) {
  131.         blocks[i + 8][11][1 + 6] = 4;
  132.         blocks[i + 8][11][6 + 2] = 4;
  133.     }
  134.     for(int i = 3; i < 5; i++) {
  135.         blocks[1 + 10][11][i + 4] = 4;
  136.         blocks[6 + 6][11][i + 4] = 4;
  137.     }
  138.     for(uint8_t i = 1; i < 7; i++) {
  139.         for(uint8_t j = 1; j < 7; j++) {
  140.             blocks[i + 8][6][j + 4] = 1;
  141.         }
  142.     }
  143.     for(uint8_t i = 0; i < 3; i++) {
  144.         blocks[9][7 + i][1 + 4] = 5;
  145.         blocks[14][7 + i][1 + 4] = 5;
  146.         blocks[9][7 + i][6 + 4] = 5;
  147.         blocks[14][7 + i][6 + 4] = 5;
  148.     }
  149.     //Tree
  150.     for(uint8_t i = 7; i < 12; i++) {
  151.         for(uint8_t j = 11; j < 16; j++) {
  152.             blocks[i][10][j] = 6;
  153.             blocks[i][11][j] = 6;
  154.         }
  155.     }
  156.     for(uint8_t i = 8; i < 11; i++) {
  157.         blocks[i][12][13] = 6;
  158.         blocks[i][13][13] = 6;
  159.     }
  160.     for(uint8_t i = 12; i < 15; i++) {
  161.         blocks[9][12][i] = 6;
  162.         blocks[9][13][i] = 6;
  163.     }
  164.     for(uint8_t i = 7; i < 13; i++) {
  165.         blocks[9][i][13] = 5;
  166.     }
  167.     blocks[9][6][13] = 2;
  168.    
  169.     static FATFS FATFS_obj;
  170.     FRESULT f_err = f_mount(&FATFS_obj, "", 1);
  171.     if(f_err != FR_OK){
  172.         printf("Filesystem mount error %u", f_err);
  173.         while(1);
  174.     }
  175.    
  176.     //for(int i2 = 0; i2 < 40; i2++){
  177.     //printf("Image %u/%u\r\n", i2 + 1, 40);
  178.    
  179.     //uint8_t c1 = i2 / 10;
  180.     //uint8_t c2 = i2 % 10;
  181.    
  182.     //char name[] = {'i', 'm', 'a', 'g', 'e', 48 + c1, 48 + c2, '.', 'b', 'm', 'p'};
  183.    
  184.     static FIL outputFile;
  185.     f_err = f_open(&outputFile, "image.bmp", FA_WRITE | FA_OPEN_ALWAYS);
  186.     if(f_err != FR_OK){
  187.         printf("File open error %u", f_err);
  188.         while(1);
  189.     }
  190.    
  191.     f_err = f_lseek(&outputFile, 0);
  192.     f_err |= f_truncate(&outputFile);
  193.     if(f_err != FR_OK){
  194.         printf("Error seeking/truncating %u", f_err);
  195.         while(1);
  196.     }
  197.    
  198.     printf("Initialized.\r\n");
  199.    
  200.     uint32_t awidth = width * 3UL;
  201.     uint8_t padAmmount = 4 - (awidth % 4);
  202.     if(padAmmount == 4) padAmmount = 0;
  203.    
  204.     printf("Final image dimensions: %ux%u\r\n", width, height);
  205.    
  206.     //Bitmap header
  207.     uint8_t dataBuffer[255];
  208.     uint8_t posCntr = 0;
  209.     dataBuffer[0] = 0x42;
  210.     dataBuffer[1] = 0x4D;
  211.     //uint32_t size = width * height * 3 + height * padAmmount + 40 + 14;
  212.     uint32_t size = 61494UL;
  213.     dataBuffer[2] = (uint8_t)(size);
  214.     dataBuffer[3] = (uint8_t)(size >> 8UL);
  215.     dataBuffer[4] = (uint8_t)(size >> 16UL);
  216.     dataBuffer[5] = (uint8_t)(size >> 24UL);
  217.     dataBuffer[6] = 0;
  218.     dataBuffer[7] = 0;
  219.     dataBuffer[8] = 0;
  220.     dataBuffer[9] = 0;
  221.     size = 54;
  222.     dataBuffer[10] = (uint8_t)(size);
  223.     dataBuffer[11] = (uint8_t)(size >> 8UL);
  224.     dataBuffer[12] = (uint8_t)(size >> 16UL);
  225.     dataBuffer[13] = (uint8_t)(size >> 24UL);
  226.     size = 40;
  227.     dataBuffer[14] = (uint8_t)(size);
  228.     dataBuffer[15] = (uint8_t)(size >> 8UL);
  229.     dataBuffer[16] = (uint8_t)(size >> 16UL);
  230.     dataBuffer[17] = (uint8_t)(size >> 24UL);
  231.     size = width;
  232.     dataBuffer[18] = (uint8_t)(size);
  233.     dataBuffer[19] = (uint8_t)(size >> 8UL);
  234.     dataBuffer[20] = (uint8_t)(size >> 16UL);
  235.     dataBuffer[21] = (uint8_t)(size >> 24UL);
  236.     size = height;
  237.     dataBuffer[22] = (uint8_t)(size);
  238.     dataBuffer[23] = (uint8_t)(size >> 8UL);
  239.     dataBuffer[24] = (uint8_t)(size >> 16UL);
  240.     dataBuffer[25] = (uint8_t)(size >> 24UL);
  241.     dataBuffer[26] = 1;
  242.     dataBuffer[27] = 0;
  243.     dataBuffer[28] = 24;
  244.     dataBuffer[29] = 0;
  245.     dataBuffer[30] = 0;
  246.     dataBuffer[31] = 0;
  247.     dataBuffer[32] = 0;
  248.     dataBuffer[33] = 0;
  249.     dataBuffer[34] = 0;
  250.     dataBuffer[35] = 0;
  251.     dataBuffer[36] = 0;
  252.     dataBuffer[37] = 0;
  253.     size = width;
  254.     dataBuffer[38] = (uint8_t)(size);
  255.     dataBuffer[39] = (uint8_t)(size >> 8UL);
  256.     dataBuffer[40] = (uint8_t)(size >> 16UL);
  257.     dataBuffer[41] = (uint8_t)(size >> 24UL);
  258.     dataBuffer[42] = (uint8_t)(size);
  259.     dataBuffer[43] = (uint8_t)(size >> 8UL);
  260.     dataBuffer[44] = (uint8_t)(size >> 16UL);
  261.     dataBuffer[45] = (uint8_t)(size >> 24UL);
  262.     dataBuffer[46] = 0;
  263.     dataBuffer[47] = 0;
  264.     dataBuffer[48] = 0;
  265.     dataBuffer[49] = 0;
  266.     dataBuffer[50] = 0;
  267.     dataBuffer[51] = 0;
  268.     dataBuffer[52] = 0;
  269.     dataBuffer[53] = 0;
  270.    
  271.     UINT w = 0;
  272.        
  273.     f_write(&outputFile, dataBuffer, 54, &w);
  274.    
  275.     //Player position
  276.     accum x,y,z = 0;
  277.     y = 9;
  278.     x = 0;
  279.     accum rotX,rotY = 0;
  280.     rotY = 0;
  281.     rotX = 0;
  282.                
  283.     //Working variables
  284.     #ifdef FLOATING_POINT
  285.     float cosX,cosY,sinX,sinY;
  286.     float toImageX,toImageY,toImageZ,toImageXn,toImageYn,toImageZn;
  287.     float length;
  288.     float stepX,stepY,stepZ;
  289.     float s1;
  290.     float pixelFX,pixelFY,pixelFZ;
  291.     float wX,wY,wZ;
  292.     #else
  293.     accum cosX,cosY,sinX,sinY;
  294.     accum toImageX,toImageY,toImageZ,toImageXn,toImageYn,toImageZn;
  295.     accum length;
  296.     accum stepX,stepY,stepZ;
  297.     accum s1;
  298.     accum pixelFX,pixelFY,pixelFZ;
  299.     accum wX,wY,wZ;
  300.     #endif
  301.     signed char intX,intY,intZ;
  302.     signed char prevIntX,prevIntY,prevIntZ;
  303.     uint8_t bb;
  304.     uint8_t block;
  305.     uint8_t pixelX,pixelY,pixelZ;
  306.     uint8_t bc,bd,be,bf;
  307.     uint16_t stepCntr = 0;
  308.    
  309.     uint8_t skyR = 0xAB;
  310.     uint8_t skyG = 0xCD;
  311.     uint8_t skyB = 0xEF;
  312.    
  313.     uint8_t voidR = 0x8B;
  314.     uint8_t voidG = 0xA6;
  315.     uint8_t voidB = 0xC1;
  316.    
  317.     uint8_t currR,currG,currB;
  318.    
  319.     #ifdef FLOATING_POINT
  320.     /*rotX = 4.2300005f;
  321.     rotY = 99.70001f;
  322.     x = 1.7884214f;
  323.     z = 9.30016f;*/
  324.     rotX = -0.0900002f;
  325.     rotY = 47.365f;
  326.     x = 0.404446f;
  327.     z = 0.22908628f;
  328.     #else
  329.     //Coords for standing in front of the house
  330.     //rotX = 4.2300005K;
  331.     //rotY = 99.70001K/* + 9.0K * (accum)i2*/;
  332.     //x = 1.7884214K;
  333.     //z = 9.30016K;
  334.     //Coords for looking at the house and tree at once
  335.     rotX = -0.0900002K;
  336.     rotY = 47.365K;
  337.     x = 0.404446K;
  338.     z = 0.22908628K;
  339.     #endif
  340.    
  341.     cosX = cos(toRadians(rotX));
  342.     cosY = cos(toRadians(rotY));
  343.     sinX = sin(toRadians(rotX));
  344.     sinY = sin(toRadians(rotY));
  345.    
  346.     for(int j = height - 1; j >= 0; j--){
  347.         for(int i = 0; i < width; i++){
  348.             //Raytrace!
  349.             #ifdef FLOATING_POINT
  350.             toImageX = ((float)i / (float)width - 0.5f);
  351.             toImageY = -((float)j / (float)width - 0.5f);
  352.             toImageZ = 1.0f;
  353.             #else
  354.             toImageX = ((accum)i / (accum)width - 0.5K);
  355.             toImageY = -((accum)j / (accum)width - 0.5K);
  356.             toImageZ = 1.0K;
  357.             #endif
  358.                            
  359.             toImageYn = toImageY * cosX - toImageZ * sinX;
  360.             toImageZ = toImageY * sinX + toImageZ * cosX;
  361.             toImageY = toImageYn;
  362.                            
  363.             toImageXn = toImageX * cosY + toImageZ * sinY;
  364.             toImageZ = -toImageX * sinY + toImageZ * cosY;
  365.             toImageX = toImageXn;
  366.            
  367.             length = sqrt(toImageX * toImageX + toImageY * toImageY + toImageZ * toImageZ);
  368.             toImageX /= length;
  369.             toImageY /= length;
  370.             toImageZ /= length;
  371.             toImageXn = toImageX;
  372.             toImageYn = toImageY;
  373.             toImageZn = toImageZ;
  374.             #ifdef FLOATING_POINT
  375.             toImageX /= (float)stepResolution;
  376.             toImageY /= (float)stepResolution;
  377.             toImageZ /= (float)stepResolution;
  378.             #else
  379.             toImageX /= (accum)stepResolution;
  380.             toImageY /= (accum)stepResolution;
  381.             toImageZ /= (accum)stepResolution;
  382.             #endif
  383.             bb = 1;
  384.            
  385.             stepX = x;
  386.             stepY = y;
  387.             stepZ = z;
  388.             intX = (signed char)x + 1;
  389.             intY = (signed char)y;
  390.             intZ = (signed char)z;
  391.             currR = skyR;
  392.             currG = skyG;
  393.             currB = skyB;
  394.             stepCntr = 0;
  395.             while(1){
  396.                 prevIntX = intX;
  397.                 prevIntY = intY;
  398.                 prevIntZ = intZ;
  399.                 intX = (signed char)stepX;
  400.                 intY = (signed char)stepY;
  401.                 intZ = (signed char)stepZ;
  402.                 if(prevIntX != intX || prevIntY != intY || prevIntZ != intZ) {
  403.                     if(intX >= WORLD_WIDTH || intX < 0 || intY >= WORLD_HEIGHT || intY < 0 || intZ >= WORLD_DEPTH || intZ < 0) {
  404.                         #ifdef FLOATING_POINT
  405.                         if(toImageY < -0.125f / (float)stepResolution) {
  406.                             currR = voidR;
  407.                             currG = voidG;
  408.                             currB = voidB;
  409.                         }
  410.                         #else
  411.                         if(toImageY < -0.125K / (accum)stepResolution) {
  412.                             currR = voidR;
  413.                             currG = voidG;
  414.                             currB = voidB;
  415.                         }
  416.                         #endif
  417.                         break;
  418.                     }
  419.                     if(bb || stepCntr >= stepResolution) {
  420.                         /*found = 0;
  421.                         bc = toImageX > 0 ? 1 : 0;
  422.                         be = toImageY > 0 ? 1 : 0;
  423.                         bf = toImageZ > 0 ? 1 : 0;
  424.                         startZ = bf ? 0 : -1;
  425.                         if(intZ == 0) startZ = 0;
  426.                         endZ = bf;
  427.                         if(intZ == WORLD_DEPTH - 1) endZ = 0;
  428.                         for(signed char a2 = bc ? 0 : -1; a2 <= bc; a2++) {
  429.                             if(intX + a2 < 0 || intX + a2 >= WORLD_WIDTH) continue;
  430.                             for(signed char b = be ? 0 : -1; b <= be; b++) {
  431.                                 if(intY + b < 0 || intY + b >= WORLD_HEIGHT) continue;
  432.                                 for(signed char c = startZ; c <= endZ; c++) {
  433.                                     if(blocks[intX + a2][intY + b][intZ + c] != 0) {
  434.                                         if(bb){
  435.                                             bb = 0;
  436.                                             b = 2;
  437.                                             a2 = 2;
  438.                                             stepX -= toImageXn;
  439.                                             stepY -= toImageYn;
  440.                                             stepZ -= toImageZn;
  441.                                         }
  442.                                         found = 1;
  443.                                         break;
  444.                                     }
  445.                                 }
  446.                             }
  447.                         }
  448.                         if(found == 0) bb = 1;*/
  449.                        
  450.                         //This is basically the above code, but convoluted as fck.....but somehow it's faster
  451.                         bc = toImageY > 0 && intY < WORLD_HEIGHT - 2;
  452.                         bd = toImageY < 0 && intY > 0;
  453.                         be = toImageZ > 0 && intZ < WORLD_DEPTH - 2;
  454.                         bf = toImageZ < 0 && intZ > 0;
  455.                         if(blocks[intX][intY][intZ] != 0 || (bc && ((be && (blocks[intX][intY + 1][intZ + 1] != 0)) || (bf && (blocks[intX][intY + 1][intZ - 1] != 0)) || blocks[intX][intY + 1][intZ] != 0)) || (bd && ((be && (blocks[intX][intY - 1][intZ + 1] != 0)) || (bf && (blocks[intX][intY - 1][intZ - 1])) != 0 || blocks[intX][intY - 1][intZ] != 0)) || (be && (blocks[intX][intY][intZ + 1])) != 0 || (bf && (blocks[intX][intY][intZ - 1])) != 0){
  456.                             goto found;
  457.                         }
  458.                         if(toImageX > 0 && intX < WORLD_WIDTH - 2 && (blocks[intX + 1][intY][intZ] != 0 || (bc && ((be && (blocks[intX + 1][intY + 1][intZ + 1])) != 0 || (bf && (blocks[intX + 1][intY + 1][intZ - 1])) != 0 || blocks[intX + 1][intY + 1][intZ] != 0)) || (bd && ((be && (blocks[intX + 1][intY - 1][intZ + 1])) != 0 || (bf && (blocks[intX + 1][intY - 1][intZ - 1])) != 0 || blocks[intX + 1][intY - 1][intZ] != 0)) || (be && (blocks[intX + 1][intY][intZ + 1] != 0)) || (bf && (blocks[intX + 1][intY][intZ - 1])) != 0)){
  459.                             goto found;
  460.                         }
  461.                         if(toImageX < 0 && intX > 0 && (blocks[intX - 1][intY][intZ] != 0 || (bc && ((be && (blocks[intX - 1][intY + 1][intZ + 1])) != 0 || (bf && (blocks[intX - 1][intY + 1][intZ - 1])) != 0 || blocks[intX - 1][intY + 1][intZ] != 0)) || (bd && ((be && (blocks[intX - 1][intY - 1][intZ + 1])) != 0 || (bf && (blocks[intX - 1][intY - 1][intZ - 1])) != 0 || blocks[intX - 1][intY - 1][intZ] != 0)) || (be && (blocks[intX - 1][intY][intZ + 1])) != 0 || (bf && (blocks[intX - 1][intY][intZ - 1])) != 0)){
  462.                             goto found;
  463.                         }
  464.                         goto notfound;
  465.                         found:
  466.                         if(bb){
  467.                             bb = 0;
  468.                             stepX -= toImageXn;
  469.                             stepY -= toImageYn;
  470.                             stepZ -= toImageZn;
  471.                         }
  472.                         goto afternotfound;
  473.                         notfound:
  474.                         bb = 1;
  475.                         afternotfound:
  476.                         ;
  477.                     }
  478.                     if(bb == 0){
  479.                         block = blocks[intX][intY][intZ];
  480.                         if(block != 0){
  481.                             currR = 128;
  482.                             currG = 128;
  483.                             currB = 128;
  484.                             wX = stepX - toImageX;
  485.                             wY = stepY - toImageY;
  486.                             wZ = stepZ - toImageZ;
  487.                            
  488.                             if(wY >= intY + 1){
  489.                                 s1 = (intY + 1 - wY) / toImageY;
  490.                                 //if(s1 >= 0){
  491.                                     pixelFX = wX + s1 * toImageX;
  492.                                     pixelFZ = wZ + s1 * toImageZ;
  493.                                     if(pixelFX >= intX && pixelFX < intX + 1 && pixelFZ >= intZ && pixelFZ < intZ + 1) {
  494.                                         #ifdef FLOATING_POINT
  495.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0f);
  496.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0f);
  497.                                         #else
  498.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0K);
  499.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0K);
  500.                                         #endif
  501.                                         if(block == 1){
  502.                                             currR = TEXTURE_stone[pixelX][pixelZ][0];
  503.                                             currG = TEXTURE_stone[pixelX][pixelZ][1];
  504.                                             currB = TEXTURE_stone[pixelX][pixelZ][2];
  505.                                         }else if(block == 2){
  506.                                             currR = TEXTURE_dirt[pixelX][pixelZ][0];
  507.                                             currG = TEXTURE_dirt[pixelX][pixelZ][1];
  508.                                             currB = TEXTURE_dirt[pixelX][pixelZ][2];
  509.                                         }else if(block == 3){
  510.                                             currR = TEXTURE_grass[pixelX][pixelZ][0];
  511.                                             currG = TEXTURE_grass[pixelX][pixelZ][1];
  512.                                             currB = TEXTURE_grass[pixelX][pixelZ][2];
  513.                                         }else if(block == 4){
  514.                                             currR = TEXTURE_planks[pixelX][pixelZ][0];
  515.                                             currG = TEXTURE_planks[pixelX][pixelZ][1];
  516.                                             currB = TEXTURE_planks[pixelX][pixelZ][2];
  517.                                         }else if(block == 5){
  518.                                             currR = TEXTURE_log_top[pixelX][pixelZ][0];
  519.                                             currG = TEXTURE_log_top[pixelX][pixelZ][1];
  520.                                             currB = TEXTURE_log_top[pixelX][pixelZ][2];
  521.                                         }else if(block == 6){
  522.                                             currR = TEXTURE_leaves[pixelX][pixelZ][0];
  523.                                             currG = TEXTURE_leaves[pixelX][pixelZ][1];
  524.                                             currB = TEXTURE_leaves[pixelX][pixelZ][2];
  525.                                         }
  526.                                         break;
  527.                                     }
  528.                                 //}
  529.                             }
  530.                             if(wZ <= intZ){
  531.                                 s1 = -(intZ - wZ) / -toImageZ;
  532.                                 //if(s1 >= 0){
  533.                                     pixelFX = wX + s1 * toImageX;
  534.                                     pixelFY = wY + s1 * toImageY;
  535.                                     if(pixelFX >= intX && pixelFX < intX + 1 && pixelFY >= intY && pixelFY < intY + 1) {
  536.                                         #ifdef FLOATING_POINT
  537.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0f);
  538.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0f);
  539.                                         #else
  540.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0K);
  541.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0K);
  542.                                         #endif
  543.                                         pixelY = 15 - pixelY;
  544.                                         if(block == 1){
  545.                                             currR = TEXTURE_stone[pixelY][pixelX][0];
  546.                                             currG = TEXTURE_stone[pixelY][pixelX][1];
  547.                                             currB = TEXTURE_stone[pixelY][pixelX][2];
  548.                                         }else if(block == 2){
  549.                                             currR = TEXTURE_dirt[pixelY][pixelX][0];
  550.                                             currG = TEXTURE_dirt[pixelY][pixelX][1];
  551.                                             currB = TEXTURE_dirt[pixelY][pixelX][2];
  552.                                         }else if(block == 3){
  553.                                             currR = TEXTURE_grass_side[pixelY][pixelX][0];
  554.                                             currG = TEXTURE_grass_side[pixelY][pixelX][1];
  555.                                             currB = TEXTURE_grass_side[pixelY][pixelX][2];
  556.                                         }else if(block == 4){
  557.                                             currR = TEXTURE_planks[pixelY][pixelX][0];
  558.                                             currG = TEXTURE_planks[pixelY][pixelX][1];
  559.                                             currB = TEXTURE_planks[pixelY][pixelX][2];
  560.                                         }else if(block == 5){
  561.                                             currR = TEXTURE_log_side[pixelY][pixelX][0];
  562.                                             currG = TEXTURE_log_side[pixelY][pixelX][1];
  563.                                             currB = TEXTURE_log_side[pixelY][pixelX][2];
  564.                                         }else if(block == 6){
  565.                                             currR = TEXTURE_leaves[pixelY][pixelX][0];
  566.                                             currG = TEXTURE_leaves[pixelY][pixelX][1];
  567.                                             currB = TEXTURE_leaves[pixelY][pixelX][2];
  568.                                         }
  569.                                         break;
  570.                                     }
  571.                                 //}
  572.                             }
  573.                             if(wZ >= intZ + 1){
  574.                                 s1 = (intZ + 1 - wZ) / toImageZ;
  575.                                 //if(s1 >= 0){
  576.                                     pixelFX = wX + s1 * toImageX;
  577.                                     pixelFY = wY + s1 * toImageY;
  578.                                     if(pixelFX >= intX && pixelFX < intX + 1 && pixelFY >= intY && pixelFY < intY + 1) {
  579.                                         #ifdef FLOATING_POINT
  580.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0f);
  581.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0f);
  582.                                         #else
  583.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0K);
  584.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0K);
  585.                                         #endif
  586.                                         pixelY = 15 - pixelY;
  587.                                         if(block == 1){
  588.                                             currR = TEXTURE_stone[pixelY][pixelX][0];
  589.                                             currG = TEXTURE_stone[pixelY][pixelX][1];
  590.                                             currB = TEXTURE_stone[pixelY][pixelX][2];
  591.                                         }else if(block == 2){
  592.                                             currR = TEXTURE_dirt[pixelY][pixelX][0];
  593.                                             currG = TEXTURE_dirt[pixelY][pixelX][1];
  594.                                             currB = TEXTURE_dirt[pixelY][pixelX][2];
  595.                                         }else if(block == 3){
  596.                                             currR = TEXTURE_grass_side[pixelY][pixelX][0];
  597.                                             currG = TEXTURE_grass_side[pixelY][pixelX][1];
  598.                                             currB = TEXTURE_grass_side[pixelY][pixelX][2];
  599.                                         }else if(block == 4){
  600.                                             currR = TEXTURE_planks[pixelY][pixelX][0];
  601.                                             currG = TEXTURE_planks[pixelY][pixelX][1];
  602.                                             currB = TEXTURE_planks[pixelY][pixelX][2];
  603.                                         }else if(block == 5){
  604.                                             currR = TEXTURE_log_side[pixelY][pixelX][0];
  605.                                             currG = TEXTURE_log_side[pixelY][pixelX][1];
  606.                                             currB = TEXTURE_log_side[pixelY][pixelX][2];
  607.                                         }else if(block == 6){
  608.                                             currR = TEXTURE_leaves[pixelY][pixelX][0];
  609.                                             currG = TEXTURE_leaves[pixelY][pixelX][1];
  610.                                             currB = TEXTURE_leaves[pixelY][pixelX][2];
  611.                                         }
  612.                                         break;
  613.                                     }
  614.                                 //}
  615.                             }
  616.                             if(wY <= intY){
  617.                                 s1 = -(intY - wY) / -toImageY;
  618.                                 //if(s1 >= 0){
  619.                                     pixelFX = wX + s1 * toImageX;
  620.                                     pixelFZ = wZ + s1 * toImageZ;
  621.                                     if(pixelFX >= intX && pixelFX < intX + 1 && pixelFZ >= intZ && pixelFZ < intZ + 1) {
  622.                                         #ifdef FLOATING_POINT
  623.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0f);
  624.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0f);
  625.                                         #else
  626.                                         pixelX = (uint8_t)((pixelFX - intX) * 16.0K);
  627.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0K);
  628.                                         #endif
  629.                                         pixelX = 15 - pixelX;
  630.                                         if(block == 1){
  631.                                             currR = TEXTURE_stone[pixelX][pixelZ][0];
  632.                                             currG = TEXTURE_stone[pixelX][pixelZ][1];
  633.                                             currB = TEXTURE_stone[pixelX][pixelZ][2];
  634.                                         }else if(block == 2){
  635.                                             currR = TEXTURE_dirt[pixelX][pixelZ][0];
  636.                                             currG = TEXTURE_dirt[pixelX][pixelZ][1];
  637.                                             currB = TEXTURE_dirt[pixelX][pixelZ][2];
  638.                                         }else if(block == 3){
  639.                                             currR = TEXTURE_dirt[pixelX][pixelZ][0];
  640.                                             currG = TEXTURE_dirt[pixelX][pixelZ][1];
  641.                                             currB = TEXTURE_dirt[pixelX][pixelZ][2];
  642.                                         }else if(block == 4){
  643.                                             currR = TEXTURE_planks[pixelX][pixelZ][0];
  644.                                             currG = TEXTURE_planks[pixelX][pixelZ][1];
  645.                                             currB = TEXTURE_planks[pixelX][pixelZ][2];
  646.                                         }else if(block == 5){
  647.                                             currR = TEXTURE_log_top[pixelX][pixelZ][0];
  648.                                             currG = TEXTURE_log_top[pixelX][pixelZ][1];
  649.                                             currB = TEXTURE_log_top[pixelX][pixelZ][2];
  650.                                         }else if(block == 6){
  651.                                             currR = TEXTURE_leaves[pixelX][pixelZ][0];
  652.                                             currG = TEXTURE_leaves[pixelX][pixelZ][1];
  653.                                             currB = TEXTURE_leaves[pixelX][pixelZ][2];
  654.                                         }
  655.                                         break;
  656.                                     }
  657.                                 //}
  658.                             }
  659.                             if(wX >= intX + 1){
  660.                                 s1 = (intX + 1 - wX) / toImageX;
  661.                                 //if(s1 >= 0){
  662.                                     pixelFZ = wZ + s1 * toImageZ;
  663.                                     pixelFY = wY + s1 * toImageY;
  664.                                     if(pixelFZ >= intZ && pixelFZ < intZ + 1 && pixelFY >= intY && pixelFY < intY + 1) {
  665.                                         #ifdef FLOATING_POINT
  666.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0f);
  667.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0f);
  668.                                         #else
  669.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0K);
  670.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0K);
  671.                                         #endif
  672.                                         pixelY = 15 - pixelY;
  673.                                         if(block == 1){
  674.                                             currR = TEXTURE_stone[pixelY][pixelZ][0];
  675.                                             currG = TEXTURE_stone[pixelY][pixelZ][1];
  676.                                             currB = TEXTURE_stone[pixelY][pixelZ][2];
  677.                                         }else if(block == 2){
  678.                                             currR = TEXTURE_dirt[pixelY][pixelZ][0];
  679.                                             currG = TEXTURE_dirt[pixelY][pixelZ][1];
  680.                                             currB = TEXTURE_dirt[pixelY][pixelZ][2];
  681.                                         }else if(block == 3){
  682.                                             currR = TEXTURE_grass_side[pixelY][pixelZ][0];
  683.                                             currG = TEXTURE_grass_side[pixelY][pixelZ][1];
  684.                                             currB = TEXTURE_grass_side[pixelY][pixelZ][2];
  685.                                         }else if(block == 4){
  686.                                             currR = TEXTURE_planks[pixelY][pixelZ][0];
  687.                                             currG = TEXTURE_planks[pixelY][pixelZ][1];
  688.                                             currB = TEXTURE_planks[pixelY][pixelZ][2];
  689.                                         }else if(block == 5){
  690.                                             currR = TEXTURE_log_side[pixelY][pixelZ][0];
  691.                                             currG = TEXTURE_log_side[pixelY][pixelZ][1];
  692.                                             currB = TEXTURE_log_side[pixelY][pixelZ][2];
  693.                                         }else if(block == 6){
  694.                                             currR = TEXTURE_leaves[pixelY][pixelZ][0];
  695.                                             currG = TEXTURE_leaves[pixelY][pixelZ][1];
  696.                                             currB = TEXTURE_leaves[pixelY][pixelZ][2];
  697.                                         }
  698.                                         break;
  699.                                     }
  700.                                 //}
  701.                             }
  702.                             if(wX <= intX){
  703.                                 s1 = -(intX - wX) / -toImageX;
  704.                                 //if(s1 >= 0){
  705.                                     pixelFZ = wZ + s1 * toImageZ;
  706.                                     pixelFY = wY + s1 * toImageY;
  707.                                     if(pixelFZ >= intZ && pixelFZ < intZ + 1 && pixelFY >= intY && pixelFY < intY + 1) {
  708.                                         #ifdef FLOATING_POINT
  709.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0f);
  710.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0f);
  711.                                         #else
  712.                                         pixelZ = (uint8_t)((pixelFZ - intZ) * 16.0K);
  713.                                         pixelY = (uint8_t)((pixelFY - intY) * 16.0K);
  714.                                         #endif
  715.                                         pixelY = 15 - pixelY;
  716.                                         if(block == 1){
  717.                                             currR = TEXTURE_stone[pixelY][pixelZ][0];
  718.                                             currG = TEXTURE_stone[pixelY][pixelZ][1];
  719.                                             currB = TEXTURE_stone[pixelY][pixelZ][2];
  720.                                         }else if(block == 2){
  721.                                             currR = TEXTURE_dirt[pixelY][pixelZ][0];
  722.                                             currG = TEXTURE_dirt[pixelY][pixelZ][1];
  723.                                             currB = TEXTURE_dirt[pixelY][pixelZ][2];
  724.                                         }else if(block == 3){
  725.                                             currR = TEXTURE_grass_side[pixelY][pixelZ][0];
  726.                                             currG = TEXTURE_grass_side[pixelY][pixelZ][1];
  727.                                             currB = TEXTURE_grass_side[pixelY][pixelZ][2];
  728.                                         }else if(block == 4){
  729.                                             currR = TEXTURE_planks[pixelY][pixelZ][0];
  730.                                             currG = TEXTURE_planks[pixelY][pixelZ][1];
  731.                                             currB = TEXTURE_planks[pixelY][pixelZ][2];
  732.                                         }else if(block == 5){
  733.                                             currR = TEXTURE_log_side[pixelY][pixelZ][0];
  734.                                             currG = TEXTURE_log_side[pixelY][pixelZ][1];
  735.                                             currB = TEXTURE_log_side[pixelY][pixelZ][2];
  736.                                         }else if(block == 6){
  737.                                             currR = TEXTURE_leaves[pixelY][pixelZ][0];
  738.                                             currG = TEXTURE_leaves[pixelY][pixelZ][1];
  739.                                             currB = TEXTURE_leaves[pixelY][pixelZ][2];
  740.                                         }
  741.                                         break;
  742.                                     }
  743.                                 //}
  744.                             }
  745.                        
  746.                             break;
  747.                         }
  748.                     }
  749.                 }
  750.                 if(bb){
  751.                     stepX += toImageXn;
  752.                     stepY += toImageYn;
  753.                     stepZ += toImageZn;
  754.                 }else{
  755.                     stepX += toImageX;
  756.                     stepY += toImageY;
  757.                     stepZ += toImageZ;
  758.                 }
  759.                 stepCntr++;
  760.             }
  761.             dataBuffer[posCntr] = currB;
  762.             dataBuffer[posCntr + 1] = currG;
  763.             dataBuffer[posCntr + 2] = currR;
  764.             posCntr+=3;
  765.             if(posCntr == 255){
  766.                 f_write(&outputFile, dataBuffer, 255, &w);
  767.                 posCntr = 0;
  768.             }
  769.         }
  770.         printf("%u/%u\r", height - j, height);
  771.         if(posCntr != 0) f_write(&outputFile, dataBuffer, posCntr, &w);
  772.         if(padAmmount != 0){
  773.             for(int i = 0; i < padAmmount; i++) dataBuffer[i] = 0;
  774.             f_write(&outputFile, dataBuffer, padAmmount, &w);
  775.         }
  776.         posCntr = 0;
  777.     }
  778.     if(posCntr != 0) f_write(&outputFile, dataBuffer, posCntr, &w);
  779.    
  780.     f_close(&outputFile);
  781.     //}
  782.     f_unmount("");
  783.     printf("\nDone.\r\n");
  784.     while(1){
  785.         _delay_ms(16);
  786.     }
  787. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!