virtual bool handle( const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa)
{
osgViewer::Viewer *viewer=dynamic_cast<osgViewer::Viewer*>(&aa);
if(!viewer) return false;
switch(ea.getEventType())
{
case osgGA::GUIEventAdapter::FRAME:
{
//printf("Time %f\n",ea.getTime());
gMyPhysX.simulate(1.0f/60.0f);
int nbActors = gMyPhysX.getScene()->getNbActors();
NxActor** actors = gMyPhysX.getScene()->getActors();
//int userdateNum = 0;
while(nbActors--)
{
NxActor* actor = *actors++;
if(!actor->userData) continue;
osg::MatrixTransform *mt = static_cast<osg::MatrixTransform*>(actor->userData);
if (mt)
{
float glmat[16];
actor->getGlobalPose().getColumnMajor44(glmat);//得到角色的世界位置
osg::Matrix mat;
mat.set(glmat);
mt->setMatrix(mat);
//userdateNum+=1;
//printf("userdateNum = %d\n",userdateNum);
}
}
return false;
}
case(osgGA::GUIEventAdapter::KEYDOWN):
{
if(ea.getKey()=='w'||ea.getKey()=='W')
{
CreateCubeFromEye(2,viewer->getCamera());
}
return false;
}
default:
return false;
}
}
void PhysUpdate ( void )
{
int iObject = 1;
// Render all the actors in the scene
int nbActors = gScene->getNbActors();
NxActor** actors = gScene->getActors();
while (nbActors--)
{
NxActor* actor = *actors++;
// Get an OpenGL transform (float[16]) from a Novodex shape’s global pose
// (NxMat34)
NxShape* shape = NULL;
NxMat34 pose = actor->getGlobalPose();
NxMat33 orient = pose.M;
NxVec3 pos = pose.t;
float glmat[16]; // 4x4 column major OpenGL matrix
orient.getColumnMajorStride4(&(glmat[0]));
pos.get(&(glmat[12]));
// clear the elements we don't need:
glmat[3] = glmat[7] = glmat[11] = 0.0f;
glmat[15] = 1.0f;
{
sPhysObject* pPhys = ( sPhysObject* ) actor->userData;
if ( pPhys )
{
SetWorldMatrix ( pPhys->iID, ( D3DXMATRIX* ) &glmat );
sObject* pObject = dbGetObject ( pPhys->iID );
pObject->position.vecPosition = D3DXVECTOR3 ( glmat [ 12 ], glmat [ 13 ], glmat [ 14 ] );
}
}
}
}
void render()
{
static Timer t;
if(gScene && !gPauseSimulation) //start the simulation
{
gTouchedTris.clear();
gScene->simulate(t.elapsed_time());
//printf("%f\n",t.elapsed_time());
t.reset();
gScene->flushStream();
/*ASYNC: in here we can do computations which depend only on the old
state of the scene "actors". Writing to the scene is not allowed.
Write calls in here are skipped.
*/
gScene->fetchResults(NX_RIGID_BODY_FINISHED,true);
}
// Clear buffers
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glColor4f(0.0,1.0,1.0,1.0);
DrawSkyBox(5000.0f);
//drawPlane(2000.0);
//Render all actors
int nbActors = gScene->getNbActors();
NxActor** actors = gScene->getActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if(!actor->userData) continue;
// Render actor
glPushMatrix();
float glMat[16];
actor->getGlobalPose().getColumnMajor44(glMat);
glMultMatrixf(glMat);
NxVec3 color = static_cast<UserData*>(actor->userData)->color;
glColor4f(color.x,color.y,color.z,1.0f);
glutSolidCube((static_cast<UserData*>(actor->userData)->size)*2.0f);
glPopMatrix();
}
RenderTerrain();
}
void Part::render()
{
assert(act && "partrender: physics equivalent invalid");
glPushMatrix();
float glMat[16];
NxActor* actor;
actor=act;
if(NULL==actor) return;
actor->getGlobalPose().getColumnMajor44(glMat);
glMultMatrixf(glMat);
if(actor->userData!=NULL && gRenderUserData) {
glPushMatrix();
((GraphicsObject*)actor->userData)->render();
glPopMatrix();
}
else {
//render according to shape descriptions in actor
for(unsigned s=0; s < actor->getNbShapes(); s++) {
NxShape *shape = actor->getShapes()[s];
glPushMatrix();
shape->getLocalPose().getColumnMajor44(glMat);
glMultMatrixf(glMat);
//render shapes
if(shape->getFlag(NX_TRIGGER_ENABLE)) {
//do nothing, triggers are not to be rendered and have different userdata
}
else if(shape->userData!=NULL) {
((GraphicsObject*)shape->userData)->render();
}
else {
NxShapeType type=shape->getType();
if(NX_SHAPE_BOX==type) {
NxBoxShape *sh=(NxBoxShape *)shape;
NxVec3 dim=sh->getDimensions();
BoxGraphicsObject g(dim.x,dim.z,dim.y); //wrond dimensions
g.render();
}
else if(NX_SHAPE_CAPSULE==type) {
NxCapsuleShape *sh=(NxCapsuleShape *)shape;
float radius=sh->getRadius();
float height=sh->getHeight();
CapsuleGraphicsObject g(radius,height);
g.render();
}
else if(NX_SHAPE_SPHERE==type) {
NxSphereShape *sh=(NxSphereShape *)shape;
float radius=sh->getRadius();
SphereGraphicsObject g(radius);
g.render();
}
else {
//render a default sphere if shape type unknown
SphereGraphicsObject sg(1);
sg.render();
}
}
glPopMatrix();
}
}
glPopMatrix();
}
// this function is called each frame
void glutDisplay (void)
{
if(gScene == NULL) return;
gScene->simulate(1.0f/30.0f);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// 射影マトリックス
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(100.0f, (float)glutGet(GLUT_WINDOW_WIDTH)/(float)glutGet(GLUT_WINDOW_HEIGHT), 1.0f, 10000.0f); // 視点の位置
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(gEye.x, gEye.y, gEye.z, gEye.x + gDir.x, gEye.y + gDir.y, gEye.z + gDir.z, 0.0f, 1.0f, 0.0f);
xn::SceneMetaData sceneMD;
xn::DepthMetaData depthMD;
g_DepthGenerator.GetMetaData(depthMD);
if (!g_bPause)
{
// Read next available data
g_Context.WaitAndUpdateAll();
}
for(int i=0;i<2;i++){
for(int j=0;j<15;j++){
oldjpoint[i][j]=jpoint[i][j];
}
}
// Process the data
g_DepthGenerator.GetMetaData(depthMD);
g_UserGenerator.GetUserPixels(0, sceneMD);
CalculateJoint();
head.x=(jpoint[0][0].X);
head.y=(jpoint[0][0].Y);
head.z=(jpoint[0][0].Z);
neck.x=(jpoint[0][1].X);
neck.y=(jpoint[0][1].Y);
neck.z=(jpoint[0][1].Z);
rshoulder.x=(jpoint[0][2].X);
rshoulder.y=(jpoint[0][2].Y);
rshoulder.z=(jpoint[0][2].Z);
relbow.x=(jpoint[0][3].X*2+oldjpoint[0][3].X)/3;
relbow.y=(jpoint[0][3].Y*2+oldjpoint[0][3].Y)/3;
relbow.z=(jpoint[0][3].Z*2+oldjpoint[0][3].Z)/3;
rhand.x=(jpoint[0][4].X*2+oldjpoint[0][4].X)/3;
rhand.y=(jpoint[0][4].Y*2+oldjpoint[0][4].Y)/3;
rhand.z=(jpoint[0][4].Z*2+oldjpoint[0][4].Z)/3;
lshoulder.x=(jpoint[0][5].X*2+oldjpoint[0][5].X)/3;
lshoulder.y=(jpoint[0][5].Y*2+oldjpoint[0][5].Y)/3;
lshoulder.z=(jpoint[0][5].Z*2+oldjpoint[0][5].Z)/3;
lelbow.x=(jpoint[0][6].X*2+oldjpoint[0][6].X)/3;
lelbow.y=(jpoint[0][6].Y*2+oldjpoint[0][6].Y)/3;
lelbow.z=(jpoint[0][6].Z*2+oldjpoint[0][6].Z)/3;
lhand.x=(jpoint[0][7].X*2+oldjpoint[0][7].X)/3;
lhand.y=(jpoint[0][7].Y*2+oldjpoint[0][7].Y)/3;
lhand.z=(jpoint[0][7].Z*2+oldjpoint[0][7].Z)/3;
torso.x=(jpoint[0][8].X*2+oldjpoint[0][8].X)/3;
torso.y=(jpoint[0][8].Y*2+oldjpoint[0][8].Y)/3;
torso.z=(jpoint[0][8].Z*2+oldjpoint[0][8].Z)/3;
rhip.x=(jpoint[0][9].X*2+oldjpoint[0][9].X)/3;
rhip.y=(jpoint[0][9].Y*2+oldjpoint[0][9].Y)/3;
rhip.z=(jpoint[0][9].Z*2+oldjpoint[0][9].Z)/3;
rknee.x=(jpoint[0][10].X*2+oldjpoint[0][10].X)/3;
rknee.y=(jpoint[0][10].Y*2+oldjpoint[0][10].Y)/3;
rknee.z=(jpoint[0][10].Z*2+oldjpoint[0][10].Z)/3;
rfoot.x=(jpoint[0][11].X*2+oldjpoint[0][11].X)/3;
rfoot.y=(jpoint[0][11].Y*2+oldjpoint[0][11].Y)/3;
rfoot.z=(jpoint[0][11].Z*2+oldjpoint[0][11].Z)/3;
lhip.x=(jpoint[0][12].X*2+oldjpoint[0][12].X)/3;
lhip.y=(jpoint[0][12].Y*2+oldjpoint[0][12].Y)/3;
lhip.z=(jpoint[0][12].Z*2+oldjpoint[0][12].Z)/3;
lknee.x=(jpoint[0][13].X*2+oldjpoint[0][13].X)/3;
lknee.y=(jpoint[0][13].Y*2+oldjpoint[0][13].Y)/3;
lknee.z=(jpoint[0][13].Z*2+oldjpoint[0][13].Z)/3;
lfoot.x=(jpoint[0][14].X*2+oldjpoint[0][14].X)/3;
lfoot.y=(jpoint[0][14].Y*2+oldjpoint[0][14].Y)/3;
lfoot.z=(jpoint[0][14].Z*2+oldjpoint[0][14].Z)/3;
printf("%f, %f, %f\n",rightreduction.x, rightreduction.y, rightreduction.z);
printf("%f, %f, %f\n",leftreduction.x, leftreduction.y, leftreduction.z);
if(jpoint[0][8].X!=0.0&&jpoint[0][8].Y!=0.0&&jpoint[0][8].Z!=0.0){
Head->setGlobalPosition(NxVec3(-head.x+positionx, -head.y+positiony, -head.z+positionz));
Head->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
Neck->setGlobalPosition(NxVec3(-neck.x+positionx, -neck.y+positiony, -neck.z+positionz));
Neck->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
rightshoulder->setGlobalPosition(NxVec3(-rshoulder.x+positionx, -rshoulder.y+positiony, -rshoulder.z+positionz));
rightshoulder->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
rightelbow->setGlobalPosition(NxVec3(-relbow.x+positionx, -relbow.y+positiony, -relbow.z+positionz));
rightelbow->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
righthand->setGlobalPosition(NxVec3(-rhand.x+positionx, -rhand.y+positiony, -rhand.z+positionz));
righthand->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
leftshoulder->setGlobalPosition(NxVec3(-lshoulder.x+positionx, -lshoulder.y+positiony, -lshoulder.z+positionz));
leftshoulder->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
leftelbow->setGlobalPosition(NxVec3(-lelbow.x+positionx, -lelbow.y+positiony, -lelbow.z+positionz));
leftelbow->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
lefthand->setGlobalPosition(NxVec3(-lhand.x+positionx, -lhand.y+positiony, -lhand.z+positionz));
lefthand->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
Torso->setGlobalPosition(NxVec3(-torso.x+positionx, -torso.y+positiony, -torso.z+positionz));
Torso->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
righthip->setGlobalPosition(NxVec3(-rhip.x+positionx, -rhip.y+positiony, -rhip.z+positionz));
righthip->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
rightknee->setGlobalPosition(NxVec3(-rknee.x+positionx, -rknee.y+positiony, -rknee.z+positionz));
rightknee->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
rightfoot->setGlobalPosition(NxVec3(-rfoot.x+positionx, -rfoot.y+positiony, -rfoot.z+positionz));
rightfoot->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
lefthip->setGlobalPosition(NxVec3(-lhip.x+positionx, -lhip.y+positiony, -lhip.z+positionz));
lefthip->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
leftknee->setGlobalPosition(NxVec3(-lknee.x+positionx, -lknee.y+positiony, -lknee.z+positionz));
leftknee->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
leftfoot->setGlobalPosition(NxVec3(-lfoot.x+positionx, -lfoot.y+positiony, -lfoot.z+positionz));
leftfoot->setLinearVelocity(NxVec3(0.0f, 0.0f, 0.0f));
}
glPushMatrix();
glBegin(GL_POLYGON);
glColor4f(0.2f,1.2f,0.1f,1.0f); // 地面の色
glVertex3f( 10000.0f,-1.0f, 10000.0f);
glVertex3f( 10000.0f,-1.0f,-10000.0f);
glVertex3f(-10000.0f,-1.0f,-10000.0f);
glVertex3f(-10000.0f,-1.0f, 10000.0f);
glEnd();
glPopMatrix();
//地平線の描画
glPushMatrix();
glColor4f(1.0f, 1.0f, 1.0f,1.0f);
glLineWidth(1);
glBegin(GL_LINES);
for(int i=-10000; i< 10000; i+=500) {
glVertex3f( i , -0.2f,-10000 );
glVertex3f( i , -0.2f, 10000 );
glVertex3f(-10000, -0.2f, i );
glVertex3f( 10000, -0.2f, i );
}
glEnd();
glPopMatrix();
switch(gameflag){
case 0: // スタート画面
glViewport( 0, 0, (float)glutGet(GLUT_WINDOW_WIDTH),(float)glutGet(GLUT_WINDOW_HEIGHT) );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.0f, (float)glutGet(GLUT_WINDOW_WIDTH),(float)glutGet(GLUT_WINDOW_HEIGHT), 0.0f, 0.0f, 1.0f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glPushMatrix();
glColor3d(1.0, 1.0, 0.0);
glRasterPos3d(GL_WIN_SIZE_X/2-80, GL_WIN_SIZE_Y/2, 0.0);
drawBitmapString(GLUT_BITMAP_HELVETICA_18,"Push 's' -> START");
glPopMatrix();
printf("Push 's' -> START\n");
break;
case 1: // ゲーム終了時
glViewport( 0, 0, (float)glutGet(GLUT_WINDOW_WIDTH),(float)glutGet(GLUT_WINDOW_HEIGHT) );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.0f, (float)glutGet(GLUT_WINDOW_WIDTH),(float)glutGet(GLUT_WINDOW_HEIGHT), 0.0f, 0.0f, 1.0f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glPushMatrix();
glColor3d(0.0, 0.0, 1.0);
glRasterPos3d(GL_WIN_SIZE_X/2-60, GL_WIN_SIZE_Y/2+20, 0.0);
drawBitmapString(GLUT_BITMAP_HELVETICA_18,"GAME OVER");
glPopMatrix();
glPushMatrix();
glColor3d(1.0, 1.0, 0.0);
glRasterPos3d(GL_WIN_SIZE_X/2-65, GL_WIN_SIZE_Y/2, 0.0);
drawBitmapString(GLUT_BITMAP_HELVETICA_18,gametime);
glPopMatrix();
glPushMatrix();
glColor3d(1.0, 0.0, 0.0);
glRasterPos3d(GL_WIN_SIZE_X/2-90, GL_WIN_SIZE_Y/2-20, 0.0);
drawBitmapString(GLUT_BITMAP_HELVETICA_18,"Push 'r' -> RESTART");
glPopMatrix();
printf("GAME OVER\ntime -> %f\n",(double)(t2 - t1) / CLOCKS_PER_SEC);
break;
case 2: // ゲーム中の画面
glEnable(GL_DEPTH_TEST);
// アクターの描画
int nbActors = gScene->getNbActors();
NxActor** actors = gScene->getActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if(!actor->userData) continue;
glPushMatrix();
glEnable(GL_LIGHTING);
float glMat[16];
actor->getGlobalPose().getColumnMajor44(glMat);
glMultMatrixf(glMat);
myData* mydata = (myData*)actor->userData;
int shape = mydata->shape;
int color = mydata->color;
switch(shape){
case 1:
glColor4f(0.0f,0.0f,1.0f,1.0f);
if(mydata->houkou==0){
link(pole[0], pole[4]);
}
else if(mydata->houkou==1){
tlink(3000.0,2000.0,6000.0,-3000.0,2000.0,6000.0);
tlink(-3000.0,2000.0,4000.0,-3000.0,2000.0,6000.0);
}
else if(mydata->houkou==2){
ylink(3000.0,2000.0,4000.0,-3000.0,2000.0,4000.0);
ylink(3000.0,2000.0,6000.0,-3000.0,2000.0,6000.0);
}
else if(mydata->houkou==3){ // パネル
glColor4f(0.0f,1.0f,1.0f,1.0f);
cuboid(mydata->width*2,mydata->length*2, mydata->height*2);
}
else if(mydata->houkou==4){
}
break;
case 2:
if(mydata->ball == 1){
glColor4f(1.0f,0.0f,0.0f,1.0f); // ボールの色
glutSolidSphere(mydata->size,15,15);
}
else if(mydata->ball == 0){
glColor4f(1.0f,1.0f,0.0f,1.0f);
glutSolidSphere(mydata->size,15,15);
}
break;
case 4:
glColor4f(1.0f,0.0f,0.0f,1.0f);
cylinder(50, 100, 50);
break;
}
glDisable(GL_LIGHTING);
glPopMatrix();
}
glDisable(GL_DEPTH_TEST);
t2 = clock();
balltimer2 = clock();
btime=(double)(balltimer2 - balltimer1) / CLOCKS_PER_SEC;
gtime=(double)(t2 - t1) / CLOCKS_PER_SEC;
printf("%f\n",gtime);
if(gtime<=10.0){
balldire=2.0;
ballspeed=250.0;
}
else if(gtime<=20.0){
balldire=1.5;
ballspeed=300.0;
}
else if(gtime<=30.0){
balldire=1.0;
ballspeed=350.0;
}
else if(gtime<=40.0){
balldire=0.5;
ballspeed=400.0;
}
break;
}
// 描画の終了
gScene->flushStream();
gScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
glutSwapBuffers();
}
void plPXPhysicalControllerCore::ICreateController(const hsPoint3& pos)
{
NxScene* scene = plSimulationMgr::GetInstance()->GetScene(fWorldKey);
NxCapsuleControllerDesc desc;
desc.position.x = pos.fX;
desc.position.y = pos.fY;
desc.position.z = pos.fZ;
desc.upDirection = NX_Z;
desc.slopeLimit = kSLOPELIMIT;
desc.skinWidth = kPhysxSkinWidth;
desc.stepOffset = STEP_OFFSET;
desc.callback = &gMyReport;
desc.userData = this;
desc.radius = fRadius;
desc.height = fHeight;
desc.interactionFlag = NXIF_INTERACTION_EXCLUDE;
//desc.interactionFlag = NXIF_INTERACTION_INCLUDE;
fController = (NxCapsuleController*)gControllerMgr.createController(scene, desc);
// Change the avatars shape groups. The avatar doesn't actually use these when
// it's determining collision, but if you're standing still and an object runs
// into you, it'll pass through without this.
NxActor* actor = fController->getActor();
NxShape* shape = actor->getShapes()[0];
shape->setGroup(plSimDefs::kGroupAvatar);
// need to create the non-bouncing object that can be used to trigger things while the avatar is doing behaviors.
NxActorDesc actorDesc;
NxCapsuleShapeDesc capDesc;
capDesc.radius = fRadius;
capDesc.height = fHeight;
capDesc.group = plSimDefs::kGroupAvatar;
actorDesc.shapes.pushBack(&capDesc);
capDesc.materialIndex= plSimulationMgr::GetInstance()->GetMaterialIdx(scene, 0.0,0.0);
actorDesc.globalPose=actor->getGlobalPose();
NxBodyDesc bodyDesc;
bodyDesc.mass = kAvatarMass;
actorDesc.body = &bodyDesc;
bodyDesc.flags = NX_BF_KINEMATIC;
bodyDesc.flags |=NX_BF_DISABLE_GRAVITY ;
actorDesc.name = "AvatarTriggerKinematicGuy";
fSeeking=false;
try
{
fKinematicActor = scene->createActor(actorDesc);
}
catch (...)
{
hsAssert(false, "Actor creation crashed");
}
// set the matrix to be the same as the controller's actor... that should orient it to be the same
//fKinematicActor->setGlobalPose(actor->getGlobalPose());
// the proxy for the debug display
//hsAssert(!fProxyGen, "Already have proxy gen, double read?");
hsColorRGBA physColor;
float opac = 1.0f;
// local avatar is light purple and transparent
physColor.Set(.2f, .1f, .2f, 1.f);
opac = 0.8f;
/*
// the avatar proxy doesn't seem to work... not sure why?
fProxyGen = new plPhysicalProxy(hsColorRGBA().Set(0,0,0,1.f), physColor, opac);
fProxyGen->Init(this);
*/
}
static void RenderCallback()
{
/*
static DWORD PreviousTime = 0;
DWORD CurrentTime = getTime();
DWORD ElapsedTime = CurrentTime - PreviousTime;
PreviousTime = CurrentTime;
*/
// Physics code
if(!gPause)
{
NxU32 i;
//this is an example of allowing two scenes to run in parallell if the implementation supports it:
for(i=0;i<2;i++)
{
if(gScenes[i])
{
gScenes[i]->simulate(1.0f/60.0f); //Note: a real application would compute and pass the elapsed time here.
gScenes[i]->flushStream();
}
}
for(i=0;i<2;i++)
{
if(gScenes[i])
{
gScenes[i]->fetchResults(NX_RIGID_BODY_FINISHED, true);
}
}
}
// ~Physics code
// Clear buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Setup camera
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (float)glutGet(GLUT_WINDOW_WIDTH)/(float)glutGet(GLUT_WINDOW_HEIGHT), 1.0f, 10000.0f);
gluLookAt(Eye.x, Eye.y, Eye.z, Eye.x + Dir.x, Eye.y + Dir.y, Eye.z + Dir.z, 0.0f, 1.0f, 0.0f);
// Keep physics & graphics in sync
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
for(NxU32 i=0;i<2;i++)
{
int nbActors = gScenes[i]->getNbActors();
NxActor** actors = gScenes[i]->getActors();
while(nbActors--)
{
NxActor* actor = *actors++;
glPushMatrix();
float glmat[16];
actor->getGlobalPose().getColumnMajor44(glmat);
glMultMatrixf(glmat);
if(i==0) glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
else glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
glutSolidCube(float(int(actor->userData))*2.0f);
glPopMatrix();
// Handle shadows
if(gShadows)
{
glPushMatrix();
const static float ShadowMat[]={ 1,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,1 };
glMultMatrixf(ShadowMat);
glMultMatrixf(glmat);
glDisable(GL_LIGHTING);
glColor4f(0.3f, 0.2f, 0.3f, 1.0f);
glutSolidCube(float(int(actor->userData))*2.0f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glEnable(GL_LIGHTING);
glPopMatrix();
}
}
}
#ifdef __PPCGEKKO__
char buf[256];
sprintf(buf,
"\nPress the keys 1,2,+,-, and b to create various things.\nThe object will appear in randomly in one of two scenes.\n"
"\nUse the arrow keys to move around."
"\nPress a to pause the simulation.\n" );
GLFontRenderer::setScreenResolution(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
GLFontRenderer::setColor(0.9f, 1.0f, 0.0f, 1.0f);
GLFontRenderer::print(0.01, 0.9, 0.036, buf, false, 11, true);
#endif
glutSwapBuffers();
}
void FPxSceneMain::Tick( FLOAT DeltaTime )
{
pxguard(FPxSceneMain::Tick);
if( mScene )
{
//mCharManager->updateControllers();
//
// Kinematic actors move unreal actors
//
/*NxActor** actors = mScene->getActors();
int nbActors = mScene->getNbActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if( actor->userData && actor->isDynamic() && actor->readBodyFlag( NX_BF_KINEMATIC ) )
{
AActor* aptr = (AActor*)actor->userData;
// update location and rotation
FCheckResult Hit(1.0f);
NxMat34 m = actor->getGlobalPose();
aptr->GetLevel()->MoveActor( aptr, FVector(0,0,0), ToRotator(m.M), Hit );
aptr->GetLevel()->FarMoveActor( aptr, ToFVS(m.t), 0, 1 );
}
}*/
//
// Unreal actors move kinematic actors
//
/*NxActor** actors = mScene->getActors();
int nbActors = mScene->getNbActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if( actor->userData && actor->isDynamic() && actor->readBodyFlag( NX_BF_KINEMATIC ) )
{
AActor* aptr = (AActor*)actor->userData;
// update location and rotation
NxMat34 m = ToMat34(aptr->Rotation,aptr->Location);
actor->setGlobalPose(m);
}
}*/
//
// Dynamic actors move unreal actors
//
NxActor** actors = mScene->getActors();
int nbActors = mScene->getNbActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if( actor->userData && actor->isDynamic() && !actor->readBodyFlag( NX_BF_KINEMATIC ) )
{
AActor* aptr = (AActor*)actor->userData;
// update location and rotation
FCheckResult Hit(1.0f);
NxMat34 m = actor->getGlobalPose();
aptr->GetLevel()->FarMoveActor( aptr, ToFVS(m.t) );
aptr->GetLevel()->MoveActor( aptr, FVector(0,0,0), ToRotator(m.M), Hit );
}
}
//
// TODO: optimize timing
//
// Minimum acceptable framerate is 5fps
if( DeltaTime > 0.2f )
{
DeltaTime = 0.2f;
}
mTime += DeltaTime;
while( /*!mSimulating &&*/ mTime >= PX_TIMESTEP )
{
mTime -= PX_TIMESTEP;
mScene->simulate(PX_TIMESTEP);
mScene->flushStream();
mScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
//mSimulating = true;
}
//renderScene();
/*if( mSimulating && mScene->checkResults(NX_RIGID_BODY_FINISHED, false) )
{
mScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
mSimulating = false;
//modifyScene(DeltaTime);
}*/
// get debug info
if( GPxPhysics.mDrawPhysX )
mDebugRen = mScene->getDebugRenderable();
}
unguard;
}
static void RenderCallback()
{
if(pScene == NULL) {
#ifdef _DEBUG
std::cout << "pScene == NULL" << std::endl;
#endif //_DEBUG
return;
}
// Start simulation
if (isSimulate) {
pScene->simulate(1.0f/60.0f);
}
// Clear buffers
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Setup projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, (float)glutGet(GLUT_WINDOW_WIDTH)/(float)glutGet(GLUT_WINDOW_HEIGHT), 1.0f, 10000.0f);
gluLookAt(gEye.x, gEye.y, gEye.z, gEye.x + gDir.x, gEye.y + gDir.y, gEye.z + gDir.z, 0.0f, 1.0f, 0.0f);
// Setup modelview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Render all actors
int nbActors = pScene->getNbActors();
NxActor** actors = pScene->getActors();
while(nbActors--)
{
NxActor* actor = *actors++;
if(actor->userData == NULL) {
// draw grid
glBegin(GL_LINES);
int y = 0;
for(int i=-100; i<=100; ++i) {
glVertex3f(i*10,y,-1000);
glVertex3f(i*10,y,1000);
glVertex3f(1000,y,i*10);
glVertex3f(-1000,y,i*10);
}
glEnd();
}
// Render actor
glPushMatrix();
float glMat[16];
actor->getGlobalPose().getColumnMajor44(glMat);
glMultMatrixf(glMat);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glutSolidCube(size_t(actor->userData)*10.0f);
glPopMatrix();
// Render shadow
glPushMatrix();
const static float shadowMat[]= { 1,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,1 };
glMultMatrixf(shadowMat);
glMultMatrixf(glMat);
glDisable(GL_LIGHTING);
glColor4f(0.1f, 0.2f, 0.3f, 1.0f);
glutSolidCube(size_t(actor->userData)*10.0f);
glEnable(GL_LIGHTING);
glPopMatrix();
}
// Fetch simulation results
if(isSimulate) {
pScene->flushStream();
pScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
}
glutSwapBuffers();
}
void NxRobot::cloneRobot(int indexNewScene, int indexNewRobot, NxVec3 newPosition, int indexNewTeam)
{
NxRobot* nxRobotSource = Simulation::gScenes[this->indexScene]->allRobots->getRobotByIdByTeam(this->id, this->idTeam);
NxActor* robotActor = Simulation::cloneActor(nxRobotSource->getActor(),indexNewScene);
//NxBounds3 bodyBounds;
//robotShapes[0]->getWorldBounds(bodyBounds);
NxVehicleDesc vehicleDesc;
vehicleDesc.position = NxVec3(robotActor->getGlobalPosition());
vehicleDesc.mass = robotActor->getMass();
//vehicleDesc.motorForce = 70000;
//vehicleDesc.maxVelocity = 300.f;
//vehicleDesc.cameraDistance = 8.0f;
vehicleDesc.centerOfMass.set(robotActor->getCMassLocalPosition());
//vehicleDesc.differentialRatio = 3.42f;
//vehicleDesc.transmissionEfficiency
vehicleDesc.actor = robotActor;
//Motor descricao
//NxVehicleMotorDesc motorsDesc[4];
//for(NxU32 i=0;i<4;i++)
//{
//motorsDesc[i].setToCorvette();
//vehicleDesc.motorsDesc.push_back(&motorsDesc[i]);
//}
//Roda (Wheel) descricao
int numberWheels = nxRobotSource->getNbWheels();
NxWheelDesc* wheelDesc = new NxWheelDesc[numberWheels];
for(NxU32 i=0; i<numberWheels; i++)
{
//NxActor* wheelModel = Simulation::getActorWheel(indexSourceScene,indexNewRobot,i);
//NxActorDesc wheelActorDesc;
//wheelModel->saveToDesc(wheelActorDesc);
//Simulation::gScenes[0]->releaseActor(*wheelModel);
//NxShape*const* wheelShapes = actorWheel->getShapes();
//NxBounds3 wheelBounds;
//wheelShapes[0]->getWorldBounds(wheelBounds);
const NxWheel* wheel = nxRobotSource->getWheel(i);
NxWheelShape* wheelShape = ((NxWheel2*)wheel)->getWheelShape();
//wheelDesc[i].wheelApproximation = 10;
wheelDesc[i].wheelOrientation = wheelShape->getGlobalOrientation();
wheelDesc[i].position.set(wheelShape->getGlobalPosition()-robotActor->getGlobalPosition());
//wheelDesc[i].position.z = 0;
wheelDesc[i].id = i;
wheelDesc[i].wheelFlags = ((NxWheel*)wheel)->getWheelFlags();
wheelDesc[i].wheelRadius = wheel->getRadius();
//wheelDesc[i].wheelWidth = 100;
wheelDesc[i].wheelSuspension = wheelShape->getSuspensionTravel();
wheelDesc[i].springRestitution = 0;
wheelDesc[i].springDamping = 0;
wheelDesc[i].springBias = 0.0f;
wheelDesc[i].maxBrakeForce = 100;
wheelDesc[i].frictionToFront = 0.1f;//0.1f;
wheelDesc[i].frictionToSide = 0;//0.02f;//
wheelDesc[i].inverseWheelMass = wheelShape->getInverseWheelMass(); //TODO: CONFIGURAR PARÂMETRO
//Angulo das Rodas (Omni)
wheelDesc[i].angWheelRelRobot = ((NxWheel2*)wheel)->angWheelRelRobot;
vehicleDesc.robotWheels.pushBack(&wheelDesc[i]);
}
//Criar robot, vehicle base
NxRobot* robot = (NxRobot*)NxRobot::createVehicle(Simulation::gScenes[indexNewScene], &vehicleDesc);
//NxRobot* robot = (NxRobot*)NxRobot::createVehicle(gScenes[indexSourceScene], &vehicleDesc);
robot->setId(indexNewRobot);
robot->setIdTeam(indexNewTeam);
robot->indexScene = indexNewScene;
robot->bodyRadius = nxRobotSource->bodyRadius;
//Dribbler and Kicker
NxShape*const* robotShapes = robotActor->getShapes();
for(int i=0; i<robotActor->getNbShapes(); i++) {
const char* shapeName = robotShapes[i]->getName();
if(shapeName) {
char* dribblerName = new char[10];//"Driblador\0"
dribblerName[9] = 0;
memcpy(dribblerName, shapeName, strlen(dribblerName));
if(strcmp(dribblerName, "Driblador") == 0) {
robot->dribbler->dribblerShapes.push_back(robotShapes[i]);
}
delete dribblerName;
}
}
robot->kicker->kickerShapeDesc = new NxBoxShapeDesc();
NxShapeDesc* shapeDesc = nxRobotSource->kicker->kickerShapeDesc;
robot->kicker->kickerShapeDesc->localPose = shapeDesc->localPose;
((NxBoxShapeDesc*)(robot->kicker->kickerShapeDesc))->dimensions = ((NxBoxShapeDesc*)shapeDesc)->dimensions;
//Initial Pose
robot->setInitialPose(robotActor->getGlobalPose());
robotActor->putToSleep();
//Transladando o robo
robot->getActor()->setGlobalPosition(newPosition);
string label;
string plabel = "Robo";
stringstream out;
out << indexNewRobot;
out << "-";
out << indexNewTeam;
//out << "-";
//out << indexNewScene;
label.append(plabel);
label.append(out.str());
char* arrayLabel = new char[label.size()+1];
arrayLabel[label.size()]=0;
memcpy(arrayLabel, label.c_str(), label.size());
robotActor->setName(arrayLabel);
//delete arrayLabel;
}
void Simulation::buildModelRobot(int indexRobot, int indexScene, int indexTeam)
{
//Veiculo descricao
//Body Descricao
NxActor* robotActor = Simulation::getActorRobot(indexScene, indexRobot);
//NxBounds3 bodyBounds;
//robotShapes[0]->getWorldBounds(bodyBounds);
NxVehicleDesc vehicleDesc;
vehicleDesc.position = NxVec3(robotActor->getGlobalPosition());
float mass = 5.;
vehicleDesc.mass = mass;//robotActor->getMass(); //PLUGIN TAH COM PROBLEMA XML ERRADO
//vehicleDesc.motorForce = 70000;
//vehicleDesc.maxVelocity = 300.f;
//vehicleDesc.cameraDistance = 8.0f;
vehicleDesc.centerOfMass.set(NxVec3(0,0,0));//robotActor->getCMassLocalPosition());
//vehicleDesc.differentialRatio = 3.42f;
//vehicleDesc.transmissionEfficiency
vehicleDesc.actor = robotActor;
vehicleDesc.actor->setMaxAngularVelocity(6.2);
vehicleDesc.actor->setMass(mass);
//TODO: LEVANTAR DAMPING
float t = vehicleDesc.actor->getLinearDamping();
float b = vehicleDesc.actor->getAngularDamping();
//vehicleDesc.actor->setAngularDamping(0.5);
//vehicleDesc.actor->setLinearDamping(0.5);
//TODO: LEVANTAR CMASS E INERTIA TENSOR
//vehicleDesc.actor->setCMassOffsetGlobalPosition(NxVec3(0, 0, 0));
NxMat33 inertiaTensor = NxMat33(NxVec3(1294.4362, 3.14502, -66.954), NxVec3(3.14502, 1094.42351, -0.24279), NxVec3(-66.954, -0.24279, 1754.80511));
vehicleDesc.actor->setCMassOffsetLocalPose( NxMat34( inertiaTensor, NxVec3(0,0,0) ) );
//TODO: Diagonalizar inertiaTensor e passar para setMassSpaceInertiaTensor
vehicleDesc.actor->setMassSpaceInertiaTensor(/*vehicleDesc.actor->getMassSpaceInertiaTensor()*1000.*/NxVec3(1764.3, 1284.9, 1094.4) );
//Motor descricao
//NxVehicleMotorDesc motorsDesc[4];
//for(NxU32 i=0;i<4;i++)
//{
//motorsDesc[i].setToCorvette();
//vehicleDesc.motorsDesc.push_back(&motorsDesc[i]);
//}
//Roda (Wheel) descricao
int numberWheels = Simulation::getNumberWheels(indexScene, indexRobot);
NxWheelDesc* wheelDesc = new NxWheelDesc[numberWheels];
for(NxU32 i=0; i<numberWheels; i++)
{
//NxActor* wheelModel = Simulation::getActorWheel(indexScene,indexRobot,i);
//NxActorDesc wheelActorDesc;
//wheelModel->saveToDesc(wheelActorDesc);
//Simulation::gScenes[0]->releaseActor(*wheelModel);
NxActor* actorWheel = Simulation::getActorWheel(indexScene,indexRobot,i);//wheelModel;//Simulation::gScenes[0]->createActor(wheelActorDesc);
//NxShape*const* wheelShapes = actorWheel->getShapes();
//NxBounds3 wheelBounds;
//wheelShapes[0]->getWorldBounds(wheelBounds);
//Para exportar modelo da roda do 3ds Max
// NxWhee
//wheelDesc[i]
//robot1Shapes[0]->isConvexMesh()->getConvexMesh().saveToDesc(convexMesh);
//NxWheelShape* wheelShape = (NxWheelShape*)wheel;
//NxTriangleMeshDesc meshDesc = *((NxTriangleMeshDesc*)(mesh->userData));
//robot1Shapes[0]->isWheel()->
//wheelDesc[i].wheelApproximation = 10;
wheelDesc[i].wheelOrientation = actorWheel->getGlobalOrientation();
wheelDesc[i].position.set(actorWheel->getGlobalPosition()-robotActor->getGlobalPosition());
//wheelDesc[i].position.z = 0;
wheelDesc[i].id = i;
wheelDesc[i].wheelRadius = 27.6;
//wheelDesc[i].wheelWidth = 100;
wheelDesc[i].wheelSuspension = 0;
wheelDesc[i].springRestitution = 0;
wheelDesc[i].springDamping = 0;
wheelDesc[i].springBias = 0.0f;
wheelDesc[i].maxBrakeForce = 100;
wheelDesc[i].frictionToFront = 0.1f;//0.1f; //TODO: CONFIGURAR PARÂMETRO
wheelDesc[i].frictionToSide = 0;//0.02f; //TODO: CONFIGURAR PARÂMETRO
wheelDesc[i].inverseWheelMass = 0.1; //TODO: CONFIGURAR PARÂMETRO
//Angulo das Rodas (Omni)
NxVec3 wheelPosRel = actorWheel->getGlobalPosition() - robotActor->getGlobalPosition();
wheelDesc[i].angWheelRelRobot = NxMath::atan2( wheelPosRel.y, wheelPosRel.x );
vehicleDesc.robotWheels.pushBack(&wheelDesc[i]);
Simulation::gScenes[indexScene]->scene->releaseActor(*actorWheel);
//NxU32 flags = NX_WF_BUILD_LOWER_HALF;
wheelDesc[i].wheelFlags = NX_WF_ACCELERATED | NX_WF_AFFECTED_BY_HANDBRAKE | NX_WF_USE_WHEELSHAPE | NX_WF_BUILD_LOWER_HALF;// |/*NX_WF_STEERABLE_INPUT |*/ flags;
}
//NxBall* teste = Simulation::gScenes[indexScene]->ball;
//Criar robot, vehicle base
NxRobot* robot = (NxRobot*)NxRobot::createVehicle(Simulation::gScenes[indexScene], &vehicleDesc);
if(robot) {
robot->setId(indexRobot);
robot->setIdTeam(indexTeam);
robot->indexScene = indexScene;
//Dribbler and Kicker
for(int i=0; i<robotActor->getNbShapes(); i++) {
NxShape*const* robotShapes = robotActor->getShapes();
const char* shapeName = robotShapes[i]->getName();
if(shapeName) {
char* dribblerName = new char[10];//"Driblador\0"
dribblerName[9] = 0;
memcpy(dribblerName, shapeName, strlen(dribblerName));
char* kickerName = new char[9];//"Chutador\0"
kickerName[8] = 0;
memcpy(kickerName, shapeName, strlen(kickerName));
if(strcmp(dribblerName, "Driblador") == 0) {
robot->dribbler->dribblerShapes.push_back(robotShapes[i]);
}
else if(strcmp(kickerName, "Chutador") == 0) {
robot->kicker->kickerShapeDesc = Simulation::copyShapeDesc(robotShapes[i]);
robotActor->releaseShape(*(robotShapes[i]));
}
delete dribblerName;
delete kickerName;
}
}
//Initial Pose
robot->setInitialPose(robotActor->getGlobalPose());
robotActor->putToSleep();
//Mudar pose do robo
//NxQuat q;
//q.
//q.fromAngleAxis(180.0f, NxVec3(0.0f, 1.0f, 0.0f));
//robot->getActor()->setGlobalPose(pose);
//Release no actor importado do 3ds Max
//gScenes[0]->releaseActor(*robotActor);
string label;
string plabel = "Robo";
stringstream out;
out << indexRobot;
out << "-";
out << indexTeam;
//out << "-";
//out << indexScene;
label.append(plabel);
label.append(out.str());
char* arrayLabel = new char[label.size()+1];
arrayLabel[label.size()]=0;
memcpy(arrayLabel, label.c_str(), label.size());
robotActor->setName(arrayLabel);
//delete arrayLabel;
}
}
bool GraphicsClass::Render(float rotation)
{
D3DXMATRIX viewMatrix, projectionMatrix, worldMatrix;
n_scene->simulate(1.0f/60.0f);
// Clear buffers
// Cornflower blue #6495ED :)
//m_D3D->BeginScene(100.0f/255.0f, 149.0f/255.0f, 237.0f/255.0f, 1.0f);
m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
// move it from here!!
// this calculates the ViewMatrix!
m_Camera->Render();
m_Camera->GetViewMatrix(viewMatrix);
m_D3D->GetWorldMatrix(worldMatrix);
m_D3D->GetProjectionMatrix(projectionMatrix);
D3DXMATRIX world_modification;
/*
for(int i = 0; i < m_Models.size(); i++){
world_modification = m_Models[i]->GetWorldTransformationMatrix();
m_Models[i]->Render(m_D3D->GetDeviceContext());
result = m_baseShader->Render(m_D3D->GetDeviceContext(), m_Models[i]->GetIndexCount(), \
worldMatrix * world_modification, viewMatrix, projectionMatrix, m_Models[i]->GetTexture(), m_light->GetDirection(),
m_light->GetDiffuseColor());
if(!result)
{
return false;
}
}
*/
int nb_Actors = n_scene->getNbActors();
NxActor** actors = n_scene->getActors();
while(nb_Actors--)
{
NxActor* actor = *actors++;
if(!actor->userData) continue;
// render current actor
unsigned int model_id = (unsigned int)actor->userData - 1;
NxMat34 w_matrx = actor->getGlobalPose();
w_matrx.getColumnMajor44(world_modification);
m_Models[model_id]->Render(m_D3D->GetDeviceContext());
m_baseShader->Render(m_D3D->GetDeviceContext(), m_Models[model_id]->GetIndexCount(), \
worldMatrix * world_modification, viewMatrix, projectionMatrix, m_Models[model_id]->GetTexture(), m_light->GetDirection(),
m_light->GetDiffuseColor());
}
m_D3D->EndScene();
n_scene->flushStream();
n_scene->fetchResults(NX_RIGID_BODY_FINISHED, true);
return true;
}
void render()
{
static Timer t;
if(!gMyPhysX.isPaused())
{
for (NxU32 i = 0; i < gKinematicActors.size(); i++)
{
NxActor* actor = gKinematicActors[i].actor;
NxVec3 pos = actor->getGlobalPosition();
pos += gKinematicActors[i].vel * 1.f/60.f;
actor->moveGlobalPosition(pos);
}
}
gMyPhysX.simulate(t.elapsed_time());
t.reset();
// Clear buffers
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glColor4f(0.5,0.9,0.5,1.0);
DrawSkyBox(SKYEXTENTS);
drawPlane(SKYEXTENTS);
// Keep physics & graphics in sync
for (NxU32 pass = 0; pass < 2; pass++) {
int nbActors = gMyPhysX.getScene()->getNbActors();
NxActor** actors = gMyPhysX.getScene()->getActors();
actors += nbActors;
while(nbActors--)
{
NxActor* actor = *--actors;
float size;
bool isTrigger = false;
bool isKinematic = actor->isDynamic() && actor->readBodyFlag(NX_BF_KINEMATIC);
NxVec3 color;
NxF32 alpha = 1;
if (actor->isDynamic()) {
if (actor->readBodyFlag(NX_BF_KINEMATIC)) {
color.set(1,0,0);
} else {
color.set(0,1,0);
}
} else {
color.set(0.2f,0.2f,0.2f);
}
if (*(int *)(&actor->userData) < 0)
{
NxI32 triggerNumber = -(*(NxI32 *)(&actor->userData));
NxI32 triggerIndex = triggerNumber - 1;
// This is our trigger
isTrigger = true;
size = 10.0f;
color.z = gNbTouchedBodies[triggerIndex] > 0.5f ? 1.0f:0.0f;
alpha = 0.5f;
if (pass == 0)
continue;
}
else
{
// This is a normal object
size = float(*(int *)(&actor->userData));
if (pass == 1)
continue;
}
float glmat[16];
glPushMatrix();
actor->getGlobalPose().getColumnMajor44(glmat);
glMultMatrixf(glmat);
glColor4f(color.x, color.y, color.z, 1.0f);
glutSolidCube(size*2.0f);
glPopMatrix();
// Handle shadows
if( !isTrigger)
{
glPushMatrix();
const static float ShadowMat[]={ 1,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,1 };
glMultMatrixf(ShadowMat);
glMultMatrixf(glmat);
glDisable(GL_LIGHTING);
glColor4f(0.1f, 0.2f, 0.3f, 1.0f);
glutSolidCube(size*2.0f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glEnable(GL_LIGHTING);
glPopMatrix();
}
}
}
}