BackRoomsMaker/src/display.c

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <math.h>
#include <stdbool.h>
#include <ncurses.h>
#include <unistd.h>
#include <termios.h>
#include <limits.h>
#include <time.h>
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>

#include "hash.h"
#include "structure.h"
#include "base.h"
#include "generation.h"
#include "display.h"

void updateRenderer(SDL_Renderer* renderer) {
    //printf("E");
    SDL_RenderPresent(renderer);
}

void resetRenderer(SDL_Renderer* renderer) {
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    SDL_RenderClear(renderer);
}

void drawRectToRenderer(SDL_Renderer* renderer, SDL_Rect* rect, int R, int G, int B, int A) {
    SDL_SetRenderDrawColor(renderer, R, G, B, A);
    SDL_RenderFillRect(renderer, rect);
}

void placeRectToRenderer(SDL_Renderer* renderer, int X, int Y, int W, int H, int R, int G, int B, int A) {
    SDL_Rect rect;
    rect.x = X;
    rect.y = Y;
    rect.w = W;
    rect.h = H;
    SDL_SetRenderDrawColor(renderer, R, G, B, A);
    SDL_RenderFillRect(renderer, &rect);
}

void drawLineWithThicc(SDL_Renderer* renderer, int width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
    // draws line with width (native SDL cannot do that)
    double theta = 0.0;
    double seglen = distance_pt(x1, x2, y1, y2);
    while(theta < 1.0) {
        placeRectToRenderer(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width, R, G, B, A);
        theta += 1 / seglen;
    }
}

void drawLineWithThiccGradient(SDL_Renderer* renderer, int start_width, int end_width, int x1, int x2, int y1, int y2, int R, int G, int B, int A) {
    // draws line with width ;
    // width goes from start_width to end_with in a linear way
    double theta = 0.0;
    double seglen = distance_pt(x1, x2, y1, y2);
    while(theta < 1.0) {
        int width = convex_seg(start_width, end_width, theta) ;
        placeRectToRenderer(renderer, convex_seg(x1, x2, theta)-width/2, convex_seg(y1, y2, theta)-width/2, width, width, R, G, B, A);
        theta += 1 / seglen;
    }
}

void drawDigitToRenderer(SDL_Renderer* renderer, imgs data, int digit, int X, int Y, int W, int H) {
    if(digit == -727) {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = data.arr[10];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    } else if (!(0 <= digit && digit <= 9)) {
        fprintf(stderr, "Illegal digit : '%d'.\n", digit);
        exit(1);
    } else {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = data.arr[digit];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    }
}

void drawCharToRenderer(SDL_Renderer* renderer, imgs data, char c, int X, int Y, int W, int H) {
    if ((int)c >= 97 && (int)c <= 122) {
        SDL_Rect rect;
        rect.x = X;
        rect.y = Y;
        rect.w = W;
        rect.h = H;
            
        SDL_Texture* texture = data.arr[(int)c - 97];
        
        SDL_RenderCopy(renderer, texture, NULL, &rect);
    }
}

void drawNumberToRenderer(SDL_Renderer* renderer, imgs data, int n, int X, int Y, int W, int H, int Woffset) {
    if(n == 0) {
        drawDigitToRenderer(renderer, data, 0, X + W, Y, W, H);
    } else if(n > 0) {
        int toDraw = 0, remaining = n, nIter = ln_baseN(n, 10);
        while(nIter != 0) {
            toDraw = remaining%10;
            remaining = remaining / 10;
            drawDigitToRenderer(renderer, data, toDraw, X + (W-Woffset)*nIter, Y, W, H);
            nIter--;
        }
    } else {
        int toDraw = 0, remaining = -n, nIter = ln_baseN(-n, 10);
        drawDigitToRenderer(renderer, data, -727, X, Y, W, H);
        while(nIter != 0) {
            toDraw = remaining%10;
            remaining = remaining / 10;
            drawDigitToRenderer(renderer, data, toDraw, X + (W-Woffset)*nIter, Y, W, H);
            nIter--;
        }
    }
}

void drawStringToRenderer(SDL_Renderer* renderer, imgs data, char* s, int X, int Y, int W, int H) {
    int k = 0 ;
    while(s[k] != '\0') {
        drawCharToRenderer(renderer, data, s[k], X + W*k, Y, W, H);
        k += 1;
    }
}

void drawChunkToRenderer(SDL_Renderer* renderer, chunk* ch, int xmin, int xmax, int ymin, int ymax) {
    if(ch->draw_id != draw_par) {
        ch->draw_id = draw_par ;
        //printf("[DDDDD] chunk (%d, %d) has signature : \n", ch.chx, ch.chy);
        //signature(ch.chdata);
        //printf("\n");
        for(int i = 0; i < 8; i++) {
            uint8_t cur = ch->chdata.lines[i] ;
            for(int j = 0; j < 8; j++) {
                int cux = 50*(8*ch->chx + j);
                int cuy = 50*(8*ch->chy + i);
                int cux2 = 50*(8*ch->chx + j+1);
                int cuy2 = 50*(8*ch->chy + i+1);
                if(true) {
                //if(cux - 50/zoom > xmin || cux - 50/zoom < xmax || cuy > ymin || cuy < ymax) {
                    if(cur%2 == 1) {
                        int nxmin = to_int((to_double(cux) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) ;
                        int nymin = to_int((to_double(cuy) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) ;
                        int nxmin2 = to_int((to_double(cux2) - to_double(xmin)) * to_double(__width__)) / (to_double(xmax) - to_double(xmin)) ;
                        int nymin2 = to_int((to_double(cuy2) - to_double(ymin)) * to_double(__height__)) / (to_double(ymax) - to_double(ymin)) ;
                        placeRectToRenderer(renderer, nxmin, nymin, nxmin2 - nxmin, nymin2 - nymin, 255, 255, 255, SDL_ALPHA_OPAQUE);
                    };
                    cur = cur / 2 ;
                }
            }
        }
    }
}

void drawHashToRenderer(SDL_Renderer* renderer, int chx, int chy, int xmin, int xmax, int ymin, int ymax, int distx, int disty) {
    if(distx < render_distance && disty < render_distance) {
        chunk* todraw = gridGet(map, chx, chy) ;
        if(todraw == NULL) {
            fprintf(stderr, "NO (%d, %d)\n", chx, chy);
            exit(1);
        };
        drawChunkToRenderer(renderer, todraw, xmin, xmax, ymin, ymax);

        if(distx != render_distance -1 && !gridMem(map, chx+1, chy)) {
            generate_chunk_all(chx+1, chy);
        };
        if(distx != render_distance -1 && !gridMem(map, chx-1, chy)) {
            generate_chunk_all(chx-1, chy);
        };
        if(disty != render_distance -1 && !gridMem(map, chx, chy+1)) {
            generate_chunk_all(chx, chy+1);
        };
        if(disty != render_distance -1 && !gridMem(map, chx, chy-1)) {
            generate_chunk_all(chx, chy-1);
        };

        drawHashToRenderer(renderer, chx+1, chy, xmin, xmax, ymin, ymax, distx+1, disty);
        drawHashToRenderer(renderer, chx-1, chy, xmin, xmax, ymin, ymax, distx+1, disty);
        drawHashToRenderer(renderer, chx, chy+1, xmin, xmax, ymin, ymax, distx, disty+1);
        drawHashToRenderer(renderer, chx, chy-1, xmin, xmax, ymin, ymax, distx, disty+1);
    }
}

void drawMapToRenderer(SDL_Renderer* renderer, int xmin, int xmax, int ymin, int ymax) {
    drawHashToRenderer(renderer, player_cx, player_cy, xmin, xmax, ymin, ymax, 0, 0);
    placeRectToRenderer(renderer, __width__ /2 - 5*zoom/100, __height__ /2 - 5*zoom/100, 10*zoom/100, 10*zoom/100, 255, 255, 32, SDL_ALPHA_OPAQUE);
}