MineBoisage::MineBoisage(scene::ISceneNode* parent, scene::ISceneManager* mgr, s32 id, MineProfil * profil, MineBloc * pMineBloc, vector3df vecteurGalerie)
: scene::ISceneNode(parent, mgr, id)
{
m_profil=*profil;
m_pMineBloc=pMineBloc;
m_buffer=NULL;
m_mesh=NULL;
vecteurGalerie.Y=0;
vecteurGalerie.normalize();
vector3df verticale(0.0, 1.0, 0.0);
vector3df vecteurNormal = vecteurGalerie.crossProduct(verticale);
m_buffer = new SMeshBuffer();
m_mesh = new SMesh();
// base du bois gauche :
generateCylinder(10, m_profil.m_s1, m_profil.m_s4, m_buffer,0,false);
generateCylinder(10, m_profil.m_s2, m_profil.m_s3, m_buffer,0,false);
generatePoutre(3.0, m_profil.m_s4, m_profil.m_s3, m_buffer,vecteurGalerie);
/*
// recalculate normals
s32 n = (s32)m_buffer->Indices.size();
for (s32 i=0; i<n-3; i+=3)
{
core::plane3d<f32> p(
m_buffer->Vertices[m_buffer->Indices[i+0]].Pos,
m_buffer->Vertices[m_buffer->Indices[i+1]].Pos,
m_buffer->Vertices[m_buffer->Indices[i+2]].Pos);
p.Normal.normalize();
m_buffer->Vertices[m_buffer->Indices[i+0]].Normal = p.Normal;
m_buffer->Vertices[m_buffer->Indices[i+1]].Normal = p.Normal;
m_buffer->Vertices[m_buffer->Indices[i+2]].Normal = p.Normal;
}
*/
video::IVideoDriver* driver = g_data.driver;
m_buffer->Material.Wireframe = false; //true;
m_buffer->Material.BackfaceCulling = true;
m_buffer->Material.Lighting = true;
m_buffer->Material.EmissiveColor=SColor(255,0,0,0);
m_buffer->Material.AmbientColor=SColor(255,255,255,255);
m_buffer->Material.DiffuseColor=SColor(255,255,255,255);
//m_buffer->Material.NormalizeNormals=true;
m_buffer->Material.FogEnable=false;
m_buffer->Material.MaterialType=EMT_SOLID;
m_buffer->Material.Shininess=0.0f;
m_buffer->Material.Texture1= driver->getTexture("media/wood.jpg");
// m_buffer->recalculateBoundingBox();
setDebugDataVisible(false);
m_mesh->addMeshBuffer(m_buffer);
// m_mesh->recalculateBoundingBox();
// creation de la bbox
Box.reset(m_profil.m_s1);
Box.addInternalPoint(m_profil.m_s2);
Box.addInternalPoint(m_profil.m_s3);
Box.addInternalPoint(m_profil.m_s4);
}
S3DVertex&TrackVertex::makeS3DVertex()
{
static S3DVertex v=S3DVertex();
static vector3df default_normal(1.0,1.0,1.0);
default_normal.normalize();
static vector2df default_texture_coords(0.0,0.0);
v.TCoords=default_texture_coords;
v.Pos=xyz;
v.Color=this->color;
v.Normal=default_normal;
return v;
}
int MineBoisage::generatePoutre(float diameter, vector3df &pt1, vector3df &pt2, SMeshBuffer * buffer, vector3df vecteurGalerie)
{
vecteurGalerie.normalize();
vecteurGalerie*=diameter/2.0f;
int n = buffer->Vertices.size();
// vertices
buffer->Vertices.push_back( makeS3DVertex(pt1+vecteurGalerie, vector3df(0,+diameter/2.0f, 0), dimension2d<f32>(0,1),pt1)); // 0
buffer->Vertices.push_back( makeS3DVertex(pt1+vecteurGalerie, vector3df(0,-diameter/2.0f, 0), dimension2d<f32>(0,0),pt1)); // 1
buffer->Vertices.push_back( makeS3DVertex(pt1-vecteurGalerie, vector3df(0,-diameter/2.0f, 0), dimension2d<f32>(0,1),pt1)); // 2
buffer->Vertices.push_back( makeS3DVertex(pt1-vecteurGalerie, vector3df(0,+diameter/2.0f, 0), dimension2d<f32>(0,0),pt1)); // 3
buffer->Vertices.push_back( makeS3DVertex(pt2+vecteurGalerie, vector3df(0,+diameter/2.0f, 0), dimension2d<f32>(1,1),pt2)); // 4
buffer->Vertices.push_back( makeS3DVertex(pt2+vecteurGalerie, vector3df(0,-diameter/2.0f, 0), dimension2d<f32>(1,0),pt2)); // 5
buffer->Vertices.push_back( makeS3DVertex(pt2-vecteurGalerie, vector3df(0,-diameter/2.0f, 0), dimension2d<f32>(1,1),pt2)); // 6
buffer->Vertices.push_back( makeS3DVertex(pt2-vecteurGalerie, vector3df(0,+diameter/2.0f, 0), dimension2d<f32>(1,0),pt2)); // 7
// indices
pushPoly(buffer, n+0, n+2, n+1);
pushPoly(buffer, n+0, n+3, n+1);
pushPoly(buffer, n+0, n+4, n+7);
pushPoly(buffer, n+0, n+7, n+3);
pushPoly(buffer, n+0, n+1, n+4);
pushPoly(buffer, n+1, n+5, n+4);
pushPoly(buffer, n+5, n+6, n+7);
pushPoly(buffer, n+4, n+5, n+7);
pushPoly(buffer, n+3, n+7, n+2);
pushPoly(buffer, n+7, n+6, n+2);
pushPoly(buffer, n+6, n+1, n+2);
pushPoly(buffer, n+6, n+5, n+1);
return 0;
}
void CSPhysXObject_RigidStatic::getPositionAndRotation(vector3df &pos, vector3df &rot)
{
if (getActor())
{
PxTransform tx = getActor()->getGlobalPose();
pos.set(tx.p.x, tx.p.y, tx.p.z);
PxMat33 mat = PxMat33::PxMat33(tx.q);
irr::core::matrix4 irrM;
irr::f32 fM[16];
fM[0] = mat.column0.x;
fM[1] = mat.column0.y;
fM[2] = mat.column0.z;
fM[4] = mat.column1.x;
fM[5] = mat.column1.y;
fM[6] = mat.column1.z;
fM[8] = mat.column2.x;
fM[9] = mat.column2.y;
fM[10] = mat.column2.z;
irrM.setM(fM);
rot = irrM.getRotationDegrees();
}
}
void CSPhysXObject_Character::addForce(vector3df dir, float force)
{
// if (!m_Controller) return;
// if (!m_Controller->getActor()) return;
dir.normalize();
PxVec3 disp = PxVec3(dir.X, dir.Y, dir.Z) * force;
m_TotalForce += vector3df(disp.x, disp.y, disp.z);
}
void CelestialObject::setOrbit(SpaceObject *parent, const f32 semiMajorAxis, const vector3df orbitCenter, const f32 pitch, const f32 initialOrientation)
{
isOrbiting_ = true;
initialOrientation_ = initialOrientation;
orbitCenter_ = orbitCenter;
parent_ = parent;
fociDistance_ = orbitCenter.getLength ();
semiMajorAxis_ = semiMajorAxis;
eccentricity_ = fociDistance_/semiMajorAxis;
meanAnomaly_ = 2 * parent->getMass()/1000 * PI / sqrt(semiMajorAxis*semiMajorAxis*semiMajorAxis); // Speed is dependant on the gravity and the size of the orbit (a*a*a) (Kepler's law)
}
void ZombieInstance :: Damage(int amount, vector3df force)
{
currentHealth -= amount;
// Brief stun:
ChangeState(IDLE);
timer = amount;
force.normalize();
velocity += force * (amount / 100.0f);
CheckDeath();
}
vector3df IrrWrapper :: RotateVectorAboutVector(vector3df v, vector3df l, float a)
{
float m_L[3][3] ={{ 0, l.Z, -l.Y},
{-l.Z, 0, l.X},
{ l.Y, -l.X, 0}};
float m_LxL[3][3] = {{0,0,0},
{0,0,0},
{0,0,0}};
for(int r = 0; r < 3; r++)
for(int c = 0; c < 3; c++)
for(int i = 0; i < 3; i++)
m_LxL[r][c] += (m_L[r][i] * m_L[i][c]);
for(int r = 0; r < 3; r++)
for(int c = 0; c < 3; c++)
m_LxL[r][c] *= ( (1 - cos(a))/l.getDistanceFromSQ(vector3df(0,0,0)));
float m_L2[3][3]= {{0,0,0},
{0,0,0},
{0,0,0}};
for(int r = 0; r < 3; r++)
for(int c = 0; c < 3; c++)
m_L2[r][c] = m_L[r][c] * sin(a)/l.getDistanceFrom(vector3df(0,0,0));
float m_I[3][3] = {{1,0,0},
{0,1,0},
{0,0,1}};
float m_final[3][3]= {{0,0,0},
{0,0,0},
{0,0,0}};
for(int r = 0; r < 3; r++)
for(int c = 0; c < 3; c++)
m_final[r][c] = m_I[r][c] + m_L2[r][c] + m_LxL[r][c];
vector3df v_output(0,0,0);
v_output.X = v.X * m_final[0][0] +
v.Y * m_final[1][0] +
v.Z * m_final[2][0];
v_output.Y = v.X * m_final[0][1] +
v.Y * m_final[1][1] +
v.Z * m_final[2][1];
v_output.Z = v.X * m_final[0][2] +
v.Y * m_final[1][2] +
v.Z * m_final[2][2];
return v_output;
}
