ボロリン

#include <stdlib.h>
#include <GL/glut.h>
#include <stdio.h>
#include <math.h>

#define for if(0);else for

const double PI=3.14159265358979;
const double D2R=PI/180;

//マウスドラッグ用
int tmp_mouse_x=-1000,tmp_mouse_y=0;

/////////////////////////////
// 回転変換

// x軸まわりの回転
void rotatex(float &x,float &y,float &z,float t)
{
	float s=sin(t),c=cos(t);
	float ay=y*c-z*s;
	float az=y*s+z*c;
	y=ay;z=az;
}
// y軸まわりの回転
void rotatey(float &x,float &y,float &z,float t)
{
	float s=sin(t),c=cos(t);
	float az=z*c-x*s;
	float ax=z*s+x*c;
	z=az;x=ax;
}
// z軸まわりの回転
void rotatez(float &x,float &y,float &z,float t)
{
	float s=sin(t),c=cos(t);
	float ax=x*c-y*s;
	float ay=x*s+y*c;
	x=ax;y=ay;
}

/////////////////////////////
// ベクトル演算

// 外積
void exprod(float p1[],float p2[],float r[])
{
	r[0]=p1[1]*p2[2]-p2[1]*p1[2];
	r[1]=p1[2]*p2[0]-p2[2]*p1[0];
	r[2]=p1[0]*p2[1]-p2[0]*p1[1];
}
// 内積
float dotprod(float p1[],float p2[])
{
	return p1[0]*p2[0]+p1[1]*p2[1]+p1[2]*p2[2];
}
// 正規化
void normalize(float p[])
{
	float d=sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]);
	p[0]/=d;p[1]/=d;p[2]/=d;
}

//////////////////////////
// カメラクラス
//
class Camera
{
private:
	double theta;   //方位角(どっちから見るか)
	double alpha; //偏角(上から見るか横から見るか)
	double dist;   //カメラと原点との距離
	double px,py,pz;  //カメラ位置
public:
	Camera()
	{
		theta=0;
		alpha=1.9;
		dist=15;
	}

	//カメラを回転させる
	void Move(int dx,int dy)
	{
		theta-=dx*0.005;
		alpha+=dy*0.005;
		Reflesh();
	}

	double GetAlpha(){return alpha;}
	double GetTheta(){return theta;}
	void GetPosition(double &x,double &y,double &z)
	{
		x=px;y=py;z=pz;
	}

	//カメラの設定をglに適用する
	void Reflesh()
	{
		if(alpha>3.14)alpha=3.14;
		if(alpha<1.58)alpha=1.58;
		glMatrixMode(GL_MODELVIEW);
		glLoadIdentity();
		px=dist*sin(theta)*sin(alpha);
		py=dist*cos(theta)*sin(alpha);
		pz=dist*cos(alpha);
		gluLookAt(
			px,  py,  pz,     // 視点
			0.0, 0.0, 0.0,    // 注視位置
			0.0, 0.0, -1.0    // 頭の上の方向
		);
	}
};

Camera camera;

/////////////////////////////
// マウス入力
//
void mouse(int button, int state, int x, int y)
{
	if(button==GLUT_LEFT_BUTTON && state==GLUT_DOWN)
	{

	}
	if(button==GLUT_RIGHT_BUTTON)
	{
		if(state==GLUT_DOWN)//右ボタンを押した
		{
			tmp_mouse_x=x;tmp_mouse_y=y;
		}
		else//右ボタンを離した
		{
			camera.Move(x-tmp_mouse_x,y-tmp_mouse_y);
			tmp_mouse_x=-1000;
		}
	}
}
void mousemove(int x,int y)
{
	if(tmp_mouse_x!=-1000)
	{
		camera.Move(x-tmp_mouse_x,y-tmp_mouse_y);
		tmp_mouse_x=x;tmp_mouse_y=y;
	}
}

/////////////////////////////////
// アニメーション
//
void animate()
{
	//再描画
	glutPostRedisplay();
}

/////////////////////////
// 描画
//

// ボックスを描画する
void renderBox()
{
	glBegin(GL_QUAD_STRIP);
	glVertex3f(1,1,-1);
	glVertex3f(-1,1,-1);
	glVertex3f(1,1,1);
	glVertex3f(-1,1,1);
	glVertex3f(1,-1,1);
	glVertex3f(-1,-1,1);
	glVertex3f(1,-1,-1);
	glVertex3f(-1,-1,-1);
	glVertex3f(1,1,-1);
	glVertex3f(-1,1,-1);
	glEnd();
	glBegin(GL_QUADS);
	glVertex3f(1,1,-1);
	glVertex3f(1,1,1);
	glVertex3f(1,-1,1);
	glVertex3f(1,-1,-1);
	glVertex3f(-1,1,-1);
	glVertex3f(-1,-1,-1);
	glVertex3f(-1,-1,1);
	glVertex3f(-1,1,1);
	glEnd();
}

//グローボックス
void renderGlowBox(double tt)
{
	glEnable(GL_BLEND);
	glPushMatrix();
	glDepthMask(0);

	glBlendFunc(GL_SRC_ALPHA,GL_ONE);//加算ブレンド
	
	glRotatef(tt,1,0,0);
	glRotatef(tt*0.71,0,1,0);
	
	double aa=sin(tt*0.04);
	aa*=aa*0.03;
	aa+=1.02;

	for(int i=0;i<10;i++)
	{
	glColor4f(0.6,0.4,0.1,0.3-i*0.03);
	renderBox();
	glScalef(aa,aa,aa);
	}
	glPopMatrix();
}

double irid2(double t)
{
	if(t*6<1)return t*6;
	if(t*6<3)return 1;
	if(t*6<4)return 4-t*6;
	return 0;
}

void irid(double &r,double &g,double &b,double t)
{
	g=irid2(fmod(t,1));
	b=irid2(fmod(t+1/3.0,1));
	r=irid2(fmod(t+2/3.0,1));
}

//グローボックスの発光体
void renderGlow(double tt)
{
	glEnable(GL_BLEND);
	glPushMatrix();
	glDepthMask(0);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE);//加算ブレンド
	glDisable(GL_DEPTH_TEST);
	glPushMatrix();
	
	glLoadIdentity();
	gluLookAt(
			0,  0,  -15,     // 視点
			0.0, 0.0, 0.0,    // 注視位置
			0.0, 1.0, 0.0    // 頭の上の方向
	);
	
	double cx,cy,cz;
	camera.GetPosition(cx,cy,cz);
	float c[]={cx,cy,cz};
	normalize(c);

	double dc=1,cc=fabs(c[0]);
	double rr=0,gg=0,bb=0;
	glBegin(GL_TRIANGLE_FAN);
	if(cc>0.85)
	{
		dc=(1-cc)/(1-0.85);
	}
	if(c[0]>0.90)
	{
		double a=(cc-0.90)/(1-0.90);
		irid(rr,gg,bb,a*3.6);
		rr+=a*0.5;gg+=a*0.5;bb+=a*0.5;
		rr*=a;gg*=a;bb*=a;
	}
	
	if(dc>1)dc=1;

	glColor4f(0.1*dc+rr,0.6*dc+gg,1*dc+bb,1);
	glVertex3f(0,0,0);
	glColor4f(0.1*dc+rr,0.6*dc+gg,1*dc+bb,0);

	double rd=2+sin(tt*0.037)*0.3;
	for(int i=0;i<=6;i++)
	{
	double a=2*PI*i/6.0;
	glVertex3f(cos(a)*rd,-sin(a)*rd,0);
	}
	glEnd();
	
	glPopMatrix();
}

//普通ボックス
void renderNormalBox(double tt)
{
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_BLEND);
	glDepthMask(1);
	glPushMatrix();
	glTranslatef(-4,0,0);
	glRotatef(tt,1,0,0);
	glRotatef(tt*0.71,0,1,0);
	static const float v[]={
		1,1,1,
		-1,1,1,
		1,-1,1,
		-1,-1,1,
		1,1,-1,
		-1,1,-1,
		1,-1,-1,
		-1,-1,-1,
	};
	static const int idx[]={
		4,5,1,0,
		0,1,3,2,
		2,3,7,6,
		6,7,5,4,
		0,2,6,4,
		5,7,3,1,
	};
	
	glBegin(GL_QUADS);
	for(int i=0;i<6;i++)
	{
		//面の法線nを求める
		float n[3];
		float a[3],b[3];
		int k=i*4;
		a[0]=v[idx[k+2]*3]-v[idx[k+1]*3];
		a[1]=v[idx[k+2]*3+1]-v[idx[k+1]*3+1];
		a[2]=v[idx[k+2]*3+2]-v[idx[k+1]*3+2];
		b[0]=v[idx[k]*3]-v[idx[k+1]*3];
		b[1]=v[idx[k]*3+1]-v[idx[k+1]*3+1];
		b[2]=v[idx[k]*3+2]-v[idx[k+1]*3+2];
		exprod(a,b,n);
		normalize(n);
		rotatey(n[0],n[1],n[2],tt*0.71*PI/180);
		rotatex(n[0],n[1],n[2],tt*PI/180);
		
		//法線から色を作る
		float c=n[0];
		c+=0.2;
		if(c<0)c=0;
		glColor3f(c*0.8+0.1,c*0.8+0.2,c*0.8+0.3);

		for(int j=0;j<4;j++)
		{
			glVertex3f(v[idx[k+j]*3],
				v[idx[k+j]*3+1],
				v[idx[k+j]*3+2]);
		}
	}
	glEnd();
	glPopMatrix();
}

//透明ボックス
void renderTransparentBox(double tt)
{
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_BLEND);
	glDepthMask(0);
	//標準ブレンド(加重平均)
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

	static const float v[]={
		1,1,1,
		-1,1,1,
		1,-1,1,
		-1,-1,1,
		1,1,-1,
		-1,1,-1,
		1,-1,-1,
		-1,-1,-1,
	};
	static const int idx[]={
		4,5,1,0,
		0,1,3,2,
		2,3,7,6,
		6,7,5,4,
		0,2,6,4,
		5,7,3,1,
	};
	
	glPushMatrix();
	glTranslatef(4,0,0);
	glRotatef(tt,1,0,0);
	glRotatef(tt*0.71,0,1,0);
	glBegin(GL_QUADS);
	for(int i=0;i<6;i++)
	{
		//面の法線nを求める
		float n[3];
		float a[3],b[3];
		int k=i*4;
		a[0]=v[idx[k+2]*3]-v[idx[k+1]*3];
		a[1]=v[idx[k+2]*3+1]-v[idx[k+1]*3+1];
		a[2]=v[idx[k+2]*3+2]-v[idx[k+1]*3+2];
		b[0]=v[idx[k]*3]-v[idx[k+1]*3];
		b[1]=v[idx[k]*3+1]-v[idx[k+1]*3+1];
		b[2]=v[idx[k]*3+2]-v[idx[k+1]*3+2];
		exprod(a,b,n);
		normalize(n);
		rotatey(n[0],n[1],n[2],tt*0.71*PI/180);
		rotatex(n[0],n[1],n[2],tt*PI/180);
		
		//法線から色を作る
		float c=-n[0];
		c+=0.2;
		if(c<0)c=0;
		glColor4f(c*0.8+0.1,c*0.8+0.2,c*0.8+0.3,0.5);

		for(int j=0;j<4;j++)
		{
			glVertex3f(v[idx[k+j]*3],
				v[idx[k+j]*3+1],
				v[idx[k+j]*3+2]);
		}
	}
	glEnd();
	glPopMatrix();
}

void disp()
{
	// 画面を消去
	glDepthMask(1);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	camera.Reflesh();
	static int t=0;
	t++;
	double tt=t*0.4;

	double cx,cy,cz;
	camera.GetPosition(cx,cy,cz);

	//不透明なボックスを描画
	renderNormalBox(tt);
	
	//αブレンドは遠いもの順に描画
	//この場合はカメラの位置によってどっちが遠いかすぐに分かる。
	if(cx<0)
	{
		//透明なボックスを描画
		glCullFace(GL_FRONT);//まずは裏側
		renderTransparentBox(tt);
		glCullFace(GL_BACK);//次に表を描画
		renderTransparentBox(tt);
		//グローボックスを描画
		renderGlowBox(tt);
		renderGlow(tt);
	}
	else
	{
		renderGlowBox(tt);
		glCullFace(GL_FRONT);
		renderTransparentBox(tt);
		glCullFace(GL_BACK);
		renderTransparentBox(tt);
		renderGlow(tt);
	}
	
	glutSwapBuffers();
}

/////////////////////////
// メイン
//
int main(int argc,char **argv)
{
	// 初期化
	glutInit(&argc,argv);
	glutInitWindowPosition(100, 50);
	glutInitWindowSize(640, 480);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);

	glutCreateWindow("3DCG Programming");
	glutDisplayFunc(disp);
	glutIdleFunc(animate);
	glutMouseFunc(mouse);
	glutMotionFunc(mousemove);

	// 背景色
	glClearColor(0.185f,0.199f,0.200f,0.0f);
	// 奥行きテスト
	glEnable(GL_DEPTH_TEST);
	//αブレンド
	glEnable(GL_BLEND);
	// 裏面を表示しない
	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);

	// カメラの設定

	// 投影法の設定
	glMatrixMode(GL_PROJECTION);
	gluPerspective(
		45,             // 視野角
		640.0/480.0,    // アスペクト比
		4,            // 視角錘台の近いほうの距離
		21             // 遠いほうの距離
	);

	// 座標の設定
	camera.Reflesh();

	// メインループ
	glutMainLoop();
	return 0;
}