void psLinearMovement::SetPosition (const csVector3& pos, float yrot,
const iSector* sector)
{
if (!sector)
{
StackTrace("Setting position without sector");
}
// Debug4(LOG_CELPERSIST,0,"DEBUG: psLinearMovement::SetPosition %s current transform: %s scale %f \n", mesh->QueryObject()->GetName(), mesh->GetMovable()->GetTransform().Description().GetData(),scale);
// Position and Sector
mesh->GetMovable ()->SetPosition ((iSector *)sector,pos);
// at first loading scale may not be yet set
if (scale>0) {
// Rotation and scale
csMatrix3 rotMatrix = (csMatrix3) csYRotMatrix3 (yrot);
csMatrix3 scaleMatrix = csMatrix3 (1/scale,0,0, 0,1/scale,0, 0,0,1/scale);
mesh->GetMovable ()->GetTransform ().SetO2T (scaleMatrix*rotMatrix);
} else {
// Rotation only
csMatrix3 rotMatrix = (csMatrix3) csYRotMatrix3 (yrot);
mesh->GetMovable ()->GetTransform ().SetO2T (rotMatrix);
}
mesh->GetMovable ()->UpdateMove ();
}
void psGameObject::SetRotationAngle(gemNPCObject* object, float angle)
{
npcMesh * pcmesh = object->pcmesh;
csMatrix3 matrix = (csMatrix3) csYRotMatrix3 (angle);
pcmesh->GetMesh()->GetMovable()->GetTransform().SetO2T (matrix);
}
bool GenmeshAsset::SetSocketTransform(const char* socketName, const SocketDescriptor& desc)
{
iSkeletonSocket* sock = skeleton->FindSocket (socketName);
if (!sock) return false;
sock->GetFactory()->SetName(desc.find("Name")->second.second.c_str());
iSkeletonBone* bone = skeleton->FindBone(desc.find("Bone")->second.second.c_str());
if (bone) sock->SetBone(bone);
csVector3 offset;
if (sscanf(desc.find("Offset")->second.second.c_str(), "%f, %f, %f", &offset[0], &offset[1], &offset[2]) != 3)
return false;
csReversibleTransform trans = sock->GetTransform();
trans.SetOrigin(offset);
sock->SetTransform(trans);
csVector3 rot;
if (sscanf(desc.find("Rotation")->second.second.c_str(), "%f, %f, %f", &rot[0], &rot[1], &rot[2]) != 3)
return false;
csReversibleTransform transr = sock->GetTransform();
csMatrix3 m;
m *= csXRotMatrix3 (rot.x);
m *= csYRotMatrix3 (rot.y);
m *= csZRotMatrix3 (rot.z);
transr.SetO2T(m);
sock->SetTransform(transr);
return true;
}
void psCharAppearance::ProcessAttach(csRef<iMeshWrapper> meshWrap, csRef<iSpriteCal3DSocket> socket)
{
if(!socket.IsValid())
return;
CS_ASSERT(socket.IsValid());
meshWrap->GetFlags().Set(CS_ENTITY_NODECAL);
const char* socketName = socket->GetName();
// Given a socket name of "righthand", we're looking for a key in the form of "socket_righthand"
csString keyName = "socket_";
keyName += socketName;
// Variables for transform to be specified
float trans_x = 0, trans_y = 0.0, trans_z = 0, rot_x = -PI/2, rot_y = 0, rot_z = 0;
csRef<iObjectIterator> it = meshWrap->GetFactory()->QueryObject()->GetIterator();
while ( it->HasNext() )
{
csRef<iKeyValuePair> key ( scfQueryInterface<iKeyValuePair> (it->Next()));
if (key && keyName == key->GetKey())
{
sscanf(key->GetValue(),"%f,%f,%f,%f,%f,%f",&trans_x,&trans_y,&trans_z,&rot_x,&rot_y,&rot_z);
}
}
meshWrap->QuerySceneNode()->SetParent( baseMesh->QuerySceneNode ());
socket->SetMeshWrapper( meshWrap );
socket->SetTransform( csTransform(csZRotMatrix3(rot_z)*csYRotMatrix3(rot_y)*csXRotMatrix3(rot_x), csVector3(trans_x,trans_y,trans_z)) );
usedSlots.PushSmart(socketName);
}
csMeshGenerator::csMeshGenerator (csEngine* engine) :
scfImplementationType (this), total_max_dist (-1.0f), minRadius(-1.0f),
use_alpha_scaling (false),
last_pos (0, 0, 0), setup_cells (false),
cell_dim (50), inuse_blocks (0), inuse_blocks_last (0),
max_blocks (100), engine (engine)
{
default_density_factor = 1.0f;
cells = new csMGCell [cell_dim * cell_dim];
for (size_t i = 0 ; i < size_t (max_blocks) ; i++)
cache_blocks.Push (new csMGPositionBlock ());
prev_cells.MakeEmpty ();
for (size_t i = 0 ; i < CS_GEOM_MAX_ROTATIONS ; i++)
{
rotation_matrices[i] = csYRotMatrix3 (2.0f*PI * float (i)
/ float (CS_GEOM_MAX_ROTATIONS));
}
alpha_priority = engine->GetAlphaRenderPriority ();
object_priority = engine->GetObjectRenderPriority ();
strings = csQueryRegistryTagInterface<iStringSet> (
engine->objectRegistry, "crystalspace.shared.stringset");
SVstrings = csQueryRegistryTagInterface<iShaderVarStringSet> (
engine->objectRegistry, "crystalspace.shader.variablenameset");
varInstancesNum = SVstrings->Request ("instances num");
varTransform = SVstrings->Request ("instancing transforms");
varFadeInfo = SVstrings->Request ("meshgen fade info");
varInstanceExtra = SVstrings->Request ("instance extra");
varWindData = SVstrings->Request ("wind data");
}
void psLinearMovement::SetYRotation( float yrot )
{
// Rotation
csMatrix3 matrix = (csMatrix3) csYRotMatrix3 (yrot);
mesh->GetMovable ()->GetTransform ().SetO2T (matrix);
mesh->GetMovable ()->UpdateMove ();
}
void Simple::Frame ()
{
// First get elapsed time from the virtual clock.
csTicks elapsed_time = vc->GetElapsedTicks ();
// Now rotate the camera according to keyboard state
float speed = (elapsed_time / 1000.0) * (0.06 * 20);
iCamera* c = view->GetCamera();
if (kbd->GetKeyState (CSKEY_SHIFT))
{
// If the user is holding down shift, the arrow keys will cause
// the camera to strafe up, down, left or right from it's
// current position.
if (kbd->GetKeyState (CSKEY_RIGHT))
c->Move (CS_VEC_RIGHT * 4 * speed);
if (kbd->GetKeyState (CSKEY_LEFT))
c->Move (CS_VEC_LEFT * 4 * speed);
if (kbd->GetKeyState (CSKEY_UP))
c->Move (CS_VEC_UP * 4 * speed);
if (kbd->GetKeyState (CSKEY_DOWN))
c->Move (CS_VEC_DOWN * 4 * speed);
}
else
{
// left and right cause the camera to rotate on the global Y
// axis; page up and page down cause the camera to rotate on the
// _camera's_ X axis (more on this in a second) and up and down
// arrows cause the camera to go forwards and backwards.
if (kbd->GetKeyState (CSKEY_RIGHT))
rotY += speed;
if (kbd->GetKeyState (CSKEY_LEFT))
rotY -= speed;
if (kbd->GetKeyState (CSKEY_PGUP))
rotX += speed;
if (kbd->GetKeyState (CSKEY_PGDN))
rotX -= speed;
if (kbd->GetKeyState (CSKEY_UP))
c->Move (CS_VEC_FORWARD * 4 * speed);
if (kbd->GetKeyState (CSKEY_DOWN))
c->Move (CS_VEC_BACKWARD * 4 * speed);
}
// We now assign a new rotation transformation to the camera. You
// can think of the rotation this way: starting from the zero
// position, you first rotate "rotY" radians on your Y axis to get
// the first rotation. From there you rotate "rotX" radians on the
// your X axis to get the final rotation. We multiply the
// individual rotations on each axis together to get a single
// rotation matrix. The rotations are applied in right to left
// order .
csMatrix3 rot = csXRotMatrix3 (rotX) * csYRotMatrix3 (rotY);
csOrthoTransform ot (rot, c->GetTransform().GetOrigin ());
c->SetTransform (ot);
rm->RenderView (view);
}
void psLinearMovement::SetPosition (const csVector3& pos, float yrot,
const iSector* sector)
{
// Position and Sector
mesh->GetMovable ()->SetPosition ((iSector *)sector,pos);
// Rotation
csMatrix3 matrix = (csMatrix3) csYRotMatrix3 (yrot);
mesh->GetMovable ()->GetTransform ().SetO2T (matrix);
mesh->GetMovable ()->UpdateMove ();
}
void psLinearMovement::SetFullPosition (const csVector3& pos, float yrot,
const iSector* sector)
{
// Position
csVector3 newpos;
newpos = pos;
mesh->GetMovable ()->SetPosition ((iSector *)sector, newpos);
// Rotation
csMatrix3 matrix = (csMatrix3) csYRotMatrix3 (yrot);
// @@@ Not correct if anchor is transformed!!!
mesh->GetMovable ()->GetTransform ().SetO2T (matrix);
// Sector
mesh->GetMovable ()->UpdateMove ();
}
csRef<iMeshWrapper> DynamicsDebugger::CreateCapsuleMesh (float length, float radius,
iMaterialWrapper* material, csOrthoTransform transform,
iSector* sector)
{
// Find the pointer to the engine plugin
csRef<iEngine> engine = csQueryRegistry<iEngine> (manager->object_reg);
if (!engine)
{
manager->Report (CS_REPORTER_SEVERITY_ERROR,
"No iEngine plugin!");
return 0;
}
// Create the capsule mesh factory.
csRef<iMeshFactoryWrapper> capsuleFact =
engine->CreateMeshFactory ("crystalspace.mesh.object.genmesh",
"capsuleFact");
if (capsuleFact == 0)
{
manager->Report (CS_REPORTER_SEVERITY_ERROR,
"Error creating capsule mesh factory!");
return 0;
}
// Generate the capsule topology
csRef<iGeneralFactoryState> gmstate = scfQueryInterface<iGeneralFactoryState>
(capsuleFact->GetMeshObjectFactory ());
gmstate->GenerateCapsule (length, radius, 10);
csReversibleTransform centerTransform (csYRotMatrix3 (PI/2), csVector3 (0));
capsuleFact->HardTransform (centerTransform * transform);
// Create the mesh.
csRef<iMeshWrapper> mesh (engine->CreateMeshWrapper (capsuleFact, "capsule",
sector));
mesh->GetMeshObject ()->SetMaterialWrapper (material);
return mesh;
}
csVector3 psWorld::Matrix2Rot(const csMatrix3 &mat)
{
csVector3 rot(0);
// obtain yaw
csVector3 vec(0,1,0);
vec = mat * vec;
rot.z = acos(vec.y);
// obtain roll
rot.y = atan2(vec.z/sin(rot.z), -vec.x/sin(rot.z));
// obtain pitch
vec = mat * csVector3(0,0,1);
vec = csZRotMatrix3(-rot.z) * csYRotMatrix3(-rot.y) * vec; // reverse roll and yaw here to ease our job
rot.x = atan2(vec.x, vec.z);
// force results in [0;2*PI] range
rot.x = rot.x < 0 ? rot.x + TWO_PI : rot.x;
rot.y = rot.y < 0 ? rot.y + TWO_PI : rot.y;
rot.z = rot.z < 0 ? rot.z + TWO_PI : rot.z;
return rot;
}
bool AnimeshAsset::SetSocketTransform(const char* socketName, const SocketDescriptor& desc)
{
uint sockf = animeshsprite->FindSocket(socketName);
if (sockf == (uint)~0) return false;
CS::Mesh::iAnimatedMeshSocket* sock = animeshstate->GetSocket(sockf);
if (!sock) return false;
sock->GetFactory()->SetName(desc.find("Name")->second.second.c_str());
int bone;
sscanf(desc.find("Bone")->second.second.c_str(), "%d", &bone);
sock->GetFactory()->SetBone(bone);
csVector3 offset;
if (sscanf(desc.find("Offset")->second.second.c_str(), "%f, %f, %f", &offset[0], &offset[1], &offset[2]) != 3)
return false;
//csReversibleTransform trans = sock->GetFactory()->GetTransform();
csReversibleTransform trans = sock->GetTransform();
trans.SetOrigin(offset);
//sock->GetFactory()->SetTransform(trans);
sock->SetTransform(trans);
csVector3 rot;
if (sscanf(desc.find("Rotation")->second.second.c_str(), "%f, %f, %f", &rot[0], &rot[1], &rot[2]) != 3)
return false;
//csReversibleTransform transr = sock->GetFactory()->GetTransform();
csReversibleTransform transr = sock->GetTransform();
csMatrix3 m;
m *= csXRotMatrix3 (rot.x);
m *= csYRotMatrix3 (rot.y);
m *= csZRotMatrix3 (rot.z);
transr.SetO2T(m);
//sock->GetFactory()->SetTransform(transr);
sock->SetTransform(transr);
return true;
}
void psCharAppearance::ApplyRider(csRef<iMeshWrapper> mesh)
{
csRef<iSpriteCal3DState> mountstate = scfQueryInterface<iSpriteCal3DState> (mesh->GetMeshObject());
csRef<iSpriteCal3DSocket> socket = mountstate->FindSocket( "back" );
if ( !socket )
{
Error1("Socket back not found.");
return;
}
baseMesh->GetFlags().Set(CS_ENTITY_NODECAL);
const char* socketName = socket->GetName();
// Given a socket name of "righthand", we're looking for a key in the form of "socket_righthand"
csString keyName = "socket_";
keyName += socketName;
// Variables for transform to be specified
float trans_x = 0, trans_y = 0.0, trans_z = 0, rot_x = -PI/2, rot_y = 0, rot_z = 0;
csRef<iObjectIterator> it = baseMesh->GetFactory()->QueryObject()->GetIterator();
while ( it->HasNext() )
{
csRef<iKeyValuePair> key ( scfQueryInterface<iKeyValuePair> (it->Next()));
if (key && keyName == key->GetKey())
{
sscanf(key->GetValue(),"%f,%f,%f,%f,%f,%f",&trans_x,&trans_y,&trans_z,&rot_x,&rot_y,&rot_z);
}
}
baseMesh->QuerySceneNode()->SetParent( mesh->QuerySceneNode ());
socket->SetMeshWrapper( baseMesh );
socket->SetTransform( csTransform(csZRotMatrix3(rot_z)*csYRotMatrix3(rot_y)*csXRotMatrix3(rot_x), csVector3(trans_x,trans_y,trans_z)) );
}
bool psEffectObj::Update(csTicks elapsed)
{
if (!anchor || !anchor->IsReady() || !anchorMesh->GetMovable()->GetSectors()->GetCount()) // wait for anchor to be ready
return true;
const static csMatrix3 UP_FIX(1,0,0, 0,0,1, 0,1,0);
const static csMatrix3 billboardFix = csXRotMatrix3(-3.14f/2.0f);
iMovable* anchorMovable = anchorMesh->GetMovable();
iMovable* meshMovable = mesh->GetMovable();
csVector3 anchorPosition = anchorMovable->GetFullPosition();
life += elapsed;
if (life > animLength && killTime <= 0)
{
life %= animLength;
if (!life)
{
life += animLength;
}
}
isAlive |= (life >= birth);
if (isAlive)
{
meshMovable->SetSector(anchorMovable->GetSectors()->Get(0));
meshMovable->SetPosition(anchorPosition);
if (dir == DT_NONE)
{
matBase = anchorMovable->GetFullTransform().GetT2O();
}
}
csMatrix3 matTransform;
if (keyFrames->GetSize() == 0)
{
if (dir == DT_CAMERA)
{
// note that this is *very* expensive
csVector3 camDir = -view->GetCamera()->GetTransform().GetO2TTranslation()
+ anchorPosition;
csReversibleTransform rt;
rt.LookAt(camDir, csVector3(0.f,1.f,0.f));
matBase = rt.GetT2O() * UP_FIX;
}
else if (dir == DT_BILLBOARD)
{
matBase = view->GetCamera()->GetTransform().GetT2O() * billboardFix;
}
baseScale = scale;
matTransform = matBase / baseScale;
}
else
{
currKeyFrame = FindKeyFrameByTime(life);
nextKeyFrame = (currKeyFrame + 1) % keyFrames->GetSize();
// grab and lerp values - expensive
float lerpfactor = LERP_FACTOR;
csVector3 lerpRot = LERP_VEC_KEY(KA_ROT,lerpfactor);
csVector3 lerpSpin = LERP_VEC_KEY(KA_SPIN,lerpfactor);
csVector3 objOffset = LERP_VEC_KEY(KA_POS,lerpfactor);
// calculate rotation from lerped values - expensive
csMatrix3 matRot = csZRotMatrix3(lerpRot.z) * csYRotMatrix3(lerpRot.y) * csXRotMatrix3(lerpRot.x);
if (dir != DT_CAMERA && dir != DT_BILLBOARD)
{
matRot *= matBase;
}
// calculate new position
csVector3 newPos = matRot * csVector3(-objOffset.x, objOffset.y, -objOffset.z);
if (dir == DT_CAMERA)
{
// note that this is *very* expensive - again
csVector3 camDir = -view->GetCamera()->GetTransform().GetO2TTranslation()
+ anchorPosition + newPos;
csReversibleTransform rt;
rt.LookAt(camDir, csVector3(sinf(lerpSpin.y),cosf(lerpSpin.y),0.f));
matBase = rt.GetT2O() * UP_FIX;
newPos = rt.GetT2O() * newPos;
// rotate and spin should have no effect on the transform when we want it to face the camera
matTransform = matBase;
}
else if (dir == DT_BILLBOARD)
{
matBase = view->GetCamera()->GetTransform().GetT2O() * billboardFix;
matTransform = matBase;
}
else
{
matTransform = matRot;
matTransform *= csZRotMatrix3(lerpSpin.z) * csYRotMatrix3(lerpSpin.y) * csXRotMatrix3(lerpSpin.x);
}
// SCALE
baseScale = LERP_KEY(KA_SCALE,lerpfactor) * scale;
matTransform /= baseScale;
// adjust position
meshMovable->SetPosition(anchorPosition+newPos);
}
// set new transform
meshMovable->SetTransform(matTransform);
meshMovable->UpdateMove();
if (killTime > 0)
{
killTime -= elapsed;
if (killTime <= 0)
return false;
}
return true;
}
