Render High Dimensional Object In Terminal

So all this just to render a cube on your terminal ?

后来做成工程概论大作业的网页版本(手机慎点)，使用了threejs这个图形库来绘制和打光，比起控制台来说虽然不那么geek，但是稍微更直观那么亿点，应该还存在一些bug，但是3，4，5维下应该是没什么问题

封面gif为超立方体绕xw与xz轴的旋转，至于结果的正确性，我参照了wiki且自认为无误，例如下图就是一些与超立方体相关的图片

超立方体解构

超立方体绕xw轴旋转

不妨先来看看我的代码都渲染出了些什么：

图像	说明
	此为在Render 3D Object In Terminal基础上修改的代码，限于模型生成原理与渲染原理写的稀烂而无法拓展到更高的五维，且由于法向量并非实时计算而是手动设置，导致旋转时的”四维面“渲染错误（就是gif中看见明显是个正方体但是却没有正确的打光的一坨吞过来吐回去的东西）
	后来对模型生成原理与渲染原理大改，引入顶点模型并实时计算法向量，正确渲染出了这个超立方体
	在四维升五维时又出现了代码通用性的问题，发现五维时存在多处三角形的各顶点几乎位于同一直线的情况，对判断质心与直线关系的方程引入一个很小的Δoffest解决此问题

最后写了透明材质，为了方便和实际效果没有对透明材质计算光照，透明物体代码比不透明的简单，但确实便利了理解内部结构变化

透明四维

透明五维

对渲染与模型的改进大纲

三角形：先前的正方体和球体模型都是实际存在于数组中的非常多的点，每个点与屏幕上的点对应，不仅空间占用多，算力跟不上，法向量也是针对正方体和球体的几何性质为其手动安排的，缺乏普适性
- 解决：对于正方体，只需要求出正方体的顶点以及顶点之间的位置关系（哪些顶点相邻），即可由此推得三角形、四棱锥等独立的局部图形，这带来的好处有：
  - 普适性增强，即使物体不是正方体也能以此方式计算、渲染
  - 性能提升，维度得以升的更高，计算速度快了亿点点
  - 可以通过计算局部质心准确区分内外法向量，但是此处的正方体是凸几何体，直接以原点（正方体质心）区分内外法向量也是足够的
内外法向量：现有一模型的相邻三点确定的平面ABC，如何区分内外法向量？
- 解决：因为我面对的对象是正方体，所以只要对任意顶点向量加上法向量，将作此偏移后的向量与其对应顶点向量比较模长大小，即可判断内外法向量
  
  但这样会在凹几何体上有误
  
  所以普适的做法应是再寻找一个相邻顶点，确定一个四面体，计算此四面体质心，然后以此质心为基准作同样的偏移后的模长比较
透视投影：人眼观察物体是小孔成像，透视投影，正投影会缺少近大远小的特征，且只有在降维时透视投影才能使高维几何体投影出令人满意的效果（否则就是黏成一坨扭来扭曲，没有大小变化），透视投影的投影矩阵通过一个相似三角形就出来了，点到为止
半透明材质：就简不就繁，再精致的透明材质在终端也看不出来，我的做法是不再计算法向量，发现投影到屏幕上的面有几个，该点的alpha就加到几，然后应用下面这个式子把alpha换回 [0,1) 内（整个幂主要是想让曲线平滑一点，去掉也可以）

alpha=1-1/(k*alpha+1)^3/2

以下是最终的源码，重要参数全部在define或全局变量中

后记：突然发现有一处用了public做了变量名/捂脸，但是C语言没有class，所以那里的public是指模型的公共顶点

简洁版

#define a 8.0
#define pi 3.1415926
#define size 55
#define delta 0.5
#define deltaA 0.02
#define eOffest 0.001
#define dimension 5
#define transparent 0.6
char shade[]=".,:;!om0&%@";
float lightSrcDis=5*a;
float light[3]={-2,5,0.8};
int rotateAround[]={3,4,0,2};
float vAxis[]     ={ 3 , 1 };
float initialCam[3]={0,pi*5/24,0};
float calLength(float *vec,int len){
    float result=0;
    for(int i=0;i<len;i++) result+=vec[i]*vec[i];
    return sqrt(result);}
int main(){
    float lightLength=calLength(&light[0],3);
    for(int i=0;i<3;i++) light[i]/=lightLength;
    float out_f[size][size],dis[size][size]={(float)4*size};
    float move=(size-1)/2;
    int face=((int)(pow(2,dimension-3)*dimension*(dimension-1)));
    int vexNum=(int)(pow(2,dimension))*dimension;
    int vexLink[vexNum],normalLink[6*face];
    float vex[vexNum],vexO[vexNum],vexProjected[vexNum],vexTemp[vexNum];
    float normalResultSet[6*face];
    memset(vexLink,0xff,sizeof(vexLink));
    memset(normalLink,0xff,sizeof(normalLink));
    for(int i=0;i<vexNum;i++) vex[i]=a;
    vex[dimension]=-a;
    for(int vexIndex=2,difference,sign,i;vexIndex*dimension<vexNum;vexIndex++){
        for(sign=0;sign<dimension;sign++){
            for(i=0;i<vexIndex-1;i++){difference=0;
                for(int k=0;k<dimension&&!difference;k++)
                    if(sign==k?vex[i*dimension+k]!=-1*vex[(vexIndex-1)*dimension+k]:vex[i*dimension+k]!=vex[(vexIndex-1)*dimension+k]) difference=1;
                if(!difference) break;
            }if(difference) break;
        }for(int k=0;k<dimension;k++) vex[vexIndex*dimension+k]=k==sign?-1*vex[(vexIndex-1)*dimension+k]:vex[(vexIndex-1)*dimension+k];}
    for(int vexIndex=0,n=0;vexIndex*dimension<vexNum;vexIndex++,n=0){
        for(int linkIndex=0;linkIndex<vexIndex;linkIndex++)
            for(int i=0;i<dimension;i++)
                if(vexLink[linkIndex*dimension+i]==vexIndex) vexLink[vexIndex*dimension+n++]=linkIndex;
        for(int i=vexIndex+1,difference=0,tooManyDiff,sign;i*dimension<vexNum&&n!=dimension;i++,difference=0){
            for(int k=0;k<dimension&&difference<=1;k++)
                if(vex[i*dimension+k]!=vex[vexIndex*dimension+k]) difference++;
            if(difference==1) vexLink[vexIndex*dimension+n++]=i;}}
    for(int cur1=0,normalIndex=0;cur1<vexNum/dimension&&normalIndex!=2*face;cur1+=2)
        for(int cur2=0,pDiag=0;cur2<vexNum/dimension&&normalIndex!=2*face;cur2++){
            if(cur1==cur2) continue;
            for(int i=0;i<dimension&&!pDiag;i++)
                for(int j=0;j<dimension&&!pDiag;j++)
                    if(vexLink[vexLink[cur1*dimension+i]*dimension+j]==cur2) pDiag=1;
            if(pDiag){
                int public[dimension-1];
                memset(public,0xff,sizeof(public));
                for(int i=0,k=0;i<dimension&&k<dimension-1;i++)
                    for(int j=0;j<dimension&&k<dimension-1;j++)
                        if(vexLink[cur1*dimension+i]==vexLink[cur2*dimension+j]) public[k++]=vexLink[cur1*dimension+i];
                for(int i=0;i<=normalIndex;i++)
                    if  (   (cur1==normalLink[i*3]||cur1==normalLink[i*3+1]||cur1==normalLink[i*3+2])
                        &&  (cur2==normalLink[i*3]||cur2==normalLink[i*3+1]||cur2==normalLink[i*3+2]))
                        for(int j=0;j<dimension-1;j++)
                            if(public[j]==normalLink[i*3]||public[j]==normalLink[i*3+1]||public[j]==normalLink[i*3+2]) public[j]=-1;
                for(int i=0;i<dimension-1;i++)
                    if(public[i]!=-1){
                        for(int j=0;j<3;j++)normalLink[normalIndex*3+j]=j==0?cur1:j==1?cur2:public[i];
                        normalIndex++;}}}
    memcpy(vexTemp,vex,sizeof(vex[0])*vexNum);
    memcpy(vexO,vex,sizeof(vex[0])*vexNum);
    for(float angle=0;;angle+=deltaA){
        for(int i=0;i<size;i++)
            for(int j=0;j<size;j++){
                out_f[i][j]=-1;
                dis[i][j]=(float)(-4.0*size);}
        memcpy(vex,vexO,sizeof(vexO));
        for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++)
            for(int rotationIndex=0,r_i=0;rotationIndex<sizeof(rotateAround)/sizeof(rotateAround[0])/2;rotationIndex++,r_i=0){
                memcpy(vexTemp,vex,sizeof(vex));
                for(int i=0;i<dimension;i++)
                    if(i==rotateAround[rotationIndex*2+r_i])
                        vex[vexIndex*dimension+i]=vexTemp[vexIndex*dimension+i]*cos(vAxis[rotationIndex]*angle)+vexTemp[vexIndex*dimension+rotateAround[rotationIndex*2+!r_i]]*sin(vAxis[rotationIndex]*angle)*(1-2*r_i++);}
        for(int i=0;i<3;i++){
            memcpy(vexTemp,vex,sizeof(vex));
            int c=!(i^1),b=i<=1?2:1;
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++) vex[vexIndex*dimension+!(i^1)] = vexTemp[vexIndex*dimension+!(i^1)]*cos(initialCam[i]) + vexTemp[vexIndex*dimension+(i<=1?2:1)]*sin(initialCam[i]);
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++) vex[vexIndex*dimension+(i<=1?2:1)] = vexTemp[vexIndex*dimension+(i<=1?2:1)]*cos(initialCam[i]) - vexTemp[vexIndex*dimension+!(i^1)]*sin(initialCam[i]);}
        float xyBefore[2*vexNum];
        memcpy(vexProjected,vex,sizeof(vex[0])*vexNum);
        for(int d=dimension-1;d>=2;d--){
            if(d==2){
                for(int i=0;i<vexNum/dimension;i++) for(int j=0;j<=1;j++) xyBefore[i*2+j]=vexProjected[i*dimension+j];
                for(int normalIndex=0;normalIndex<2*face;normalIndex++){
                    float vec1[3],vec2[3];
                    for(int i=0;i<3;i++){
                        vec1[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]-vexProjected[normalLink[normalIndex*3+1]*dimension+i];
                        vec2[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]-vexProjected[normalLink[normalIndex*3+2]*dimension+i];}
                    for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]=vec1[i==0?1:i==1?2:0]*vec2[i==0?2:i==1?0:1]-vec1[i==0?2:i==1?0:1]*vec2[i==0?1:i==1?2:0];
                    float normalLength=calLength(&normalResultSet[3*normalIndex],3);
                    if(normalLength!=0)
                        for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]/=normalLength;
                    if(!transparent){
                        float slidedVec[3],slideLength,vexLength=calLength(&vexProjected[normalLink[normalIndex*3]*dimension],3);
                        for(int i=0;i<3;i++) slidedVec[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]+normalResultSet[3*normalIndex+i];
                        slideLength=calLength(slidedVec,3);
                        if(slideLength>vexLength)
                            for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]*=-1;}}}
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++)
                for(int axis=0;axis<d;axis++) vexProjected[vexIndex*dimension+axis]=vexProjected[vexIndex*dimension+axis]*lightSrcDis/(lightSrcDis-vexProjected[vexIndex*dimension+d]);}
        for(int sx=0;sx<size;sx++) for(int sy=0;sy<size;sy++)
            for(int normalIndex=0,inside=1;normalIndex<2*face;normalIndex++,inside=1){
                float tCenter[2]={0};
                float x[3],y[3],z[3],xb[3],yb[3];
                for(int i=0;i<3;i++){
                    x[i]=vexProjected[normalLink[normalIndex*3+i]*dimension];
                    tCenter[0]+=x[i];
                    y[i]=vexProjected[normalLink[normalIndex*3+i]*dimension+1];
                    tCenter[1]+=y[i];
                    z[i]=vexProjected[normalLink[normalIndex*3+i]*dimension+2];
                    xb[i]=xyBefore[normalLink[normalIndex*3+i]*2];
                    yb[i]=xyBefore[normalLink[normalIndex*3+i]*2+1];}
                tCenter[0]/=3;tCenter[1]/=3;
                for(int i=0;i<3&&inside;i++){
                    if(     ((tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])
                            ?(sy-move-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])>(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(sx-move-x[i==0?1:i==1?0:0])
                            :(sy-move-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(sx-move-x[i==0?1:i==1?0:0]))
                            ||((tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])+eOffest>(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])
                            &&(tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])-eOffest<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])))
                        inside=0;}
                if(inside){float alpha,currentDis,p[4];
                    if(transparent) out_f[sy][sx]=out_f[sy][sx]<0?1:out_f[sy][sx]+1;
                    else{
                        p[0]= yb[0]*z[1] -yb[0]*z[2] -yb[1]*z[0] +yb[1]*z[2] +yb[2]*z[0] -yb[2]*z[1];
                        p[1]=-xb[0]*z[1] +xb[0]*z[2] +xb[1]*z[0] -xb[1]*z[2] -xb[2]*z[0] +xb[2]*z[1];
                        p[2]= xb[0]*yb[1] -xb[0]*yb[2] -xb[1]*yb[0] +xb[1]*yb[2] +xb[2]*yb[0] -xb[2]*yb[1];
                        p[3]=-xb[0]*yb[1]*z[2] +xb[0]*yb[2]*z[1] +xb[1]*yb[0]*z[2] -xb[1]*yb[2]*z[0] -xb[2]*yb[0]*z[1] +xb[2]*yb[1]*z[0];
                        currentDis=lightSrcDis*(p[0]*(sx-move)+p[1]*(sy-move)+p[3])/(p[0]*(sx-move)+p[1]*(sy-move)-p[2]*lightSrcDis);
                        if(currentDis>dis[sy][sx]){
                            alpha=0;
                            for(int i=0;i<3;i++) alpha+=normalResultSet[normalIndex*3+i]*light[i];
                            dis[sy][sx]=currentDis;
                            out_f[sy][sx]=alpha>1||alpha<-1?alpha>1?10:0:(alpha*10+10)*0.5;}}}}
        for(int i=0,outIndex;i<size;i++){
            for(int j=0;j<size;j++){
                if(!transparent) outIndex=(int)out_f[i][j];
                else outIndex=(int)(pow((1-1/(transparent*out_f[i][j]+1)),2)*10);
                out_f[i][j]!=-1?printf("%c%c",shade[outIndex],shade[outIndex]):printf("  ");
            }printf("\n");
        }printf("\x1b[2J");printf("\x1b[H");usleep(30000);}}

以上代码只是看起来比较好看，以下是以下是带注释与测试代码的源码，环境是win，linux的话把清屏部分的代码稍微改改即可，可以参考前文提到的之前的博客Render 3D Object In Terminal

注释版

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <Windows.h>
#define a 8.0//立方体边长
#define pi 3.1415926
#define size 55//荧幕大小
#define delta 0.5//遍历方块的步长
#define deltaA 0.02//物体旋转速度
#define eOffest 0.001//判定点是否在平面内时的方程阈值
#define dimension 5//维数
#define transparent 0//是否使用透明材质，同时是透明的倍率，四维推荐0.75，五维推荐0.6

//坐标系说明：x向右，y向下，z向前
char shade[]=".,:;!om0&%@";//阴影字符集十一个，便于选取
float lightSrcDis=5*a;//透视投影时的光源距离
float light[3]={-2,5,0.8};//平行光向量，选取了一个比较舒服的打光
int rotateAround[]={3,4,1,3,0,2};//确定旋转基准，指定参与旋转的方向，两个一组，一组中小的在前大的在后
float vAxis[]     ={ 3 , 2 , 1 };//对应上边的配速倍率
float initialCam[3]={0,pi*5/24,0};//水平旋转 前后倾斜 左右倾斜，注意用弧度角，如 pi/4
/*initialObj[已删除]：正方体初始摆放的角度；initialObj：摄像机初始摆放的角度
旋转顺序：initialObj → rotateAround → initialCam
initialObj感觉用处不大，删了算了*/
/*计算向量模长
--------------------
Par:
    vec[]：向量
    len：元素个数
--------------------*/
float calLength(float *vec,int len){
    float result=0;
    for(int i=0;i<len;i++) result+=vec[i]*vec[i];
    return sqrt(result);
}

int main(){
    COORD pos={0,0};//光标回零
    float lightLength=calLength(&light[0],3);
    for(int i=0;i<3;i++) light[i]/=lightLength;//单位化平行光向量
    float out_f[size][size],dis[size][size]={(float)4*size};//记录亮度，映射到字符集 | 记录三维投影后到屏幕最小距离，由此判断遮罩关系
    float move=(size-1)/2;//从坐标原点(屏幕左上角)偏移到屏幕中心所需的偏移量
    int face=((int)(pow(2,dimension-3)*dimension*(dimension-1)));
    /*  面数公式解释
        每个 n 维正方体中的每个 m 维边界都会被 n-m 个 m+1 维边界共用。比如正六面体中，每条棱被两个面共用，而每个顶点被三条棱共用。
        这样算来，对于任意一个 n 维的正方体，计算其不重复的二维正方形表面的数量应该为：
          6x8x10x...x(2n)/(2*3*...*(n-2))
        =(2^(n-2))*(n!)/2/(n-2)!
        =(2^(n-3))*n*(n-1)*/
    int vexNum=(int)(pow(2,dimension))*dimension;//顶点个数*维数
    int vexLink[vexNum],normalLink[6*face];//相邻顶点集，如：三维中0号顶点与1，3，7相邻，则前dimension个元素为1，3，7 | 同理，法向量对应三角形面的三个vex的index
    float vex[vexNum],vexO[vexNum],vexProjected[vexNum],vexTemp[vexNum];//当前顶点坐标 | 原始顶点坐标 | 投影后顶点坐标 | 临时
    float normalResultSet[6*face];//法向量结果集
    memset(vexLink,0xff,sizeof(vexLink));//初始化
    memset(normalLink,0xff,sizeof(normalLink));
    for(int i=0;i<vexNum;i++) vex[i]=a;
    vex[dimension]=-a;//这个算法需要有前车之鉴
    /*得到顶点坐标
    用上一向量一个元素变号，使其与之前任一向量都不同，该向量即要找的下一个顶点
    向量不同 = 元素至少有一个不相同*/
    for(int vexIndex=2,difference,sign,i;vexIndex*dimension<vexNum;vexIndex++){
        for(sign=0;sign<dimension;sign++){//遍历尝试改变vexIndex-1向量的每一单个元素正负号，执行条件：d为假
            for(i=0;i<vexIndex-1;i++){difference=0;//遍历每个向量，执行条件：d为真，每次初始化d为假
                for(int k=0;k<dimension&&!difference;k++)//遍历比较vexIndex-1向量与之前向量的元素
                    if(sign==k?vex[i*dimension+k]!=-1*vex[(vexIndex-1)*dimension+k]:vex[i*dimension+k]!=vex[(vexIndex-1)*dimension+k]) difference=1;
                if(!difference) break;
            }
            if(difference) break;
        }
        for(int k=0;k<dimension;k++) vex[vexIndex*dimension+k]=k==sign?-1*vex[(vexIndex-1)*dimension+k]:vex[(vexIndex-1)*dimension+k];
    }
    /*测试代码：打印vex
    for(int i=0;i<vexNum/dimension;i++){
        if(i<10) printf(" %d= ",i);
        else printf("%d= ",i);
        for(int j=0;j<dimension;j++){
            if(vex[i*dimension+j]>=0)printf(" %.0f,",vex[i*dimension+j]);
            else printf("%.0f,",vex[i*dimension+j]);
        }
        printf("\n");
    }
    printf("Vex Above\n");
    //*/
    /*得到相邻顶点，相邻顶点在vex中的index存储到vexLink中
    先在vexLink中已经建立link的部分找有没有之前link到过当前正在建立link的点，有则直接加入当前的link
    linkIndex：这是第几个已经建立link的点
    在link数量达到dimension之前，用当前向量与之前的向量作比较，如果_只_更_改_一_个_符_号_就可以匹配，则加入link，直到当前向量的link满dimension个*/
    for(int vexIndex=0,n=0;vexIndex*dimension<vexNum;vexIndex++,n=0){//vexIndex：当前正在建立link的点 | n：已经建立到第几个link了
        for(int linkIndex=0;linkIndex<vexIndex;linkIndex++)
            for(int i=0;i<dimension;i++)
                if(vexLink[linkIndex*dimension+i]==vexIndex) vexLink[vexIndex*dimension+n++]=linkIndex;
        for(int i=vexIndex+1,difference=0,tooManyDiff,sign;i*dimension<vexNum&&n!=dimension;i++,difference=0){//遍历当前向量之后的每个向量 || difference：存在不一样的元素的数量
            for(int k=0;k<dimension&&difference<=1;k++)//遍历被比较向量中的每个元素
                if(vex[i*dimension+k]!=vex[vexIndex*dimension+k]) difference++;
            if(difference==1) vexLink[vexIndex*dimension+n++]=i;
        }
    }
    /*测试代码：打印vexLink
    for(int i=0;i<vexNum/dimension;i++){
        if(i<10) printf(" %d= ",i);
        else printf("%d= ",i);
        for(int j=0;j<dimension;j++){
            if(vexLink[i*dimension+j]>=10)printf("%d, ",vexLink[i*dimension+j]);
            else printf(" %d ,",vexLink[i*dimension+j]);
        }
        printf("\n");
    }
    printf("vexLink Above\n");
    //*/
    //得到面对应的三个点
    for(int cur1=0,normalIndex=0;cur1<vexNum/dimension&&normalIndex!=2*face;cur1+=2)//cur n 表示指向第几个顶点，normalIndex表这是已经找到的第几个三角形
        for(int cur2=0,pDiag=0;cur2<vexNum/dimension&&normalIndex!=2*face;cur2++){//pDiag(Plane Diagonal)表是否为平面对角点，即cur1通过Link索引，在第二次可以索引到cur2
            if(cur1==cur2) continue;
            for(int i=0;i<dimension&&!pDiag;i++)//第一次索引的偏移
                for(int j=0;j<dimension&&!pDiag;j++)//第二次索引的偏移
                    if(vexLink[vexLink[cur1*dimension+i]*dimension+j]==cur2) pDiag=1;
            if(pDiag){
                int public[dimension-1];
                memset(public,0xff,sizeof(public));
                for(int i=0,k=0;i<dimension&&k<dimension-1;i++)
                    for(int j=0;j<dimension&&k<dimension-1;j++)
                        if(vexLink[cur1*dimension+i]==vexLink[cur2*dimension+j]) public[k++]=vexLink[cur1*dimension+i];
                for(int i=0;i<=normalIndex;i++)//i指向normalLink中的向量
                    if  (   (cur1==normalLink[i*3]||cur1==normalLink[i*3+1]||cur1==normalLink[i*3+2])//cur1与第i个normalLink中存在元素重合？
                        &&  (cur2==normalLink[i*3]||cur2==normalLink[i*3+1]||cur2==normalLink[i*3+2]))//cur2与第i个normalLink中存在元素重合？
                        for(int j=0;j<dimension-1;j++)
                            if(public[j]==normalLink[i*3]||public[j]==normalLink[i*3+1]||public[j]==normalLink[i*3+2]) public[j]=-1;//public[j]与第i个normalLink中存在元素重合？
                for(int i=0;i<dimension-1;i++)
                    if(public[i]!=-1){
                        for(int j=0;j<3;j++)normalLink[normalIndex*3+j]=j==0?cur1:j==1?cur2:public[i];
                        normalIndex++;
                    }
            }
        }
    /*测试代码：打印normalLink
    for(int i=0;i<2*face;i++){
        //if(i<10) printf(" %d= ",i);
        //else printf("%d= ",i);
        for(int j=0;j<3;j++){
            if(normalLink[i*3+j]>=10) printf("%d, ",normalLink[i*3+j]);
            else printf("0%d, ",normalLink[i*3+j]);
        }
        printf("\n");
    }
    printf("normalLink Above\n");
    //*/
    memcpy(vexTemp,vex,sizeof(vex[0])*vexNum);
    memcpy(vexO,vex,sizeof(vex[0])*vexNum);
    //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    for(float angle=0;;angle+=deltaA){//大循环
        for(int i=0;i<size;i++)
            for(int j=0;j<size;j++){
                out_f[i][j]=-1;
                dis[i][j]=(float)(-4.0*size);
            }//初始化
        memcpy(vex,vexO,sizeof(vexO));//还原vex到初始状态，否则带角加速度
        //计算向量与旋转矩阵相乘，0太多，没必要搞真正的矩阵乘法
        for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++)
            for(int rotationIndex=0,r_i=0;rotationIndex<sizeof(rotateAround)/sizeof(rotateAround[0])/2;rotationIndex++,r_i=0){//限定旋转次数；rotateAround每行2个元素，j的作用是选取他们
                memcpy(vexTemp,vex,sizeof(vex));
                for(int i=0;i<dimension;i++)//遍历所有的轴
                    if(i==rotateAround[rotationIndex*2+r_i])//当前轴是被旋转轴时，结果符合旋转矩阵计算结果
                        vex[vexIndex*dimension+i]=vexTemp[vexIndex*dimension+i]*cos(vAxis[rotationIndex]*angle)+vexTemp[vexIndex*dimension+rotateAround[rotationIndex*2+!r_i]]*sin(vAxis[rotationIndex]*angle)*(1-2*r_i++);
            }
        for(int i=0;i<3;i++){//摄像机旋转
            memcpy(vexTemp,vex,sizeof(vex));
            int c=!(i^1),b=i<=1?2:1;
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++) vex[vexIndex*dimension+!(i^1)] = vexTemp[vexIndex*dimension+!(i^1)]*cos(initialCam[i]) + vexTemp[vexIndex*dimension+(i<=1?2:1)]*sin(initialCam[i]);
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++) vex[vexIndex*dimension+(i<=1?2:1)] = vexTemp[vexIndex*dimension+(i<=1?2:1)]*cos(initialCam[i]) - vexTemp[vexIndex*dimension+!(i^1)]*sin(initialCam[i]);
        }
        //以透视投影降维
        float xyBefore[2*vexNum];//备份x，y轴用于计算平面方程
        memcpy(vexProjected,vex,sizeof(vex[0])*vexNum);
        for(int d=dimension-1;d>=2;d--){//d+1 = 当前维数
            if(d==2){//趁还在三维的时候先把法向量算了，不然反光的面就也透视了
                for(int i=0;i<vexNum/dimension;i++) for(int j=0;j<=1;j++) xyBefore[i*2+j]=vexProjected[i*dimension+j];
                for(int normalIndex=0;normalIndex<2*face;normalIndex++){
                    float vec1[3],vec2[3];
                    for(int i=0;i<3;i++){
                        vec1[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]-vexProjected[normalLink[normalIndex*3+1]*dimension+i];
                        vec2[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]-vexProjected[normalLink[normalIndex*3+2]*dimension+i];
                    }
                    for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]=vec1[i==0?1:i==1?2:0]*vec2[i==0?2:i==1?0:1]-vec1[i==0?2:i==1?0:1]*vec2[i==0?1:i==1?2:0];
                    float normalLength=calLength(&normalResultSet[3*normalIndex],3);
                    if(normalLength!=0)
                        for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]/=normalLength;
                    if(!transparent){//以全局质心计算，使法向量向外
                        float slidedVec[3],slideLength,vexLength=calLength(&vexProjected[normalLink[normalIndex*3]*dimension],3);
                        for(int i=0;i<3;i++) slidedVec[i]=vexProjected[normalLink[normalIndex*3]*dimension+i]+normalResultSet[3*normalIndex+i];
                        slideLength=calLength(slidedVec,3);
                        if(slideLength>vexLength)
                            for(int i=0;i<3;i++) normalResultSet[3*normalIndex+i]*=-1;
                    }
                }
            }
            for(int vexIndex=0;vexIndex<vexNum/dimension;vexIndex++)//vexIndex：第几个向量，axis：该向量的第几个元素
                for(int axis=0;axis<d;axis++) vexProjected[vexIndex*dimension+axis]=vexProjected[vexIndex*dimension+axis]*lightSrcDis/(lightSrcDis-vexProjected[vexIndex*dimension+d]);
            /*测试代码：打印vexProjected
            for(int i=0;i<vexNum/dimension&&d>2;i++){
                if(i<10) printf(" %d= ",i);
                else printf("%d= ",i);
                for(int j=0;j<dimension;j++){
                    if(vexProjected[i*dimension+j]>=0)printf(" %.2f,",vexProjected[i*dimension+j]);
                    else printf("%.2f,",vexProjected[i*dimension+j]);
                }
                printf("\n");
            }
            if(d>2) printf("VexPorjected Above , dimension = %d\n",d);
            //*/
        }
        //输出到out_f[]
        for(int sx=0;sx<size;sx++)
            for(int sy=0;sy<size;sy++)
                for(int normalIndex=0,inside=1;normalIndex<2*face;normalIndex++,inside=1){
                    float tCenter[2]={0};//当前三角形质心
                    float x[3],y[3],z[3],xb[3],yb[3];
                    for(int i=0;i<3;i++){
                        x[i]=vexProjected[normalLink[normalIndex*3+i]*dimension];
                        tCenter[0]+=x[i];
                        y[i]=vexProjected[normalLink[normalIndex*3+i]*dimension+1];
                        tCenter[1]+=y[i];
                        z[i]=vexProjected[normalLink[normalIndex*3+i]*dimension+2];
                        xb[i]=xyBefore[normalLink[normalIndex*3+i]*2];
                        yb[i]=xyBefore[normalLink[normalIndex*3+i]*2+1];
                    }
                    tCenter[0]/=3;
                    tCenter[1]/=3;
                    for(int i=0;i<3&&inside;i++){//判断当前屏幕的点是否在三角形范围内
                        if(     ((tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])
                                ?(sy-move-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])>(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(sx-move-x[i==0?1:i==1?0:0])
                                :(sy-move-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(sx-move-x[i==0?1:i==1?0:0]))
                                ||((tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])+eOffest>(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])
                                &&(tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0])-eOffest<(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0])))
                            inside=0;
                    }
                    if(inside){
                        /*测试代码：方程阈值检验
                        if(sx==0){
                            for(int i=0;i<3&&inside;i++){
                                double b=(tCenter[1]-y[i==0?1:i==1?0:0])*(x[i==0?2:i==1?2:1]-x[i==0?1:i==1?0:0]);
                                double c=(y[i==0?2:i==1?2:1]-y[i==0?1:i==1?0:0])*(tCenter[0]-x[i==0?1:i==1?0:0]);\
                                double d=b-c;
                            }
                        }
                        //*/
                        float alpha,currentDis,p[4];
                        if(transparent) out_f[sy][sx]=out_f[sy][sx]<0?1:out_f[sy][sx]+1;
                        else{//求三角形平面方程算出点到屏幕距离
                            p[0]= yb[0]*z[1] -yb[0]*z[2] -yb[1]*z[0] +yb[1]*z[2] +yb[2]*z[0] -yb[2]*z[1];
                            p[1]=-xb[0]*z[1] +xb[0]*z[2] +xb[1]*z[0] -xb[1]*z[2] -xb[2]*z[0] +xb[2]*z[1];
                            p[2]= xb[0]*yb[1] -xb[0]*yb[2] -xb[1]*yb[0] +xb[1]*yb[2] +xb[2]*yb[0] -xb[2]*yb[1];
                            p[3]=-xb[0]*yb[1]*z[2] +xb[0]*yb[2]*z[1] +xb[1]*yb[0]*z[2] -xb[1]*yb[2]*z[0] -xb[2]*yb[0]*z[1] +xb[2]*yb[1]*z[0];
                            currentDis=lightSrcDis*(p[0]*(sx-move)+p[1]*(sy-move)+p[3])/(p[0]*(sx-move)+p[1]*(sy-move)-p[2]*lightSrcDis);
                            if(currentDis>dis[sy][sx]){
                                alpha=0;
                                for(int i=0;i<3;i++) alpha+=normalResultSet[normalIndex*3+i]*light[i];
                                dis[sy][sx]=currentDis;
                                out_f[sy][sx]=alpha>1||alpha<-1?alpha>1?10:0:(alpha*10+10)*0.5;
                            }
                        }
                    }
                }
        ///*输出到终端
        for(int i=0,outIndex;i<size;i++){
            for(int j=0;j<size;j++){
                if(!transparent) outIndex=(int)out_f[i][j];
                else outIndex=(int)(pow((1-1/(transparent*out_f[i][j]+1)),2)*10);
                out_f[i][j]!=-1?printf("%c%c%c",shade[outIndex],shade[outIndex],shade[outIndex]):printf("   ");
            }
            printf("\n");
        }
        Sleep(15);
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
    }
}

Prev Home Next

Render High Dimensional Object In Terminal

Render High Dimensional Object In Terminal

Comments