graphycs.h

Go to the documentation of this file.

#ifndef GRAPHYCS_H
#define GRAPHYCS_H
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <conio.h>
#include <stdint.h>
#include <ctype.h>
#include <limits.h>


typedef struct {
    int r; 
    int g; 
    int b; 
} Color;

typedef struct {
    int x; 
    int y; 
} Vector2;



#define COLOR_BLACK (Color){0, 0, 0}
#define COLOR_RED   (Color){255, 0, 0}
#define COLOR_GREEN   (Color){0, 255, 0}
#define COLOR_YELLOW  (Color){255, 255, 0}
#define COLOR_BLUE    (Color){0, 0, 255}
#define COLOR_PURPLE  (Color){128, 0, 128}
#define COLOR_CYAN    (Color){0, 255, 255}
#define COLOR_WHITE   (Color){255, 255, 255}

#define VETOR_NULO (Vector2){0, 0}
#define VETOR_CIMA (Vector2){0, -1}
#define VETOR_BAIXO (Vector2){0, 1}
#define VETOR_ESQUERDA (Vector2){-1, 0}
#define VETOR_DIREITA (Vector2){1, 0}
 

typedef struct {
    Color cor;      
    Vector2 position; 
    void** obj_source; 
    char source_type; 
} Pixel;

typedef struct Pixel_Node{
    Pixel pixel;
    struct Pixel_Node* anterior;
} Pixel_Node;

typedef struct {
    Pixel_Node* topo;
} Pixel_Stack;

typedef struct {
    Pixel_Stack*** pixeis;  
    Vector2 screen_size;
    Vector2 position;
} Screen;


typedef struct {
    char nome[20];      
    int* frame_index;   
    int qtd_frames;     
    int frame_atual;    
} Animation;

typedef struct {
    int qtd_anims;      
    int anim_atual;     
    Animation* anims;   
} AnimationManager;


typedef struct {
    Vector2 position;   
    Pixel* info;        
    Vector2 size;       
    int qtd_Pixel;      
    bool renderizado;   
} Objeto;

typedef struct {
    Vector2 position;           
    Vector2* pivot_frames;      
    Objeto** frames;           
    AnimationManager* anim_manager; 
    Vector2 size;              
    bool renderizado;          
    bool animar;               
    int qtd_frames;            
    int frame_atual;           
} ObjetoComplexo;


char ler_teclado();

Screen* criar_tela(Vector2 tamanho, Color fundo);

void mover_tela (Screen* s, Vector2 direction);
void preencher_background(Screen* s, Color cor);
void render(Screen* s, bool reset);
void moveCursor(Vector2 v);


Color criar_cor(int r, int g, int b);

Color aplicar_filtro(Color original, Color filtro);
 


Vector2 new_Vector2(int x, int y);
Vector2 produto_vetor_escalar(Vector2 vet, float escalar);

Vector2 vector_sum(Vector2 v1, Vector2 v2);

Vector2 vector_subtr(Vector2 v1, Vector2 v2);

Vector2 reverse_vector (Vector2 v);

Vector2 get_abs_Pixel_pos(Objeto* obj, int index);

Vector2 get_complexo_abs_Pixel_pos(ObjetoComplexo* obj, int frame, int index);

Vector2 centro_do_objeto(Objeto* obj);

Vector2 centro_objeto_complexo(ObjetoComplexo* obj);

Vector2 centro_da_tela(Screen* s);


Pixel criar_Pixel(Color cor, Vector2 pos);

Pixel desempilhar_Pixel(Pixel_Stack* stack);

Pixel deletar_Pixel(Screen* s, Vector2 pos);
 


Objeto* criar_objeto_custom(Pixel* info, int qtd_Pixel, bool normalizar);

Objeto* recortar_objeto (Objeto* obj, Vector2 inicio, Vector2 fim);

Objeto* criar_retangulo_monocromatico(Color cor, Vector2 tamanho);

Objeto* criar_obj_eixos_debug(Screen* s);

Objeto* merge_objeto(Objeto* prioridade, Objeto* novo, Vector2 pivot);

Objeto* criar_piskel_obj (const uint32_t frame_data[], int width, int height);


ObjetoComplexo* criar_objeto_complexo_piskel(int qtd_frames, int width, int height, const uint32_t obj_data[qtd_frames][width * height]);

ObjetoComplexo* criar_objeto_complexo_via_lista(Objeto** obj_origem, int qtd_objetos);

Animation criar_anim(int* frame_list, int qtd_frames, char nome[]);

void setup_animations(ObjetoComplexo* obj, Animation anims[], int qtd_anims);

Pixel get_pixel_em(Screen* s, Vector2 pos);
bool vetor_valido_na_tela(Screen* s, Vector2 vet);
bool compare_vector(Vector2 v1, Vector2 v2);
bool obj_contem_Pixel_em(Objeto* obj, Vector2 pos);
int* obj_complexo_contem_Pixel_em(ObjetoComplexo* obj, Vector2 pos, int* out_qtd_de_frames);

void setar_animation_via_index(ObjetoComplexo* obj, int anim_index);
void setar_animation_via_nome(ObjetoComplexo* obj, char nome[]);
void animar_objeto_complexo(Screen* s, ObjetoComplexo* obj);
void setar_frame_obj_complexo(Screen* s, ObjetoComplexo* obj, int frame);

void aplicar_filtro_obj (Objeto* obj, Color filtro);
void aplicar_filtro_obj_complexo (ObjetoComplexo* obj, Color filtro);
void espelhar_objeto (Screen* s, Objeto* obj, bool horizontalmente);
void espelhar_objeto_complexo (Screen* s, ObjetoComplexo* obj, bool horizontalmente);
void rotacionar_objeto (Objeto* obj, Vector2 pivot, float graus);
void rotacionar_objeto_complexo (ObjetoComplexo* obj, Vector2 pivot, float graus);


void normalizar_objeto(Objeto* obj);
void centralizar_objeto(Objeto* obj);
void alterar_pivot_obj(Objeto* obj, Vector2 new_pivot);
void alterar_pivot_frame(ObjetoComplexo* obj, int frame, Vector2 novo_pivot);

void desenhar_objeto(Screen* s, Objeto* obj);
void desenhar_objeto_complexo (Screen* s, ObjetoComplexo* obj);
void esconder_objeto(Screen* s, Objeto* obj);
void esconder_objeto_complexo (Screen* s, ObjetoComplexo* obj);

void excluir_objeto(Objeto* obj);
void excluir_objeto_complexo(ObjetoComplexo* obj);
void excluir_tela(Screen* s);


void teleportar_objeto(Screen* s, Objeto* obj, Vector2 pos_final);
void teleportar_objeto_complexo(Screen* s, ObjetoComplexo* obj, Vector2 pos_final);
void mover_objeto(Screen* s, Objeto* obj, Vector2 direction);
void mover_objeto_complexo(Screen* s, ObjetoComplexo* obj, Vector2 direction);
 
#endif // GRAPHYCS_H