Трехмерная графика

#include <iostream>
#include <vector>
#include <conio.h>
#include <cmath>
#include <Windows.h>
 
#define M_PI 3.14159
#define M_PI_2 1.5708
#define M_PI_4 0.78539
 
typedef std::vector<std::pair<int, int>> vertex;
 
class Doom
{
public:
    float pos_x;
    float pos_y;
 
    float angle;
 
    float fov;
    
    size_t n;
    size_t m;
    int* frame;
 
    vertex* pMap;
 
    Doom()
    {
        pos_x = 0;
        pos_y = 0;
        angle = 0;
 
        fov = M_PI_4 / 2;
 
        n = 20;
        m = 40;
 
        frame = new int[n*m];
 
        frm_cls();
 
        pMap = nullptr;
    }
 
    ~Doom() 
    {
        delete [] frame;
    }
 
    float distance(float x, float y)
    {
        x -= pos_x;
        y -= pos_y;
 
        return sqrt(x*x + y*y);
    }
 
    void frm_cls()
    {
        memset(frame, 0, (n*m*sizeof(int)));
    }
 
    void load(vertex *p)
    {
        pMap = p;
    }
 
    void make_frame()
    {
        frm_cls();
        for(auto iter = pMap->begin(); iter != pMap->end(); ++iter)
        {
 
 
            float dist = distance(iter->first, iter->second);
            if(!dist) continue;
 
            float edge_an = asin((iter->second - pos_y) / dist);
            
            float temp = edge_an;
            if(edge_an < 0)
            {
                temp += 2*M_PI;
                if(iter->first - pos_x < 0)
                {
                    temp -= M_PI;
                    temp += 2 * fabs(edge_an);
                }
            } else {
                if(iter->first - pos_x < 0)
                {
                    temp += M_PI;
                    temp -= 2 * fabs(edge_an);
                }
            }
 
            edge_an = temp;
 
            if(fabs(angle - edge_an) <=  fov)
            {
                in_frame(edge_an, dist);
                continue;
                
            }
 
            if(angle > (2*M_PI - fov))
            {
                if(fabs(angle - (edge_an+2*M_PI)) <=  fov)
                {
                    in_frame(edge_an+2*M_PI, dist);
                
                }
            }
            
            if(angle < fov)
            {
                if((angle - (edge_an - 2*M_PI )) <= fov)
                {
                    in_frame(edge_an- 2*M_PI, dist);
                }
            }
 
        }
    }
 
    void in_frame(float e_an, float distance)
    {
        if(distance < 1.) return;
 
        int half = m/2;
        int horis = half - (half*((e_an - angle)/fov));
        if(horis < 0 || horis > 39) return;
 
        int height = n/(distance/3);
        if(height > 20) height = 20;
        for(size_t i=0, h = (n-height)/2; i<height; ++i)
        {
            *(frame+((h+i)*m)+horis) = 1;
        }
 
        //~~~~~~~~~~~~~~~~~~~~~~~~~
        *(frame+780) = 4;
        *(frame+781) = 7;
        *(frame+740) = 1;
 
        ///~~~~~~~~~~~~~~~~~~~~~~~~
 
    }
 
    void show()
    {
        int* f = frame;
        for(size_t i = 0; i < n; ++i)
        {
            for(size_t j = 0; j < m; ++j)
            {
                std::cout << (*(f++) ? "*" : " ");
            }
            std::cout << "\n";
        }
        for(size_t i = 0; i < m; ++i)
        {
            std::cout << "#";
        }
 
        std::cout << "\n     100    0       o_o       ##   20   \n";
    }
 
    void play()
    {
        if(control())
        {
            make_frame();
            system("cls");
            show();
        }
    
    }
 
    void start()
    {
        make_frame();
        show();
        while(1) play();
    }
 
    bool control()
    {
        int input = getch();
        input = getch();
 
        if(input == 77)
        {
            angle -= 0.05;
            if(angle < 0) angle = (M_PI * 2) - 0.05;
            return true;
        }
 
        if(input == 75)
        {
            angle += 0.05;
            if(angle > (M_PI * 2)) angle = 0.05;
            return true;
        }
 
        if(input == 80)
        {
 
            pos_x -= cos(angle);
            pos_y -= sin(angle);
            return true;
        }
        
        if(input == 72)
        {
 
            pos_x += cos(angle);
            pos_y += sin(angle);
            return true;
        }
 
        if(input == 27)
        {
            exit(0);
        }
 
        return false;
    }
 
 
};
 
int main()
{
    vertex map_vertex;
 
    for(float i = 1; i<9; i+=0.2)
    {
        map_vertex.push_back(std::make_pair(i,1));
        map_vertex.push_back(std::make_pair(i,5));
    }
 
    for(float i = 1; i<15; i+=0.2)
    {
        map_vertex.push_back(std::make_pair(15,i));
    }
 
    Doom X;
    X.load(&map_vertex);
    X.pos_x = 2;
    X.pos_y = 2;
 
    X.start();
 
 
    system("pause");
    return 0;
}

#include "portability.h"
#include <iostream>
#include <vector>
#include <cmath>
#include <cstring>
#include <curses.h>
 
class Screen{
private:
  int key_last; //код последней нажатой клавиши
  MEVENT event; //мышь
public:
  Screen();
  ~Screen();
  bool resize(size_t w, size_t h);
  void clear();
  void update();
  int key_pressed();
};
 
Screen::Screen(){
  initscr();
  noecho();
  curs_set(0);
  start_color();
  timeout(1);
  set_escdelay(0);
  keypad(stdscr, TRUE);
  mousemask(ALL_MOUSE_EVENTS, NULL);
  cbreak();
  leaveok(stdscr,false);
  nonl();
}
 
Screen::~Screen(){
  endwin();
}
 
bool Screen::resize(size_t w, size_t h){
  if((size_t)COLS < w || (size_t)LINES < h){
    move(0,0);
    attron(A_BLINK);
    printw("Resize terminal\n");
    attroff(A_BLINK);
    printw("to %ix%i\n", w, h);
    printw("Current size is %ix%i   \n",COLS,LINES);
    return false;
  }
  return true;
}
 
void Screen::clear(){
  erase();
}
 
void Screen::update(){
  key_last = getch();
  if(key_last == KEY_MOUSE)getmouse(&event);
}
 
int Screen::key_pressed(){
  return key_last;
}
 
 
Screen sc;
const unsigned int scr_w = 79;
const unsigned int scr_h = 25;
 
typedef std::vector<std::pair<int, int>> vertex;
 
class Doom{
public:
  float pos_x;
  float pos_y;
  
  float angle;
  
  float fov;
 
  int frame[scr_w * scr_h];
  
  vertex* pMap;
  
  Doom(){
    pos_x = 0;
    pos_y = 0;
    angle = 0;
    
    fov = M_PI_4 / 2;
    
    frm_cls();
    
    pMap = nullptr;
  }
  
  ~Doom(){
  }
  
  float distance(float x, float y){
    x -= pos_x;
    y -= pos_y;
    return sqrt(x*x + y*y);
  }
  
  void frm_cls(){
    memset(frame, 0, sizeof(frame));
  }
  
  void load(vertex *p){
    pMap = p;
  }
  
  void make_frame(){
    frm_cls();
    for(auto iter = pMap->begin(); iter != pMap->end(); ++iter){
      float dist = distance(iter->first, iter->second);
      if(!dist) continue;
      
      float edge_an = asin((iter->second - pos_y) / dist);
      
      float temp = edge_an;
      if(edge_an < 0){
        temp += 2*M_PI;
        if(iter->first - pos_x < 0){
          temp -= M_PI;
          temp += 2 * fabs(edge_an);
        }
      }else{
        if(iter->first - pos_x < 0){
          temp += M_PI;
          temp -= 2 * fabs(edge_an);
        }
      }
      
      edge_an = temp;
      
      if(fabs(angle - edge_an) <=  fov){
        in_frame(edge_an, dist);
        continue;
      }
      
      if(angle > (2*M_PI - fov)){
        if(fabs(angle - (edge_an+2*M_PI)) <=  fov){
          in_frame(edge_an+2*M_PI, dist);
        }
      }
      
      if(angle < fov){
        if((angle - (edge_an - 2*M_PI )) <= fov){
          in_frame(edge_an- 2*M_PI, dist);
        }
      }
      
    }
  }
  
  void in_frame(float e_an, float distance){
    if(distance < 1.) return;
    
    unsigned int half = scr_w/2;
    unsigned int horis = half - (half*((e_an - angle)/fov));
    if(horis < 0 || horis > scr_w) return;
    
    unsigned int height = scr_h/(distance/3);
    if(height > scr_h) height = scr_h;
    
    unsigned int h_min = (scr_h-height)/2;
    unsigned int h_max = scr_h - h_min;
    for(unsigned int i=h_min; i<h_max; i++)
      frame[horis + i*scr_w] = 1;
    
    //~~~~~~~~~~~~~~~~~~~~~~~~~
    // треугольник снизу?
    frame[scr_w/2 + scr_w*(scr_h-2)] = 4;
    frame[scr_w/2 + scr_w*(scr_h-1)] = 7;
    frame[scr_w/2+1 + scr_w*(scr_h-1)] = 1;
    ///~~~~~~~~~~~~~~~~~~~~~~~~
    
  }
  
  void show(){
    int* f = frame;
    move(0,0);
    for(size_t i = 0; i < scr_h; ++i){
      for(size_t j = 0; j < scr_w; ++j){
        if(*(f++))addch('*'); else addch(' ');
      }
      addch('\n');
    }
    for(size_t i = 0; i < scr_w; ++i){
      addch('#');
    }
    
    printw("\n     %3i    %3i       o_o       ##   %3i  \n", 100, 0, 20);
  }
  
  void start(){
    do{
      make_frame();
      show();
    }while(control());
  }
  
  bool control(){
    sc.update();
    int input = sc.key_pressed();
    
    if(input == KEY_RIGHT){
      angle -= 0.05;
      if(angle < 0) angle = (M_PI * 2) - 0.05;
      return true;
    }
    
    if(input == KEY_LEFT){
      angle += 0.05;
      if(angle > (M_PI * 2)) angle = 0.05;
      return true;
    }
    
    if(input == KEY_DOWN){
      pos_x -= cos(angle);
      pos_y -= sin(angle);
      return true;
    }
    
    if(input == KEY_UP){
      pos_x += cos(angle);
      pos_y += sin(angle);
      return true;
    }
    
    if(input == 27){
      return false;
    }
    
    return true;
  }
  
  
};
 
int main(){
  while(! sc.resize(80, 25)){
    sc.update();
    if(sc.key_pressed()==27)exit(0);
  }
 
  vertex map_vertex;
  
  for(float i = 1; i<9; i+=0.2){
    map_vertex.push_back(std::make_pair(i,1));
    map_vertex.push_back(std::make_pair(i,5));
  }
  
  for(float i = 1; i<15; i+=0.2){
    map_vertex.push_back(std::make_pair(15,i));
  }
  
  Doom X;
  X.load(&map_vertex);
  X.pos_x = 2;
  X.pos_y = 2;
  
  X.start();
  
  return 0;
}

int x = 1;
int y = pow(x, 2);

//~~~~~~~~~~~~~~~~~~~~~~~~~
* * * * *(frame+780) = 4;
* * * * *(frame+781) = 7;
* * * * *(frame+740) = 1;
///~~~~~~~~~~~~~~~~~~~~~~~~