linux环境下基于opengl的3*3可控魔方绘制

于 2022-09-30 15:37:15 发布
阅读量178 收藏
点赞数
文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62089210/article/details/127080925
版权

一、 前言
本程序设计使用opengl函数库，在linux环境下运行，绘制一个3*3的魔方，可以通过键盘控制任意层的旋转，达到魔方转动的效果。（参考很多年前一毕业论文，个人觉得写的好）
二、 功能设计方案

1.魔方的绘制采用等效替代的思路，一个大魔方是由27块小正方体组成的，那么绘制一个标准正方体后通过空间中的移位来移动到预先设定的位置，而不是整体绘制。

2.首先对立方体建模，一个小正方体由8个点组成，有6个面，那么对正方体的几何操作本质上对6个面操作，也就是对8个点操作。正方体的空间旋转，归根到底还是顶点的旋转.

3.当键盘触发旋转，单层进行了旋转，需要更新小正方体的索引号，首先在小正方体模型池中遍历进行比对，更新出现在的该层索引号，如果不更新，旋转该层将发生扭曲错误，这和程序单层旋转的设计方案有关，本设计是通过索引号来实现任意层次的旋转的，所以旋转后要更新旋转，来知道此时此刻该层都是哪些小正方体，如果是其他设计方案，自然不用。

旋转代码片段和模型对比代码片段：

void Rotate_ZM()
{
	for(int i=0;i<8;i++)
		Rotate(&Cube[ZM[i]],rotAngle,0.0,0.0,1.0);
	if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotZ=0;
	}

int is_equal(stCube *pc1,stCube *pc2)
{
	float x1,x2,y1,y2,z1,z2;
	int isFind=0;

	for(int i=0;i<8;i++)
	{
		x1=pc1->CubePoint[i].p[0];
		y1=pc1->CubePoint[i].p[1];
		z1=pc1->CubePoint[i].p[2];
		isFind=0;
		for(int j=0;j<8;j++)
		{
			x2=pc2->CubePoint[j].p[0];
			y2=pc2->CubePoint[j].p[1];
			z2=pc2->CubePoint[j].p[2];
			if(fabs(x1-x2)<1e-1 && fabs(y1-y2)<1e-1 && fabs(z1-z2)<1e-1)	
			{
				pc1->CubePoint[i].p[0]=pc2->CubePoint[j].p[0];
				pc1->CubePoint[i].p[1]=pc2->CubePoint[j].p[1];
				pc1->CubePoint[i].p[2]=pc2->CubePoint[j].p[2];
				isFind=1;
				break;
			}
		}
		if(isFind==0)  return 0;	
		}
		return 1;
}

下面是demo的实现代码，因为不是最终用的版本，如果有问题也是小问题，稍作修改即可编译运行，懒得检查了。

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

#define PI 3.1415926

#define CYCLE_COUNT 90

int rotate=0;
int rotAngle=0;
int  rotCount=0;
int rotX,rotY,rotZ;


typedef struct
{
	GLfloat vx,vy,vz;	
}CubeVertex;

typedef struct
{
	GLfloat p[3];
}stPoint;

typedef struct
{
	stPoint CubePoint[8];

}stCube;

static stPoint CubePoint[8]=
{
    	{-1.0f,-1.0f,1.0f},

	{1.0f,-1.0f,1.0f},

	{1.0f,1.0f,1.0f},

	{-1.0f,1.0f,1.0f},

	{-1.0f,-1.0f,-1.0f},

	{-1.0f,1.0f,-1.0f},

	{1.0f,1.0f,-1.0f},

	{1.0f,-1.0f,-1.0f}

};

stCube Cube[27];

stCube Static_Cube[27];

int ZP[9]={0,1,2,3,4,5,6,7,8};

int ZZ[9]={9,10,11,12,13,14,15,16,17};

int ZM[9]={18,19,20,21,22,23,24,25,26};


int YM[9]={0,1,2,11,10,9,18,19,20};

int YZ[9]={3,4,5,14,13,12,21,22,23};

int YP[9]={6,7,8,17,16,15,24,25,26};


int XM[9]={2,3,8,17,12,11,20,21,26};

int XZ[9]={1,4,7,16,13,10,19,22,25};

int XP[9]={0,5,6,15,14,9,18,23,24};


const int SZP[9]={0,1,2,3,4,5,6,7,8};

const int SZZ[9]={9,10,11,12,13,14,15,16,17};

const int SZM[9]={18,19,20,21,22,23,24,25,26};



const int SYM[9]={0,1,2,11,10,9,18,19,20};

const int SYZ[9]={3,4,5,14,13,12,21,22,23};

const int SYP[9]={6,7,8,17,16,15,24,25,26};



const int SXM[9]={2,3,8,17,12,11,20,21,26};

const int SXZ[9]={1,4,7,16,13,10,19,22,25};

const int SXP[9]={0,5,6,15,14,9,18,23,24};



void Rotate(stCube *pCube,float angle,float x0,float y0,float z0)
{
	int i;
        double a = PI*2.0*angle/360.0;
	double cosa = cos(a);
	double sina=sin(a);
	if(fabs(x0)>1e-2)
	{
	for(i=0;i<8;i++)
	{
	float y,z;
	y=pCube->CubePoint[i].p[1];
	z=pCube->CubePoint[i].p[2];
	pCube->CubePoint[i].p[1]=y*cosa-z*sina;
	pCube->CubePoint[i].p[2]=y*sina+z*cosa;
	}
	}

	if(fabs(y0)>1e-2)
{
	for(i=0;i<8;i++)
	{	
	float x,z;
	x=pCube->CubePoint[i].p[0];
	z=pCube->CubePoint[i].p[2];
	pCube->CubePoint[i].p[0]=x*cosa-z*sina;
	pCube->CubePoint[i].p[2]=x*sina+z*cosa;
	}
}

	if(fabs(z0)>1e-2)
 { 
	for(i=0;i<8;i++)
	{
	float x,y;
	x=pCube->CubePoint[i].p[0];
        y=pCube->CubePoint[i].p[1];
	pCube->CubePoint[i].p[0]=x*cosa-y*sina;
	pCube->CubePoint[i].p[1]=x*sina+y*cosa;
	}
 }
}


int is_equal(stCube *pc1,stCube *pc2)
{
	float x1,x2,y1,y2,z1,z2;
	int isFind=0;

	for(int i=0;i<8;i++)
	{
		x1=pc1->CubePoint[i].p[0];
		y1=pc1->CubePoint[i].p[1];
		z1=pc1->CubePoint[i].p[2];
		isFind=0;
		for(int j=0;j<8;j++)
		{
			x2=pc2->CubePoint[j].p[0];
			y2=pc2->CubePoint[j].p[1];
			z2=pc2->CubePoint[j].p[2];
			if(fabs(x1-x2)<1e-1 && fabs(y1-y2)<1e-1 && fabs(z1-z2)<1e-1)	
			{
				pc1->CubePoint[i].p[0]=pc2->CubePoint[j].p[0];
				pc1->CubePoint[i].p[1]=pc2->CubePoint[j].p[1];
				pc1->CubePoint[i].p[2]=pc2->CubePoint[j].p[2];
				isFind=1;
				break;
			}
		}
		if(isFind==0)  return 0;	
		}
		return 1;
}



void Update_Cube_index()
{
	int i,j,k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SZM[i]]))
		ZM[k++]=j;
	}

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SZZ[i]]))
		ZZ[k++]=j;
	}	

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SZP[i]]))
		ZP[k++]=j;
	}	

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=16;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SXM[i]]))
		XM[k++]=j;
	}

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SXZ[i]]))
		XZ[k++]=j;
	}		

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SXP[i]]))
		XP[k++]=j;
	}

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SYM[i]]))
		YM[k++]=j;
	}		

	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SYZ[i]]))
		YZ[k++]=j;
	}
	k=0;
	for(i=0;i<9;i++)
	{
		for(j=0;j<27;j++)
		if(is_equal(&Cube[j],&Static_Cube[SYP[i]]))
		YP[k++]=j;
	}			
}


void Rotate_ZM()
{
	for(int i=0;i<8;i++)
		Rotate(&Cube[ZM[i]],rotAngle,0.0,0.0,1.0);
	if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotZ=0;
	}
}


void Rotate_ZZ()
{
	for(int i=0;i<8;i++)
		Rotate(&Cube[ZZ[i]],rotAngle,0.0,0.0,1.0);
		if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotZ=0;
	}
}


void Rotate_ZP()
{
	for(int i=0;i<9;i++)
	Rotate(&Cube[ZP[i]],rotAngle,0.0,0.0,1.0);
	if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotZ=0;
	}
}


void Rotate_XM()
{
	for(int i=0;i<9;i++)
		Rotate(&Cube[XM[i]],rotAngle,1.0,0.0,0.0);
		if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotX=0;
	}
}


void Rotate_XZ()
{
	for(int i=0;i<9;i++)
		Rotate(&Cube[XZ[i]],rotAngle,1.0,0.0,0.0);

		if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotX=0;
	}

}

void Rotate_XP()
{
	rotAngle=45;
	for(int i=0;i<9;i++)

		Rotate(&Cube[XP[i]],rotAngle,1.0,0.0,0.0);
}

void Rotate_YM()
{
	for(int i=0;i<9;i++)
	Rotate(&Cube[YM[i]],rotAngle,0.0,1.0,0.0);
		if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotY=0;

	}	
}


void Rotate_YZ()
{
	for(int i=0;i<9;i++)
	Rotate(&Cube[YZ[i]],rotAngle,0.0,1.0,0.0);

		if(rotCount++==CYCLE_COUNT)

	{
		Update_Cube_index();
		rotAngle=0;
		rotY=0;

	}	
}


void Rotate_YP()
{
	for(int i=0;i<9;i++)
	Rotate(&Cube[YP[i]],rotAngle,0.0,1.0,0.0);
		if(rotCount++==CYCLE_COUNT)
	{
		Update_Cube_index();
		rotAngle=0;
		rotY=0;
	}	
}

void Rotate_Z(int ii)
{
	switch(ii)
	{
		case 0: Rotate_ZP(); break;
		case 1: Rotate_ZZ(); break;
		case 2: Rotate_ZM(); break;

	}

}


void Rotate_Y(int ii)

{
	switch(ii)
	{
                case 0: Rotate_YP(); break;
		case 1: Rotate_YZ(); break;
		case 2: Rotate_YM(); break;
	}

}

void Rotate_X(int ii)
{
		switch(ii)
	{
		case 0: Rotate_XP(); break;
		case 1: Rotate_XZ(); break;
		case 2: Rotate_XM(); break;
	}
}

void glKeyboard(unsigned char key, int x, int y)
{
	switch (key)
	{
		case 'a':
			Rotate_X(0);
                        glutPostRedisplay();
                 	break;
		case 'd':
                        rotate+=3;
			glutPostRedisplay();
			break;
		case 'w':
		        Rotate_Y(0) ;
			glutPostRedisplay();
			break;
		case 's':
			 rotate+=3;
			glutPostRedisplay();
			break;
	}
}
void rest_model()
{

	int i;

	for(i=0;i<8;i++)

	{

		Cube[0].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[0].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[0].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}

        for(i=0;i<8;i++)

	{

		Cube[1].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[1].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[1].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}

	for(i=0;i<8;i++)

	{

		Cube[2].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[2].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[2].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}


		for(i=0;i<8;i++)

	{

		Cube[3].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[3].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[3].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[4].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[4].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[4].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}
		for(i=0;i<8;i++)

	{

		Cube[5].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[5].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[5].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[6].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[6].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[6].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}
	for(i=0;i<8;i++)

	{

		Cube[7].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[7].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[7].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[8].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[8].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[8].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[9].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[9].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[9].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}	for(i=0;i<8;i++)
	{

		Cube[10].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[10].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[10].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[11].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[11].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[11].CubePoint[i].p[2]=CubePoint[i].p[2]+2.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[12].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[12].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[12].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}	for(i=0;i<8;i++)
	{

		Cube[13].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[13].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[13].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[14].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[14].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[14].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}

		for(i=0;i<8;i++)
	{

		Cube[15].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[15].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[15].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[16].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[16].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[16].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[17].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[17].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[17].CubePoint[i].p[2]=CubePoint[i].p[2]+0.0f;

	}
	for(i=0;i<8;i++)

	{

		Cube[18].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[18].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[18].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[19].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[19].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[19].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[20].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[20].CubePoint[i].p[1]=CubePoint[i].p[1]-2.0f;

		Cube[20].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}
		for(i=0;i<8;i++)

	{

		Cube[21].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[21].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[21].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}	for(i=0;i<8;i++)

	{

		Cube[22].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[22].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[22].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}

		for(i=0;i<8;i++)

	{

		Cube[23].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[23].CubePoint[i].p[1]=CubePoint[i].p[1]+0.0f;

		Cube[23].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}
	 for(i=0;i<8;i++)

	{

		Cube[24].CubePoint[i].p[0]=CubePoint[i].p[0]-2.0f;

		Cube[24].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[24].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}

	for(i=0;i<8;i++)

	{

		Cube[25].CubePoint[i].p[0]=CubePoint[i].p[0]+0.0f;

		Cube[25].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[25].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}

	for(i=0;i<8;i++)

	{

		Cube[26].CubePoint[i].p[0]=CubePoint[i].p[0]+2.0f;

		Cube[26].CubePoint[i].p[1]=CubePoint[i].p[1]+2.0f;

		Cube[26].CubePoint[i].p[2]=CubePoint[i].p[2]-2.0f;

	}

	for(i=0;i<27;i++)

		Static_Cube[i]=Cube[i];

}


void DrawCube(int ID)

{
  stPoint *CubePoint=Cube[ID].CubePoint;

  glColor3f(1, 0, 0);
  glBegin(GL_QUADS);
  //glNormal3f(0.0f,1.0f,0.0f);
  glVertex3f(CubePoint[0].p[0],CubePoint[0].p[1],CubePoint[0].p[2]);

  glVertex3f(CubePoint[1].p[0],CubePoint[1].p[1],CubePoint[1].p[2]);

  glVertex3f(CubePoint[2].p[0],CubePoint[2].p[1],CubePoint[2].p[2]);

  glVertex3f(CubePoint[3].p[0],CubePoint[3].p[1],CubePoint[3].p[2]);
  glEnd();

  glColor3f(1, 1, 0);
  glBegin(GL_QUADS);
  // glNormal3f(0.0f,-1.0f,0.0f);
  glVertex3f(CubePoint[4].p[0],CubePoint[4].p[1],CubePoint[4].p[2]);

  glVertex3f(CubePoint[5].p[0],CubePoint[5].p[1],CubePoint[5].p[2]);

  glVertex3f(CubePoint[6].p[0],CubePoint[6].p[1],CubePoint[6].p[2]);

  glVertex3f(CubePoint[7].p[0],CubePoint[7].p[1],CubePoint[7].p[2]);
  glEnd();

  glColor3f(1, 0, 1);
  glBegin(GL_QUADS);
  // glNormal3f(0.0f,0.0f,1.0f);
  glVertex3f(CubePoint[5].p[0],CubePoint[5].p[1],CubePoint[5].p[2]);

  glVertex3f(CubePoint[3].p[0],CubePoint[3].p[1],CubePoint[3].p[2]);

  glVertex3f(CubePoint[2].p[0],CubePoint[2].p[1],CubePoint[2].p[2]);

  glVertex3f(CubePoint[6].p[0],CubePoint[6].p[1],CubePoint[6].p[2]);
  glEnd();

  glColor3f(1, 1, 1);
  glBegin(GL_QUADS);
  //glNormal3f(0.0f,0.0f,-1.0f);
  glVertex3f(CubePoint[4].p[0],CubePoint[4].p[1],CubePoint[4].p[2]);

  glVertex3f(CubePoint[7].p[0],CubePoint[7].p[1],CubePoint[7].p[2]);

  glVertex3f(CubePoint[1].p[0],CubePoint[1].p[1],CubePoint[1].p[2]);

  glVertex3f(CubePoint[0].p[0],CubePoint[0].p[1],CubePoint[0].p[2]);

  glEnd();
  glColor3f(0.5, 0.5, 0);
  glBegin(GL_QUADS);
  //glNormal3f(-1.0f,0.0f,0.0f);
   glVertex3f(CubePoint[7].p[0],CubePoint[7].p[1],CubePoint[7].p[2]);

  glVertex3f(CubePoint[6].p[0],CubePoint[6].p[1],CubePoint[6].p[2]);

  glVertex3f(CubePoint[2].p[0],CubePoint[2].p[1],CubePoint[2].p[2]);

  glVertex3f(CubePoint[1].p[0],CubePoint[1].p[1],CubePoint[1].p[2]);
  glEnd();

 glColor3f(1, 0, 0.5);
  glBegin(GL_QUADS);

  //glNormal3f(1.0f,0.0f,0.0f);

  glVertex3f(CubePoint[4].p[0],CubePoint[4].p[1],CubePoint[4].p[2]);

  glVertex3f(CubePoint[0].p[0],CubePoint[0].p[1],CubePoint[0].p[2]);

  glVertex3f(CubePoint[3].p[0],CubePoint[3].p[1],CubePoint[3].p[2]);

  glVertex3f(CubePoint[5].p[0],CubePoint[5].p[1],CubePoint[5].p[2]);

  glEnd();

}


void renderScene(void) 

{
 //
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT );  
	
    glEnable(GL_DEPTH_TEST);
	
    glMatrixMode(GL_MODELVIEW); 

    glLoadIdentity();

    glPushMatrix();
 
    glTranslatef(-0.1,0.0,-0.0);

    glScalef(0.1, 0.1, 0.1);

    gluLookAt (0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 1.0, 1.0,0.0);	
	
    glRotatef(rotate, 0, 0, 1);

    glRotatef(rotate, 1, 0, 0);


	for(int j=0;j<27;j++)
    DrawCube(j);

    glPopMatrix();

    glutSwapBuffers();

}



void main(int argc, char **argv) 

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	

    glShadeModel(GL_SMOOTH);                        

    glClearColor(1.0f, 0.0f, 0.0f, 0.0f);                  

    glClearDepth(1.0f);                          

    glEnable(GL_DEPTH_TEST);                          

    glDepthFunc(GL_LEQUAL);                         

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  

    glutInitWindowPosition(100,100);

    glutInitWindowSize(1000, 1000);

    rest_model();
     
    gluLookAt (2.0, 2.0, 0.0, 2.0, 1.0, 5.0, 2.0, 1.0, 5.0);

    glutCreateWindow("Cube_Demo");

    glutDisplayFunc(renderScene);

    glutKeyboardFunc(glKeyboard);
 
    glutIdleFunc(renderScene);

    glutMainLoop();
}
春哥111
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
基于OPENGL的3D魔方
01-10
计算机图形学大作业 内含： 1.项目源码 2.可执行文件 3.开题报告 4.结题报告
OpenGL实现3D魔方游戏源代码
热门推荐
Hackbuteer1的专栏
08-11 2万+
首先这个程序是建立的是Windows应用程序，建立控制台程序是不能运行的，另外，项目——项目属性——配置属性——常规-----使用多字节字符集，这样编译才能够通过的，否则如果选择使用 Unicode 字符集，编译会有错误提示：error C2440: “初始化”: 无法从“con
配置OpenGL（Linux）
码上看世界
10-31 1万+
这里介绍了在Linux系统使用OpenGL可能会用到的库的安装方法，这些库包括：`freeglut`, `glew`, `GLTools`, `glfw`;
linux opengl图形编程,OpenGL基本程序结构
weixin_35057850的博客
05-12 312
用OpenGL编写的程序结构类似于用其他语言编写的程序。实际上，OpenGL是一个丰富的三维图形函数库，编写OpenGL程序并非难事，只需在基本C语言中调用这些函数，用法同Turbo C、Microsoft C等类似，但也有许多不同之处。本指南所有的程序都是在Windows NT的Microsoft Visual C++集成环境下编译连接的，其中有部分头文件和函数是为这个环境所用的，例如判别操作系...
qt/c++ 实现opengl绘制3d曲线以及Q3DSurface绘制类似3d曲线
05-04
网上找了很久也没有关于3d曲线的绘制，都是有关3d曲面的。...该资源用opengl完成了3d曲线的绘制，但是没有坐标信息，所以又使用Q3DSurface完成类似曲线的效果，可以带坐标轴并且在曲线上点击获得坐标xyz
Android开发 OpenGL ES绘制3D 图形实例详解
09-01
主要介绍了Android开发 OpenGL ES绘制3D 图形实例详解的相关资料,需要的朋友可以参考下
3d-mofang.rar_3D魔方 OpenGL_3d cube_魔方
07-15
三维立体可转动魔方 用到了OPENGL 可以在Vc++6.0下运行
基于openGL的3D贪吃蛇.zip
最新发布
01-06
基于openGL的3D贪吃蛇.zip
OpenGL实现的3D魔方
11-16
用《OpenGL超级宝典》第五版中提供的API和库文件实现的3D魔方，用的具有shader的可编程渲染管线，可以通过拖动鼠标来旋转整个魔方，但不能通过拖动鼠标只能通过修改代码来拖到魔方的每一片。
基于OpenGL的魔方
05-05
利于OpenGL绘制魔方，可以进行各面的旋转
【OpenGL ES】绘制魔方.zip
11-07
使用 OpenGL 绘制旋转的魔方
基于opengl的3D旋转魔方实现
06-03
我们的软件课程设计作业 老师的程序是2阶魔方 我们要做的是3阶的
用opengl做的三维魔方完整源码
07-18
用opengl做的三维魔方完整源码，十分值得学习！
学习opengl之制作魔方
wphkadn的博客
03-22 2912
效果 实现了一个魔方能够按照某一边旋转，但本内容没有过多考虑纹理，所以魔方内部也有颜色。 工具 glad、glfw(这个无所谓)、glm（这个也主要是为了和glad配合，使用eigen也行） 思路 状态机 STOP 停止不动时如何刷新界面 RUNX(Y/Z) 沿着X/Y/Z轴旋转时如何作图 UPDATE 当旋转到位置时，更新模型矩阵，包括旋转以及位置 UPDATE状态中更新旋转矩阵 每一...
openGL之glsl入门6--画三维图魔方、圆柱体
他山随悟的专栏
11-21 1万+
这一章介绍坐标变换与矩阵相关内容，对应红宝书第5章内容，并通过两个简单的例子展示矩阵变换的效果。 1. 坐标变换     变换的类型有多种，包括视图、模型、投影、视口变换等，概念可以参照红宝书5.1章节，概念虽不同，但最终作用到顶点坐标的方式是一致的，都是对顶点坐标进行运算（直接加减乘除或者使用矩阵运算），弄清楚这些概念，有利于清晰描述变换的效果，虽然不同的变化都可以得到相同的结果(显示器上输
自己动手做一个虚拟魔方——建模、还原、可视化
qq_45362415的博客
04-02 2569
今天为了教妹妹玩儿魔方，又拿起了初中学会的几个公式。其实我拼魔方很菜的，只是知道几个公式(准确的说是三个…)突发奇想，能不能用python建立一个存在于电脑中的数字化普通三阶魔方。这篇文章记录了我从初步构思到最终实现的过程(如果真能实现…) 由于代码量比较大，所以特意写下这篇博文作为我创建虚拟魔方过程的目录。 虚拟魔方创建过程 建模——对虚拟魔方完成最基本的建模工作，实现各种操作 可视化...
OpenGL-Shader
07-09
共六章1.基础章节,从Shader1.0版本到新的4.5版本,介绍每一个版本中特性的用法;2.Tesslattion Shader应用/基础案例分析3.Gemotry Shader应用/基础案例分析4.Compute Shader应用/基础案例分析5.通过大量案例讲解分析/结合新特性，介绍用法6.性能调优，如果借助shader加速应用,让你的程序支撑百万级别的场景对象轻松应对
基于OpenGL实现的3d魔方的函数
05-29
基于OpenGL实现的3D魔方主要需要以下函数： 1. `glBegin(GL_QUADS)` 和 `glEnd()`：用于绘制立方体的6个面。使用`glBegin(GL_QUADS)`开始绘制四边形，然后使用`glVertex3f()`指定四个点的坐标，最后使用`glEnd()`结束绘制。 2. `glColor3f()`：用于指定颜色。可以使用该函数指定每个面的颜色，或者使用纹理贴图来指定颜色。 3. `glTranslatef()`：用于平移物体。该函数可以将物体沿x、y、z轴平移一定距离，实现物体的移动。 4. `glRotatef()`：用于旋转物体。该函数可以将物体绕x、y、z轴旋转一定角度，实现物体的旋转。 5. `glMatrixMode()` 和 `glLoadIdentity()`：用于设置矩阵模式和重置变换矩阵。可以使用这两个函数来设置投影矩阵和视图矩阵。 6. `gluPerspective()`：用于设置透视投影矩阵。该函数可以设置视角、宽高比、近截面和远截面等参数，实现透视投影效果。 7. `gluLookAt()`：用于设置视图矩阵。该函数可以设置视点、观察点和上方向等参数，实现观察物体的效果。 8. `glGenTextures()`、`glBindTexture()` 和 `glTexImage2D()`：用于加载和使用纹理贴图。可以使用这些函数实现魔方每个面的贴图。 以上是基于OpenGL实现的3D魔方中常用的一些函数，具体实现时还需要考虑其他一些细节问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

春哥111

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值