Spring RTS Engine

Code: Select all

int CLuaUnitScript::TurnVec(lua_State* L)
{
	if (activeScript == NULL) {
	return 0;
	}
//
const int piece = 	luaL_checkint(L, 1) - 1;
const float x_vec=	luaL_checkfloat(L, 2);
const float y_vec=	luaL_checkfloat(L, 3);
const float z_vec=	luaL_checkfloat(L, 4);
const float xspeed=	luaL_checkfloat(L, 5);
const float yspeed=	luaL_checkfloat(L, 6);
const float zspeed=	luaL_checkfloat(L, 7);
const float zspeed=	luaL_checkfloat(L, 7);

const float destx =GetHeadingFromVector(1,x_vec);
const float desty =GetHeadingFromVector(1,y_vec);
const float destz =GetHeadingFromVector(1,z_vec);

	if (yspeed == 0.0f || yspeed==0.0f || zspeed== 0.0f)
	{
	activeScript->TurnNow(piece, 1, destx);
	activeScript->TurnNow(piece, 2, desty);
	activeScript->TurnNow(piece, 3, destz);
	}

	if (lua_isboolean(L, 8) && lua_toboolean(L, 8)) {
	// CUnit* unit = activeScript->GetUnit();
	// LocalModel* model = unit->localModel;
	LocalModelPiece* piece = ParseLocalModelPiece(L, activeScript, __FUNCTION__);

	// note:
	// both of these only have effect if MoveNow() was called, but
	// the former starts from the ROOT piece (less efficient here)
	// model->UpdatePieceMatrices();
	piece->UpdateMatricesRec(true);
	}

return 0;

}

Code: Select all

static int TurnVec(lua_State* L);

Code: Select all

//Creates a new Matrix that rotates piece around an arbitrary vector.
void Spring.UnitPieceLookAt(const vector3& dir, const vector3& up, matrix33& m) { 
        vector3 z(dir); 
        z.norm(); 
        vector3 x( up * z ); // x = up cross z 
        x.norm(); 
        vector3 y( z * x ); // y = z cross x 
        m.set_components(x,y,z ); 
} 

Code: Select all

bool LocalModelPiece::UpdateMatrix()
{
	return (original->ComposeTransform(pieceSpaceMat.LoadIdentity(), pos, rot, original->scales));
}

Code: Select all

struct S3DModelPiece {
....
CMatrix44f& ComposeRotation(CMatrix44f& m, const float3& r) const {
		// execute rotations in YPR order by default
		// note: translating + rotating is faster than
		// matrix-multiplying (but the branching hurts)
                switch (axisMapType) {
			case AXIS_MAPPING_XYZ: {
				if (r.y != 0.0f) { m.RotateY(r.y * rotAxisSigns.y); } // yaw
				if (r.x != 0.0f) { m.RotateX(r.x * rotAxisSigns.x); } // pitch
				if (r.z != 0.0f) { m.RotateZ(r.z * rotAxisSigns.z); } // roll

Code: Select all

enum AnimType {ANone = -1, ATurn = 0, ASpin = 1, AMove = 2};

void CUnitScript::TickAnims(int deltaTime, AnimType type, std::list< std::list<AnimInfo*>::iterator >& doneAnims) {
	switch (type) {
		case AMove: {
			for (std::list<AnimInfo*>::iterator it = anims[type].begin(); it != anims[type].end(); ++it) {
				AnimInfo* ai = *it;

				// NOTE: we should not need to copy-and-set here, because
				// MoveToward/TurnToward/DoSpin modify pos/rot by reference
				float3 pos = pieces[ai->piece]->GetPosition();

				if (MoveToward(pos[ai->axis], ai->dest, ai->speed / (1000 / deltaTime))) {
					ai->done = true; doneAnims.push_back(it);
				}

				pieces[ai->piece]->SetPosition(pos);
				unit->localModel->PieceUpdated(ai->piece);
			}
		} break;

		case ATurn: {
			for (std::list<AnimInfo*>::iterator it = anims[type].begin(); it != anims[type].end(); ++it) {
				AnimInfo* ai = *it;
				float3 rot = pieces[ai->piece]->GetRotation();

				if (TurnToward(rot[ai->axis], ai->dest, ai->speed / (1000 / deltaTime))) {
					ai->done = true; doneAnims.push_back(it);
				}

				pieces[ai->piece]->SetRotation(rot);
				unit->localModel->PieceUpdated(ai->piece);
			}
		} break;

		case ASpin: {
			for (std::list<AnimInfo*>::iterator it = anims[type].begin(); it != anims[type].end(); ++it) {
				AnimInfo* ai = *it;
				float3 rot = pieces[ai->piece]->GetRotation();

				if (DoSpin(rot[ai->axis], ai->dest, ai->speed, ai->accel, 1000 / deltaTime)) {
					ai->done = true; doneAnims.push_back(it);
				}

				pieces[ai->piece]->SetRotation(rot);
				unit->localModel->PieceUpdated(ai->piece);
			}
		} break;

		default: {
		} break;
	}
}

Code: Select all

enum AnimType {ANone = -1, ATurn = 0, ASpin = 1, AMove = 2, ASwing = 3};

struct AnimInfo {
		AnimType type;
		int axis;
		int piece;
		float speed;
		float dest;           // means final position when turning or moving, final speed when spinning
		float accel;            // used for spinning, can be negative
               vector3 target;         // use for swing
		bool done;
		std::list<IAnimListener*> listeners;
	};
...



....
                 /*The purpose of the swing motion is to orientate the piece limb in a prescribed direction
given by a unit vector 

To transform the z vector into the d vector, a rotation matrix
must be defined.

 Do not interpolate matrices
 tR1 + (1-t)R2 is not a rotation!*/

		case ASwing {
			for (std::list<AnimInfo*>::iterator it = anims[type].begin(); it != anims[type].end(); ++it) {
				AnimInfo* ai = *it;
				
                                Matrix4x4 rot = pieces[ai->piece]->GetRotationMatrix();

				if (SwingToward(ai->target)) {
					ai->done = true; doneAnims.push_back(it);
				}

				pieces[ai->piece]->SetRotationMatrix(rot);
				unit->localModel->PieceUpdated(ai->piece);
			}
		} break;

Code: Select all

/**
 * @brief Updates Swing animation, used to rotate object about rotationAxis by rotationAngle
 * @param dest vector3 target
 * @return returns true if destination was reached, false otherwise
 */
bool CUnitScript::SwingToward(vector3 )
{

...considerations...

Left or right handed coordinate system?
Vector shown as row or column ?
Matrix order?
Direction of x,y and z coordinates?
Euler angle order?
Direction of positive angles?
Choice of basis?

...

}

Code: Select all

if walking
  calculate_ik()
  apply_rotations()
end