C++ YsVec3::Set方法代码示例

void FsLazyWindowApplication::CacheBoundingBox(void)
{
	auto nVtx=vtx.size()/3;
	// Cache bounding box
	if(0<nVtx)
	{
		float minx,miny,minz,maxx,maxy,maxz;
		minx=vtx[0];
		miny=vtx[1];
		minz=vtx[2];
		maxx=vtx[0];
		maxy=vtx[1];
		maxz=vtx[2];
		for(decltype(nVtx) i=0; i<nVtx; ++i)
		{
			YsMakeSmaller(minx,vtx[i*3]);
			YsMakeSmaller(miny,vtx[i*3+1]);
			YsMakeSmaller(minz,vtx[i*3+2]);
			YsMakeGreater(maxx,vtx[i*3]);
			YsMakeGreater(maxy,vtx[i*3+1]);
			YsMakeGreater(maxz,vtx[i*3+2]);
		}
		min.Set(minx,miny,minz);
		max.Set(maxx,maxy,maxz);
	}
	else
	{
		min=YsVec3::Origin();
		max=YsVec3::Origin();
	}
}

void YsClassSample::Motion(int x,int y)
{
	double dx,dy;
	YsVec3 vec;

	dx=double(x-lastX);
	dy=double(lastY-y);
	switch(mouseMode)
	{
	case 0:
		eyeAtt.NoseUp(dy/300.0);
		eyeAtt.YawLeft(-dx/300.0);
		break;
	case 1:
		vec.Set(-dx/30.0,-dy/30.0,0.0);
		vec=eyeAtt.GetMatrix()*vec;
		eyeLookAt=eyeLookAt+vec;
		break;
	case 2:
		RotatePolygon(dy/300.0,-dx/300.0);
		break;
	case 3:
		vec.Set(dx/30.0,dy/30.0,0.0);
		vec=eyeAtt.GetMatrix()*vec;
		pointOfInterest=pointOfInterest+vec;
		break;
	}
	lastX=x;
	lastY=y;
}

void Motion(int x,int y)
{
	if(button==GLUT_DOWN)
	{
		double dx,dy;
		YsVec3 vec;

		dx=double(x-lastX);
		dy=double(lastY-y);
		switch(mouseMode)
		{
		case 0:
			eyeAtt.NoseUp(dy/300.0);
			eyeAtt.YawLeft(-dx/300.0);
			break;
		case 1:
			vec.Set(-dx/30.0,-dy/30.0,0.0);
			vec=eyeAtt.GetMatrix()*vec;
			eyeLookAt=eyeLookAt+vec;
			break;
		}
		glutPostRedisplay();
	}
	lastX=x;
	lastY=y;
}

void Display(void)
{
	double matBuf[4*4];
	YsVec3 eyePos;
	YsMatrix4x4 eyeTfm;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	eyePos.Set(0.0,0.0,eyeDistance);
	eyePos=eyeAtt.GetMatrix()*eyePos;

	eyeTfm.Initialize();
	eyeTfm.Translate(eyePos);
	eyeTfm.Rotate(eyeAtt);
	eyeTfm.Invert();
	eyeTfm.Translate(-eyeLookAt);

	eyeTfm.GetArray(matBuf);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glMultMatrixd(matBuf);
	DrawShell(sh1,blu,drawInPolygon);
	DrawShell(sh2,grn,drawInPolygon);
	DrawAxis(5.0);
	glFlush();
	glutSwapBuffers();
}

void YsClassSample::Display(void)
{
	BIPOSATT biEyePos;
	BIPOINT cursor;

	eyePos.Set(0.0,0.0,-eyeDistance);
	eyePos=eyeAtt.GetMatrix()*eyePos;
	eyePos=eyeLookAt+eyePos;

	BiSetPoint(&biEyePos.p,eyePos.x(),eyePos.y(),eyePos.z());
	BiSetAngleDeg(&biEyePos.a,
	              YsRadToDeg(eyeAtt.h()),
	              YsRadToDeg(eyeAtt.p()),
	              YsRadToDeg(eyeAtt.b()));

	BiClearScreen();
	BiStartBuffer(&biEyePos);

	BiSetPoint(&cursor,
	           pointOfInterest.x(),
	           pointOfInterest.y(),
	           pointOfInterest.z());
	BiInsMarker(&cursor,&BiWhite,BIMK_CROSS);
	DrawSlashedPolygon();
	DrawPolygon(4,q,blu,YSFALSE);
	DrawPolygon(4,r,blu,YSFALSE);
	DrawAxis(5.0);

	BiFlushBuffer();
	BiSwapBuffers();
}

void Display(void)
{
	double matBuf[4*4];
	YsVec3 eyePos;
	YsMatrix4x4 eyeTfm;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	eyePos.Set(0.0,0.0,eyeDistance);
	eyePos=eyeAtt.GetMatrix()*eyePos;

	eyeTfm.Initialize();
	eyeTfm.Translate(eyePos);
	eyeTfm.Rotate(eyeAtt);
	eyeTfm.Invert();
	eyeTfm.Translate(-eyeLookAt);

	eyeTfm.GetArray(matBuf);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glMultMatrixd(matBuf);
	DrawSeparatablePair(nVtx,vtx);

	glFlush();
	glutSwapBuffers();
}

YSRESULT YsZClip(YsVec3 &clipPos,const YsVec3 &p1,const YsVec3 &p2,const double &clipz)
{
	const double denom=(p2.z()-p1.z());
	if(YsTolerance<=fabs(denom))
	{
		const YsVec3 v=p2-p1;
		const double t=(clipz-p1.z())/denom;
		clipPos.Set(p1[0]+t*v[0],p1[1]+t*v[1],clipz);
		return YSOK;
	}
	return YSERR;
}

void YsClassSample::MainLoop(void)
{
	int lb,mb,rb;
	long mx,my;

	eyeDistance=10.0;
	eyeLookAt.Set(0.0,0.0,0.0);
	eyeAtt.Set(0.0,0.0,0.0);

	pointOfInterest.Set(0.0,0.0,-1.0);
	PrepareSquare(p);
	PrepareSquare(q);
	RotatePolygon(q,YsDegToRad(90.0),0.0);
	PrepareSquare(r);
	RotatePolygon(r,0.0,YsDegToRad(90.0));

	BiMouse(&lb,&mb,&rb,&mx,&my);

	mouseMode=0;
	while((key=BiInkey())!=BIKEY_ESC)
	{
		BIPROJ prj;

		BiUpdateDevice();
		BiGetStdProjection(&prj);
		BiSetProjection(&prj);

		Key(key);
		Display();

		lastX=mx;
		lastY=my;
		BiMouse(&lb,&mb,&rb,&mx,&my);
		if(lb==BI_ON && (mx!=lastX || my!=lastY))
		{
			Motion(mx,my);
		}
	}

}

void YsTransform3DCoordToScreenCoord(YsVec3 &scrn,const YsVec3 &from,const int viewport[4],const YsMatrix4x4 &projViewModelTfm)
{
	double pos4d[4]={from.x(),from.y(),from.z(),1.0};
	projViewModelTfm.Mul(pos4d,pos4d);

	pos4d[0]/=pos4d[3];
	pos4d[1]/=pos4d[3];
	pos4d[2]/=pos4d[3];

	pos4d[0]=(double)viewport[0]+(double)viewport[2]*(pos4d[0]+1.0)/2.0;
	pos4d[1]=(double)viewport[1]+(double)viewport[3]*(pos4d[1]+1.0)/2.0;

	scrn.Set(pos4d[0],pos4d[1],pos4d[2]);
}

void YsTransformScreenCoordTo3DCoord(YsVec3 &threeD,const YsVec3 &scrn,const int viewport[4],const YsMatrix4x4 &projViewModelTfm)
{
	double pos4d[4]=
	{
		(scrn.x()-(double)viewport[0])*2.0/(double)viewport[2]-1.0,
		(scrn.y()-(double)viewport[1])*2.0/(double)viewport[3]-1.0,
		scrn.z(),
		1.0
	};

	projViewModelTfm.MulInverse(pos4d,pos4d);

	pos4d[0]/=pos4d[3];
	pos4d[1]/=pos4d[3];
	pos4d[2]/=pos4d[3];
	threeD.Set(pos4d[0],pos4d[1],pos4d[2]);
}

void Display(void)
{
	double matBuf[4*4];
	YsVec3 eyePos;
	YsMatrix4x4 eyeTfm;
	YsVec3 p;

	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	eyePos.Set(0.0,0.0,eyeDistance);
	eyePos=eyeAtt.GetMatrix()*eyePos;

	eyeTfm.Initialize();
	eyeTfm.Translate(eyePos);
	eyeTfm.Rotate(eyeAtt);
	eyeTfm.Invert();
	eyeTfm.Translate(-eyeLookAt);

	eyeTfm.GetArray(matBuf);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glMultMatrixd(matBuf);
	DrawAxis(5.0);

	glDisable(GL_LIGHTING);
	glColor3d(1.0,1.0,1.0);
	glBegin(GL_LINES);
	glVertex3d(0.0,0.0,0.0);
	glVertex3d(axisOfOrbit.x()*5.0,axisOfOrbit.y()*5.0,axisOfOrbit.z()*5.0);
	glEnd();

	rot.RotatePositive(p,orbiter);
	glPushMatrix();
	glTranslatef(p.x()*5.0,p.y()*5.0,p.z()*5.0);
	DrawCursor();
	glPopMatrix();

	glFlush();
	glutSwapBuffers();
}

static YSRESULT YsClip3DLine
    (YsVec3 &clip,const YsVec3 &org,const YsVec3 &vec,const double &clipPoint,int component)
{
	int c1,c2;
	double buf[3],slope[3];

	if(component==0)
	{
		c1=1;
		c2=2;
	}
	else if(component==1)
	{
		c1=0;
		c2=2;
	}
	else
	{
		c1=0;
		c2=1;
	}

	if(YsAbs(vec.GetValue()[component])>=YsTolerance)
	{
		slope[c1]=vec.GetValue()[c1]/vec.GetValue()[component];
		slope[c2]=vec.GetValue()[c2]/vec.GetValue()[component];

		buf[component]=clipPoint;
		buf[c1]=org.GetValue()[c1]+slope[c1]*(clipPoint-org.GetValue()[component]);
		buf[c2]=org.GetValue()[c2]+slope[c2]*(clipPoint-org.GetValue()[component]);

		clip.Set(buf[0],buf[1],buf[2]);

		return YSOK;
	}
	else
	{
		return YSERR;
	}
}

static YSRESULT YsClipInfiniteLine3_FindSecondIntersection
    (YsVec3 &itsc,const YsVec3 &first,const YsVec3 &vec,const YsVec3 range[2])
{
	int i,j,k;
	double dist,d;
	YSRESULT found;
	YsVec3 candidate;

	found=YSERR;
	dist=-1.0;
	candidate.Set(0.0,0.0,0.0);
	for(i=0; i<3; i++)
	{
		for(j=0; j<2; j++)
		{
			if(YsClip3DLine(candidate,first,vec,range[j].GetValue()[i],i)==YSOK)
			{
				for(k=0; k<3; k++)
				{
					if(i!=k &&
					   (candidate.GetValue()[k]<range[0].GetValue()[k]-YsTolerance ||
					    range[1].GetValue()[k]+YsTolerance<candidate.GetValue()[k]))
					{
						goto NEXTPLANE;
					}
				}
				found=YSOK;
				d=(first-candidate).GetSquareLength();
				if(d>dist)
				{
					itsc=candidate;
					dist=d;
				}
			}
		NEXTPLANE:
			;
		}
	}
	return found;
}

int main(int argc, char** argv)
{
	InitYsClass();

	axisOfOrbit.Set(1.0,1.0,1.0);
	axisOfOrbit.Normalize();

	orbiter=axisOfOrbit.GetArbitraryParpendicularVector();
	orbiter.Normalize();

	rot.Set(axisOfOrbit,0.0);


	printf("Keys\n");
	printf("A....Viewing Rotation Mode\n");
	printf("B....Viewing Translation (Scroll) Mode\n");
	printf("Z....Zoom\n");
	printf("M....Mooz\n");
	printf("----------\n");

	eyeAtt.Set(YsPi/2.0,0.0,0.0);
	eyeDistance=10.0;

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowSize(500, 500);
	glutInitWindowPosition(100, 100);
	glutCreateWindow(argv[0]);
	InitOpenGL();
	glutDisplayFunc(Display);
	glutReshapeFunc(Reshape);
	glutKeyboardFunc(Keyboard);
	glutMouseFunc(Mouse);
	glutMotionFunc(Motion);
	glutIdleFunc(Idle);
	glutMainLoop();
	return 0;
}

YSRESULT YsShell::LoadTri(const char fn[])
{
	FILE *fp;
	int nNod,nTri;
	YsShellVertexHandle *nodVtHd;
	int ac;
	char buf[256],str[256],*av[32];

	nNod=0;
	nTri=0;
	nodVtHd=NULL;

	fp=fopen(fn,"r");
	if(fp!=NULL)
	{
		while(fgets(str,256,fp)!=NULL)
		{
			strcpy(buf,str);
			YsArguments(&ac,av,32,buf);
			if(ac>0)
			{
				if(strcmp(av[0],"nofnod")==0)
				{
					int i;
					nNod=atoi(av[1]);
					nodVtHd=new YsShellVertexHandle [nNod+1];
					if(nodVtHd==NULL)
					{
						YsExceptionHandler::Exception(YsExceptionHandler::OUTOFMEMORY,"YsShell::LoadTri()");
					}
					for(i=0; i<nNod; i++)
					{
						nodVtHd[i]=NULL;
					}
				}
				else if(strcmp(av[0],"noftri")==0)
				{
					nTri=atoi(av[1]);
				}
				else if(strcmp(av[0],"nod")==0)
				{
					if(nodVtHd!=NULL)
					{
						int ndId;
						YsVec3 pos;
						ndId=atoi(av[1]);
						pos.Set(atof(av[2]),atof(av[3]),atof(av[4]));
						nodVtHd[ndId]=AddVertexH(pos);
					}
					else
					{
						YsErrOut("YsShell::LoadTri()\n");
						YsErrOut("  nofnod didn't come before nod\n");
						fclose(fp);
						goto ERREND;
					}
				}
				else if(strcmp(av[0],"tri")==0)
				{
					YsShellVertexHandle vtHd[3];
					vtHd[0]=nodVtHd[atoi(av[2])];
					vtHd[1]=nodVtHd[atoi(av[3])];
					vtHd[2]=nodVtHd[atoi(av[4])];
					if(vtHd[0]!=NULL && vtHd[1]!=NULL && vtHd[2]!=NULL)
					{
						AddPolygonH(3,vtHd);
					}
					else
					{
						YsErrOut("YsShell::LoadTri()\n");
						YsErrOut("  Nodes must be defined before triangles.\n");
						fclose(fp);
						goto ERREND;
					}
				}
			}
		}
	}
	fclose(fp);
	return YSOK;

ERREND:
	if(nodVtHd!=NULL)
	{
		delete [] nodVtHd;
	}
	return YSERR;
}