fork(1) download
copy 
  1. #include <iostream>
  2.  
  3. #include <iomanip>
  4. #include <vector>
  5.  
  6. //#include <vec-simple.h>
  7.  
  8. #ifndef VECSIMPLE_H
  9. #define VECSIMPLE_H
  10. #ifndef VEC_H
  11. #define VEC_H
  12. #include <ostream>
  13.  
  14. #define ASSERT(n) (n);
  15. using namespace std;
  16.  
  17. template <size_t Dim,typename Number> class vec
  18. {
  19.  
  20. public:
  21.     typedef Number NumberT;
  22.     static const size_t DimN=Dim;
  23.     Number items[Dim];
  24.  
  25.     vec()
  26.     {
  27.  
  28.     }
  29.  
  30.     vec(const vec<Dim,Number >& src)
  31.     {
  32.         for(size_t i=Dim;i--;)
  33.         {
  34.             items[i]=src[i];
  35.         }
  36.     }
  37.  
  38.     vec(const Number* src)
  39.     {
  40.         for(size_t i=Dim;i--;)
  41.         {
  42.             items[i]=src[i];
  43.         }
  44.     }
  45.  
  46.     size_t maxPos() const
  47.     {
  48.         size_t ret=0;
  49.         for(size_t i=Dim;--i;)
  50.         {
  51.             if(items[i]>items[ret])
  52.             {
  53.                 ret=i;
  54.             }
  55.         }
  56.         return(ret);
  57.     }
  58.  
  59.     ostream& print(ostream& out) const
  60.     {
  61.         out<<"{ ";
  62.         for(size_t i=0;i<Dim;i++)
  63.         {
  64.             out<<setw(6)<<items[i]<<" ";
  65.         }
  66.         out<<"} ";
  67.         return(out);
  68.     }
  69.     static vec<Dim,Number > fill(const Number& val=0)
  70.     {
  71.         vec<Dim, Number> ret;
  72.         for(size_t i=Dim;i--;)
  73.         {
  74.             ret[i]=val;
  75.         }
  76.         return(ret);
  77.     }
  78.  
  79.     bool operator!=(const vec<Dim,Number>&v)
  80.     {
  81.         for(size_t i=Dim;i--;)
  82.         {
  83.             if(v[i]!=items[i])
  84.             {
  85.                 return(true);
  86.             }
  87.         }
  88.         return(false);
  89.     }
  90.  
  91.     Number& operator [](size_t index)
  92.     {
  93.         return(items[index]);
  94.     }
  95.     const Number& operator [](size_t index) const
  96.     {
  97.         return(items[index]);
  98.     }
  99. };
  100.  
  101. template<size_t Dim,typename Number>vec<Dim,Number > operator+(vec<Dim,Number > lhs, const vec<Dim,Number >& rhs)
  102. {
  103.     for(size_t i=Dim;i--;)
  104.     {
  105.         lhs[i]+=rhs[i];
  106.     }
  107.     return(lhs);
  108.  
  109. }
  110.  
  111. template<size_t Dim,typename Number>vec<Dim,Number > operator-(vec<Dim,Number > lhs, const vec<Dim,Number >& rhs)
  112. {
  113.     for(size_t i=Dim;i--;)
  114.     {
  115.         lhs[i]-=rhs[i];
  116.     }
  117.     return(lhs);
  118. }
  119.  
  120. template<size_t Dim,typename Number>vec<Dim,Number > operator*(vec<Dim,Number > lhs, const Number& rhs)
  121. {
  122.     for(size_t i=Dim;i--;)
  123.     {
  124.         lhs[i]*=rhs;
  125.     }
  126.     return(lhs);
  127. }
  128.  
  129.  
  130.  
  131. template<size_t Dim,typename Number>vec<Dim,Number > operator/(vec<Dim,Number > lhs, const Number& rhs)
  132. {
  133.     for(size_t i=Dim;i--;)
  134.     {
  135.         lhs[i]/=rhs;
  136.     }
  137.     return(lhs);
  138. }
  139.  
  140.  
  141. template<size_t Dim,typename Number> Number operator*(const vec<Dim,Number >&lhs, const vec<Dim,Number >& rhs)
  142. {
  143.     Number ret=0;
  144.     for(size_t i=Dim;i--;)
  145.     {
  146.         ret+=lhs[i]*rhs[i];
  147.     }
  148.     return(ret);
  149. }
  150.  
  151.  
  152. template<size_t len,size_t Dim, typename Number> vec<len,Number > proj(const vec<Dim,Number> &v,size_t start=0)
  153. {
  154.     return(vec<len,Number >(&v.items[start]));
  155. }
  156.  
  157. template<size_t len,size_t Dim, typename Number> vec<len,Number > dive(const vec<Dim,Number> &v,size_t start=0)
  158. {
  159.     vec<len,Number> ret(&v.items[start]);
  160.     for(size_t i=Dim+start;i<len;i++)
  161.     {
  162.         ret[i]=1;
  163.     }
  164.     return(ret);
  165. }
  166.  
  167. template<size_t Dim,typename Number> ostream& operator<<(ostream& os,const vec<Dim,Number >& v)
  168. {
  169.     return(v.print(os));
  170. }
  171.  
  172. template<size_t DimRows,size_t DimCols,typename Number> class mat;
  173.  
  174. template<size_t DimCols,size_t DimRows,typename Number> struct dt
  175. {
  176.     static Number det(const mat<DimRows,DimCols,Number>& src)
  177.     {
  178.         Number ret=0;
  179.         for(size_t i=DimCols;i--;)
  180.         {
  181.             ret+=src[0][i]*src.algAdd(0,i);
  182.         }
  183.         return(ret);
  184.     }
  185. };
  186.  
  187. template<typename Number> struct dt<1,1,Number>
  188. {
  189.     static Number det(const mat<1,1,Number>& src)
  190.     {
  191.         return(src[0][0]);
  192.     }
  193. };
  194.  
  195. template<size_t DimRows,size_t DimCols,typename Number> class mat
  196. {
  197.     vec<DimCols,Number> rows[DimRows];
  198.  
  199.  
  200. public:
  201.     typedef Number NumberT;
  202.     static size_t shift(size_t in,const size_t& val)
  203.     {
  204.         return(in<val ? in : ++in);
  205.     }
  206.  
  207.     mat()
  208.     {
  209.     }
  210.     mat(const mat<DimRows,DimCols,Number >& src)
  211.     {
  212.         for(size_t i=DimCols;i--;)
  213.         {
  214.             for(size_t j=DimRows;j--;)
  215.             {
  216.                 const Number t=src[i][j];
  217.                 rows[i][j]=t;
  218.             }
  219.         }
  220.     }
  221.  
  222.     ostream& print(ostream& out) const
  223.     {
  224.         for(size_t i=0;i<DimRows;i++)
  225.         {
  226.             out<<rows[i]<<"\n";
  227.         }
  228.         return(out);
  229.     }
  230.     vec<DimCols,Number > minimums()
  231.     {
  232.         vec<DimCols,Number > ret=rows[0];
  233.         for(size_t i=DimRows;--i;)
  234.         {
  235.             for(size_t j=DimCols;j--;)
  236.             {
  237.                 ret[j]=min(ret[j],rows[i][j]);
  238.             }
  239.         }
  240.         return(ret);
  241.     }
  242.  
  243.     vec<DimCols,Number > maximums()
  244.     {
  245.         vec<DimCols,Number > ret=rows[0];
  246.         for(size_t i=DimRows;--i;)
  247.         {
  248.             for(size_t j=DimCols;j--;)
  249.             {
  250.                 ret[j]=max(ret[j],rows[i][j]);
  251.             }
  252.         }
  253.         return(ret);
  254.     }
  255.     vec<DimCols,Number>& operator[] (size_t index)
  256.     {
  257.         return(rows[index]);
  258.     }
  259.  
  260.     const vec<DimCols,Number>& operator[] (size_t index) const
  261.     {
  262.         return(rows[index]);
  263.     }
  264.     static mat<DimCols,DimRows,Number> ones()
  265.     {
  266.         mat<DimCols,DimRows,Number> ret;
  267.         for(size_t i=DimRows;i--;)
  268.         {
  269.             for(size_t j=DimCols;j--;)
  270.             {
  271.                 ret[i][j]=(i==j);
  272.             }
  273.  
  274.         }
  275.         return(ret);
  276.     }
  277.  
  278.     Number det() const
  279.     {
  280.         return(dt<DimCols,DimRows,Number>::det(*this));
  281.     }
  282.  
  283.     mat<DimRows-1,DimCols-1,Number> minor(size_t row,size_t col) const
  284.     {
  285.         mat<DimRows-1,DimCols-1,Number> ret;
  286.         for(size_t i=DimRows-1;i--;)
  287.         {
  288.             for(size_t j=DimCols-1;j--;)
  289.             {
  290.                 ret[i][j]=rows[ret.shift(i,row)][ret.shift(j,col)];
  291.             }
  292.         }
  293.         return(ret);
  294.     }
  295.  
  296.  
  297.     Number algAdd(size_t row,size_t col) const
  298.     {
  299.         return(minor(row,col).det()*( (row+col)%2 ? -1 : 1));
  300.     }
  301.  
  302.     mat<DimRows,DimCols,Number> Adjacent()const
  303.     {
  304.         mat<DimRows,DimCols,Number> ret;
  305.         for(size_t i=DimRows;i--;)
  306.         {
  307.             for(size_t j=DimCols;j--;)
  308.             {
  309.                 ret[i][j]=algAdd(i,j);
  310.             }
  311.         }
  312.         return(ret);
  313.     }
  314.  
  315.     mat<DimRows,DimCols,Number> invertT()const
  316.     {
  317.         mat<DimRows,DimCols,Number> ret=Adjacent();
  318.         return(ret/(ret[0]*rows[0]));
  319.     }
  320.  
  321.     void setCol(const Number& val,size_t col)
  322.     {
  323.         for(size_t i=DimRows;i--;)
  324.         {
  325.             rows[i][col]=val;
  326.         }
  327.     }
  328.  
  329. };
  330.  
  331. template<size_t Dim,typename Number>vec<Dim,Number > operator*(const mat<Dim,Dim,Number >& lhs, const vec<Dim,Number>& rhs)
  332. {
  333.     vec<Dim,Number> ret;
  334.     for(size_t i=Dim;i--;)
  335.     {
  336.         ret[i]=lhs[i]*rhs;
  337.     }
  338.     return(ret);
  339. }
  340.  
  341. template<size_t DimCols,size_t DimRows,typename Number>mat<DimCols,DimRows,Number > operator/(mat<DimCols,DimRows,Number> lhs, const Number& rhs)
  342. {
  343.     for(size_t i=DimRows;i--;)
  344.     {
  345.         lhs[i]=lhs[i]/rhs;
  346.     }
  347.     return(lhs);
  348. }
  349.  
  350. template<size_t DimRows,size_t DimCols,typename Number> ostream& operator<<(ostream& os,const mat<DimRows,DimCols,Number>& v)
  351. {
  352.     return(v.print(os));
  353. }
  354.  
  355. typedef mat<2,2,float > tempMat;
  356.  
  357. #endif // VEC_H
  358.  
  359.  
  360. #endif // VECSIMPLE_H
  361.  
  362.  
  363.  
  364. using namespace std;
  365.  
  366. typedef vec<3,float> pixel;
  367.  
  368. class screen
  369. {
  370.     vector<pixel > buffer;
  371.     size_t width;
  372.     size_t height;
  373. public:
  374.     screen(size_t width,size_t height):width(width),height(height)
  375.     {
  376.         buffer.assign(width*height,pixel());
  377.     }
  378.     template<typename t> void putpixel(const t& location,const pixel& px)
  379.     {
  380.  
  381.         buffer[location[0]+location[1]*width]=px;
  382.     }
  383.  
  384.     ostream& print(ostream& out) const
  385.     {
  386.         for(size_t i=0;i<height;i++)
  387.         {
  388.             out<<"|";
  389.             for(size_t j=0;j<width;j++)
  390.             {                
  391.                 const size_t mp=buffer[i+j*width].maxPos();
  392.                 static const char syms[]={' ','.','\'','-','+','*'};
  393.                 static const char syms2[]={'R','G','B'};
  394.                 if(buffer[i+j*width][mp] > static_cast<pixel::NumberT>(sizeof(syms)-1)/static_cast<pixel::NumberT>(sizeof(syms)))
  395.                 {
  396.                     cout<<syms2[mp];
  397.                 }
  398.                 else
  399.                 {
  400.                     const size_t idx=buffer[i+j*width][mp]*float(sizeof(syms)-1);
  401.                     out<<syms[idx];
  402.                 }
  403.             }
  404.             out<<"|\n";
  405.         }
  406.         return(out);
  407.     }
  408. };
  409.  
  410. typedef vec<3,float > v3i;
  411. typedef vec<2,float > v2i;
  412. typedef mat<3,3,float>  m3i;
  413.  
  414.  
  415. template<typename V>class allPointsOfSquare
  416. {
  417.     vec<V::DimN,typename V::NumberT> topLeft;
  418.     vec<V::DimN,typename V::NumberT> bottomRight;
  419.     vec<V::DimN,typename V::NumberT> pos;
  420. public:
  421.     allPointsOfSquare(const V& topLeft,const V& bottomRight):topLeft(topLeft),bottomRight(bottomRight),pos(topLeft)
  422.     {
  423.     }
  424.     const v2i& operator *() const
  425.     {
  426.         return(pos);
  427.     }
  428.     bool next()
  429.     {
  430.         const bool ret=(pos!=bottomRight);
  431.         for(size_t i=V::DimN;i--;)
  432.         {
  433.             pos[i]++;
  434.             if(pos[i]>bottomRight[i])
  435.             {
  436.                 pos[i]=0;
  437.             }
  438.             else
  439.             {
  440.                 break;
  441.             }
  442.         }
  443.         return(ret);
  444.     }
  445. };
  446.  
  447. class IShader
  448. {
  449. public:
  450.     virtual ~IShader()
  451.     {
  452.  
  453.     }
  454.  
  455.     virtual pixel shade(const v3i& a)=0;
  456. };
  457.  
  458. class baryShader:public IShader
  459. {
  460. public:
  461.     virtual ~baryShader()
  462.     {
  463.  
  464.     }
  465.  
  466.     virtual pixel shade(const v3i&a)
  467.     {
  468.         return(a);
  469.     }
  470. };
  471.  
  472.  
  473. void fillTria(mat<3,3,float > coord,IShader* shader,screen& scr)
  474. {
  475.     //находим углы прямоугольника, в котором лежит треугольник.
  476.     //это соответственно минимумы и максимумы сторон, его содержащих
  477.  
  478.     v3i topLeft=coord.minimums();
  479.     v3i bottomRight=coord.maximums();
  480.  
  481.     coord.setCol(1,2);
  482.  
  483.     mat<3,3,float > bcm=coord.invertT();
  484.  
  485.     mat<3,2,float > directions;
  486.  
  487.     for(size_t i=3;i--;)
  488.     {
  489.         directions[i]=proj<2>(coord[ (i+1) % 3 ])-proj<2>(coord[i]);
  490.     }
  491.  
  492.     for(allPointsOfSquare<v2i> sweep=allPointsOfSquare<v2i>(
  493.                                                                 proj<2>(topLeft),
  494.                                                                 proj<2>(bottomRight))
  495.                         ;
  496.                                                                 sweep.next()
  497.                         ;
  498.                                                             )
  499.     {
  500.             size_t i=0;
  501.             for(;i<3;i++)
  502.             {
  503.                 v2i curDirection=(*sweep)-proj<2>(coord[i]);
  504.  
  505.                 tempMat crss;
  506.                 crss[0]=proj<2>(curDirection);
  507.                 crss[1]=proj<2>(directions[i]);
  508.  
  509.                 if(crss.det()>0)
  510.                 {                    
  511.                     break;
  512.                 }
  513.             }
  514.             if(i==3)
  515.             {                
  516.                 v3i a=bcm*dive<3>(*sweep);
  517.  
  518.                 scr.putpixel(*sweep,shader->shade(a));
  519.  
  520.             }
  521.     }
  522. }
  523.  
  524.  
  525.  
  526.  
  527. ostream& operator<<(ostream& os,const screen& v)
  528. {
  529.     return(v.print(os));
  530. }
  531.  
  532.  
  533.  
  534.  
  535. int main()
  536. {
  537.     screen scr(80,80);
  538. //    cout<<scr;
  539.     mat<3,3,float > t;
  540.     t[0][0]=5;
  541.     t[0][1]=7;
  542.     t[0][2]=3;
  543.  
  544.  
  545.     t[1][0]=70;
  546.     t[1][1]=13;
  547.     t[1][2]=13;
  548.  
  549.  
  550.  
  551.     t[2][0]=20;
  552.     t[2][1]=50;
  553.     t[2][2]=21;
  554.     cerr<<"started";
  555.  
  556.  
  557.     baryShader bs;
  558.     fillTria(t,&bs,scr);
  559.     cerr<<"filled";
  560.  
  561.     cout<<scr;
  562.  
  563.     return 0;
  564. }
  565.  
  566.  
Success #stdin #stdout #stderr 0s 3276KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|        RR                                                                      |
|        RRRRR                                                                   |
|        RRRRRR++                                                                |
|        RRRRRR+----                                                             |
|        RRRRR++-------                                                          |
|        RRRR++-----------                                                       |
|        RRR++-----------''''                                                    |
|        RRR+-----------'''''''                                                  |
|        RR++----------'''''''''''                                               |
|        R++-----------'''''''''''---                                            |
|         +-----------''''''''''''------                                         |
|         -----------''''''''''''''--------                                      |
|         -----------''''''''''''''--------+BB                                   |
|         ----------'''''''''''''''--------+BBBBB                                |
|         ---------''''''''''''''''--------++BBBBBBB                             |
|         --------'''''''''''''''''--------++BBBBBB                              |
|         --------'''''''''''''''''--------++BBBBB                               |
|         -------''''''''''''''''''--------++BBBB                                |
|         ------'''''''''''''''''''---------+BBBB                                |
|         -----'''''''''''.''''''''---------+BBB                                 |
|         -----''''''''''..''''''''---------+BB                                  |
|          ---'''''''''''..''''''''---------+B                                   |
|          --'''''''''''...'''''''''--------+B                                   |
|          -'''''''''''....'''''''''--------+                                    |
|          -''''''''''.....'''''''''--------                                     |
|          '''''''''''......''''''''-------                                      |
|          ''''''''''.......''''''''-------                                      |
|          '''''''''........''''''''------                                       |
|          '''''''''........''''''''-----                                        |
|          '''''''''''......''''''''----                                         |
|          ''''''''''''''...''''''''----                                         |
|          '''''''''''''''''''''''''---                                          |
|           '''''''''''''''''''''''''-                                           |
|           '''''''''''''''''''''''''                                            |
|           '''''''''''''''''''''''''                                            |
|           ''''''''''''''''''''''''                                             |
|           '''''''''''''''''''''''                                              |
|           ''''''''''''''''''''''                                               |
|           ''''''''''''''''''''''                                               |
|           ---''''''''''''''''''                                                |
|           ------''''''''''''''                                                 |
|           ---------'''''''''''                                                 |
|           ------------'''''''                                                  |
|            -------------''''                                                   |
|            ----------------                                                    |
|            ----------------                                                    |
|            ---------------                                                     |
|            --------------                                                      |
|            -------------                                                       |
|            -------------                                                       |
|            ------------                                                        |
|            -----------                                                         |
|            +++-------                                                          |
|            ++++++----                                                          |
|             GG++++++                                                           |
|             GGGGG++                                                            |
|             GGGGGG                                                             |
|             GGGGGG                                                             |
|             GGGGG                                                              |
|             GGGG                                                               |
|             GGG                                                                |
|             GGG                                                                |
|             GG                                                                 |
|             G                                                                  |
|             G                                                                  |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
|                                                                                |
stderr
copy 
startedfilled
https://ideone.com/SwLCdQ
language:
C++ (gcc 8.3)
created:
9 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!