bool CBuzzControllerSpiri::Land() { CVector3 cPos = m_pcPosition->GetReading().Position; if(Abs(cPos.GetZ()) < 0.01f) return false; cPos.SetZ(0.0f); m_pcPropellers->SetAbsolutePosition(cPos); return true; }
QString MyLineEdit::GetDefault() { if (parameterContainer && !gotDefault) { QString type = GetType(objectName()); if (type == QString("vect3")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector3 val = parameterContainer->GetDefault<CVector3>(nameVect); QString valS = QString::number(val.itemByName(lastChar), 'g', 16); defaultText = valS; gotDefault = true; } else { QString val = parameterContainer->GetDefault<QString>(parameterName); defaultText = val; gotDefault = true; } QString toolTipText; toolTipText += "Name: " + parameterName + "\n"; toolTipText += "Default: " + defaultText; setToolTip(toolTipText); } return defaultText; }
QString MyLineEdit::GetDefault() { if (parameterContainer && !gotDefault) { QString type = GetType(objectName()); if (type == QString("vect3") || type == QString("logvect3")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector3 val = parameterContainer->GetDefault<CVector3>(nameVect); QString valS = QString("%L1").arg(val.itemByName(lastChar), 0, 'g', 16); defaultText = valS; gotDefault = true; } else if (type == QString("vect4") || type == QString("logvect3")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector4 val = parameterContainer->GetDefault<CVector4>(nameVect); QString valS = QString("%L1").arg(val.itemByName(lastChar), 0, 'g', 16); defaultText = valS; gotDefault = true; } else { QString val = parameterContainer->GetDefault<QString>(parameterName); defaultText = val; gotDefault = true; } setToolTipText(); } return defaultText; }
double MyDoubleSpinBox::GetDefault() { if (parameterContainer && !gotDefault) { QString type = GetType(objectName()); if (type == QString("spinbox3") || type == QString("spinboxd3")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector3 val = parameterContainer->GetDefault<CVector3>(nameVect); defaultValue = val.itemByName(lastChar); gotDefault = true; } else if (type == QString("spinbox4") || type == QString("spinboxd4")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector4 val = parameterContainer->GetDefault<CVector4>(nameVect); defaultValue = val.itemByName(lastChar); gotDefault = true; } else { defaultValue = parameterContainer->GetDefault<double>(parameterName); gotDefault = true; } QString toolTipText = toolTip(); toolTipText += "\nParameter name: " + parameterName + "<br>"; toolTipText += "Default: " + QString("%L1").arg(defaultValue, 0, 'g', 16); setToolTip(toolTipText); } return defaultValue; }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : void SetPosition(const CVector3& position) // // - Purpose : Sets matrix's position values. // // ----------------------------------------------------------------------------- void CMatrix::SetPosition(const CVector3& position) { m_fM[0][3] = position.X(); m_fM[1][3] = position.Y(); m_fM[2][3] = position.Z(); }
double MyDoubleSpinBox::GetDefault() { if (parameterContainer && !gotDefault) { QString type = GetType(objectName()); if (type == QString("spinbox3") || type == QString("spinboxd3")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector3 val = parameterContainer->GetDefault<CVector3>(nameVect); defaultValue = val.itemByName(lastChar); gotDefault = true; setToolTipText(); } else if (type == QString("spinbox4") || type == QString("spinboxd4")) { char lastChar = (parameterName.at(parameterName.length() - 1)).toLatin1(); QString nameVect = parameterName.left(parameterName.length() - 2); CVector4 val = parameterContainer->GetDefault<CVector4>(nameVect); defaultValue = val.itemByName(lastChar); gotDefault = true; setToolTipText(); } else { defaultValue = parameterContainer->GetDefault<double>(parameterName); gotDefault = true; setToolTipText(); } } return defaultValue; }
void CRABEquippedEntity::Update() { CVector3 cPos = m_cPosOffset; cPos.Rotate(m_psAnchor->Orientation); cPos += m_psAnchor->Position; SetPosition(cPos); SetOrientation(m_psAnchor->Orientation * m_cRotOffset); }
VoronoiDiagram::Point VoronoiDiagram::ToPoint(const CVector3& vec) const { VoronoiDiagram::Point point; /* Assuming that Vector have meter values */ point.set(HORIZONTAL, vec.GetX()*scaleVectorToMilimeters); point.set(VERTICAL, vec.GetY()*scaleVectorToMilimeters); return point; }
CVector3 CVector3::RotateAroundVectorByAngle(CVector3 axis, double angle) { CVector3 vector = *this * cos(angle); vector += (axis.Cross(*this)) * sin(angle); vector += axis * axis.Dot(*this) * (1 - cos(angle)); return vector; }
sRGBAfloat cRenderWorker::EnvMapping(const sShaderInputData &input) { sRGBAfloat envReflect; CVector3 reflect; double dot = -input.viewVector.Dot(input.normal); reflect = input.normal * 2.0 * dot + input.viewVector; double alphaTexture = reflect.GetAlpha() + M_PI; double betaTexture = reflect.GetBeta(); double texWidth = data->textures.envmapTexture.Width(); double texHeight = data->textures.envmapTexture.Height(); if (betaTexture > 0.5 * M_PI) betaTexture = 0.5 * M_PI - betaTexture; if (betaTexture < -0.5 * M_PI) betaTexture = -0.5 * M_PI + betaTexture; double dtx = (alphaTexture / (2.0 * M_PI)) * texWidth + texWidth * 8.25; double dty = (betaTexture / (M_PI) + 0.5) * texHeight + texHeight * 8.0; dtx = fmod(dtx, texWidth); dty = fmod(dty, texHeight); if (dtx < 0) dtx = 0; if (dty < 0) dty = 0; envReflect.R = data->textures.envmapTexture.Pixel(dtx, dty).R / 256.0; envReflect.G = data->textures.envmapTexture.Pixel(dtx, dty).G / 256.0; envReflect.B = data->textures.envmapTexture.Pixel(dtx, dty).B / 256.0; return envReflect; }
bool CDynamics3DEntity::MoveTo(const CVector3& c_position, const CQuaternion& c_orientation, bool b_check_only) { /* Move the body to the new position */ dBodySetPosition(m_tBody, c_position.GetX(), c_position.GetY(), c_position.GetZ()); /* Rotate the body to the new orientation */ dQuaternion tQuat = { c_orientation.GetW(), c_orientation.GetX(), c_orientation.GetY(), c_orientation.GetZ() }; dBodySetQuaternion(m_tBody, tQuat); /* Check for collisions */ bool bCollisions = m_cEngine.IsEntityColliding(m_tEntitySpace); if(bCollisions || b_check_only) { /* * Undo the changes if there is a collision or * if the move was just a check */ const CVector3& cPosition = GetEmbodiedEntity().GetPosition(); dBodySetPosition(m_tBody, cPosition.GetX(), cPosition.GetY(), cPosition.GetZ()); const CQuaternion& cOrientation = GetEmbodiedEntity().GetOrientation(); dQuaternion tQuat2 = { cOrientation.GetW(), cOrientation.GetX(), cOrientation.GetY(), cOrientation.GetZ() }; dBodySetQuaternion(m_tBody, tQuat2); return !bCollisions; } else { /* Set the new position and orientation */ GetEmbodiedEntity().SetPosition(c_position); GetEmbodiedEntity().SetOrientation(c_orientation); return true; } }
bool CDynamics3DEntity::CheckIntersectionWithRay(Real& f_t_on_ray, const CRay& c_ray) const { /* Create an ODE ray from ARGoS ray */ Real fRayLength = c_ray.GetLength(); dGeomID tRay = dCreateRay(m_cEngine.GetSpaceID(), fRayLength); CVector3 cDirection; c_ray.GetDirection(cDirection); dGeomRaySet(tRay, c_ray.GetStart().GetX(), c_ray.GetStart().GetY(), c_ray.GetStart().GetZ(), cDirection.GetX(), cDirection.GetY(), cDirection.GetZ()); /* Create the structure to contain info about the possible ray/geom intersection */ dContactGeom tIntersection; /* Check for intersection between the ray and the object local space */ if(dCollide(tRay, reinterpret_cast<dGeomID>(m_tEntitySpace), 1, &tIntersection, sizeof(dContactGeom)) > 0) { /* There is an intersecton */ f_t_on_ray = tIntersection.depth / fRayLength; return true; } else { /* No intersection detected */ return false; } }
void CDynamics2DEngine::PositionPhysicsToSpace(CVector3& c_new_pos, const CVector3& c_original_pos, const cpBody* pt_body) { c_new_pos.SetX(pt_body->p.x); c_new_pos.SetY(pt_body->p.y); c_new_pos.SetZ(c_original_pos.GetZ()); }
bool CPlane::Intersects(Real& f_t_on_ray, const CRay3& c_ray) { /* Ray direction */ CVector3 cRayDir; c_ray.GetDirection(cRayDir); /* Calculate f_t_on_ray */ Real fNumerator = (m_cPosition-c_ray.GetStart()).DotProduct(m_cNormal); Real fDenominator = cRayDir.DotProduct(m_cNormal); /* Is ray parallel to plane? */ if(Abs(fDenominator) > 1e-6) { /* No, it's not */ f_t_on_ray = fNumerator / fDenominator / c_ray.GetLength(); return (f_t_on_ray < 1.0f); } else { /* Yes, it is */ /* Is ray coincident with the plane? */ if(Abs(fNumerator) > 1e-6) { /* No, the ray is parallel to and far from the plane */ /* No intersection possible */ return false; } else { /* Yes, the ray coincides with the plane */ f_t_on_ray = 0.0f; return true; } } }
unsigned int CBspMapMeshProvider::FindLeaf(const CVector3& searchPosition) const { int32 index = 0; const Bsp::NodeArray& nodes(m_bspFile->GetNodes()); const Bsp::PlaneArray& planes(m_bspFile->GetPlanes()); while(index >= 0) { const Bsp::NODE& node = nodes[index]; const Bsp::PLANE& plane = planes[node.plane]; CVector3 planeNormal = Bsp::ConvertToAthenaCoord(plane.normal); float distance = planeNormal.Dot(searchPosition) - plane.distance; if(distance >= 0) { index = node.children[0]; } else { index = node.children[1]; } } return -index - 1; }
void CGround::Update() { CVector3 pos; pos.Set(0.0f, -0.5f, 0.0f); m_box.SetPosition(pos); m_box.UpdateWorldMatrix(); }
bool CPalet::detectionCollision(CVector3 *_poPosBoule, int *i) { CVector3 positionObjet; this->getPosition(&positionObjet); float ys=_poPosBoule->fGetY(); float yc=positionObjet.fGetY(); float zs=_poPosBoule->fGetZ(); float zc=positionObjet.fGetZ(); float L=2*scale->fGetY()*0.4; float l=2*scale->fGetZ()*1.2; Rectangle rect(yc,zc,L+0.3,l+0.3); if (rect.contains(ys,zs)) { if (fabs(ys-yc)<((l/2))) { *i=0; } else { *i=1; } return true; } return false; }
CRABEquippedEntity::CRABEquippedEntity(CComposableEntity* pc_parent, const std::string& str_id, size_t un_msg_size, Real f_range, const SAnchor& s_anchor, CEmbodiedEntity& c_entity_body, const CVector3& c_pos_offset, const CQuaternion& c_rot_offset) : CPositionalEntity(pc_parent, str_id), m_psAnchor(&s_anchor), m_cPosOffset(c_pos_offset), m_cRotOffset(c_rot_offset), m_cData(un_msg_size), m_fRange(f_range), m_pcEntityBody(&c_entity_body) { Disable(); SetCanBeEnabledIfDisabled(false); CVector3 cPos = c_pos_offset; cPos.Rotate(s_anchor.Orientation); cPos += s_anchor.Position; SetInitPosition(cPos); SetPosition(cPos); SetInitOrientation(s_anchor.Orientation * c_rot_offset); SetOrientation(GetInitOrientation()); }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : void Transform(CPlane* plane) // // - Purpose : Transforms a plane. // // ----------------------------------------------------------------------------- void CMatrix::Transform(CPlane* plane) const { CVector3 planePoint; // Get a point of the plane: if(IS_ZERO(plane->A()) == false) { planePoint.Set(-plane->D() / plane->A(), 0.0f, 0.0f); } else if(IS_ZERO(plane->B()) == false) { planePoint.Set(0.0f, -plane->D() / plane->B(), 0.0f); } else if(IS_ZERO(plane->C()) == false) { planePoint.Set(0.0f, 0.0f, -plane->D() / plane->C()); } // Transform both point of the plane and plane's normal. CVector3 normal = plane->Normal(); Transform(&planePoint); Transform(&normal, true); plane->Build(planePoint, normal); }
void CQTOpenGLUserFunctions::DrawPolygon(const CVector3& c_position, const CQuaternion& c_orientation, const std::vector<CVector2>& vec_points, const CColor& c_color, const bool b_fill) { if(vec_points.size() < 2) { LOGERR << "CQTOpenGLUserFunctions::DrawPolygon() needs at least 3 points." << std::endl; return; } /* Save attributes and current matrix */ glPushAttrib(GL_POLYGON_BIT); /* Set color */ SetColor(c_color); /* Disable face culling, to make the triangle visible from any angle */ glDisable(GL_CULL_FACE); /* Set polygon attributes */ glEnable(GL_POLYGON_SMOOTH); glPolygonMode(GL_FRONT_AND_BACK, b_fill ? GL_FILL : GL_LINE); /* Set position/orientation */ Rototranslate(c_position, c_orientation); /* Draw */ glBegin(GL_POLYGON); glNormal3f(0.0f, 0.0f, 1.0f); for(size_t i = 0; i < vec_points.size(); ++i) { glVertex3f(vec_points[i].GetX(), vec_points[i].GetY(), 0.0f); } glEnd(); /* Reset translation */ glTranslatef(-c_position.GetX(), -c_position.GetY(), -c_position.GetZ()); /* Restore saved stuff */ glPopAttrib(); }
void CDynamics2DMultiBodyObjectModel::MoveTo(const CVector3& c_position, const CQuaternion& c_orientation) { /* Set target position and orientation */ cpVect tBodyPos = cpv(c_position.GetX(), c_position.GetY()); CRadians cXAngle, cYAngle, cZAngle; c_orientation.ToEulerAngles(cZAngle, cYAngle, cXAngle); cpFloat tBodyOrient = cZAngle.GetValue(); /* For each body: */ for(size_t i = 0; i < m_vecBodies.size(); ++i) { /* Set body orientation at anchor */ cpBodySetAngle(m_vecBodies[i].Body, tBodyOrient + m_vecBodies[i].OffsetOrient); /* Set body position at anchor */ cpBodySetPos(m_vecBodies[i].Body, cpvadd(tBodyPos, cpvrotate(m_vecBodies[i].OffsetPos, m_vecBodies[i].Body->rot))); /* Update shape index */ cpSpaceReindexShapesForBody(GetDynamics2DEngine().GetPhysicsSpace(), m_vecBodies[i].Body); } /* Update ARGoS entity state */ UpdateEntityStatus(); }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : CMatrix Quaternion() // // - Purpose : Returns the equivalent quaternion. // // ----------------------------------------------------------------------------- CQuaternion CMatrix::Quaternion() const { CQuaternion result; float fTrace, fS; fTrace = 1.0f + m_fM[0][0] + m_fM[1][1] + m_fM[2][2]; // Check trace value if(fTrace > 0.000001f) { fS = 0.5f / sqrtf(fTrace); result.SetW(0.25f / fS); CVector3 v; v.SetX((m_fM[2][1] - m_fM[1][2]) * fS); v.SetY((m_fM[0][2] - m_fM[2][0]) * fS); v.SetZ((m_fM[1][0] - m_fM[0][1]) * fS); result.SetV(v); return result; } else { float qx, qy, qz, qw; if(m_fM[0][0] > m_fM[1][1] && m_fM[0][0] > m_fM[2][2]) { fS = sqrtf(1.0f + m_fM[0][0] - m_fM[1][1] - m_fM[2][2]) * 2.0f; qx = 0.25f * fS; qy = (m_fM[0][1] + m_fM[1][0] ) / fS; qz = (m_fM[0][2] + m_fM[2][0] ) / fS; qw = (m_fM[1][2] - m_fM[2][1] ) / fS; } else if(m_fM[1][1] > m_fM[2][2]) { fS = sqrt( 1.0 + m_fM[1][1] - m_fM[0][0] - m_fM[2][2] ) * 2; qx = (m_fM[0][1] + m_fM[1][0] ) / fS; qy = 0.25f * fS; qz = (m_fM[1][2] + m_fM[2][1] ) / fS; qw = (m_fM[0][2] - m_fM[2][0] ) / fS; } else { fS = sqrt( 1.0 + m_fM[2][2] - m_fM[0][0] - m_fM[1][1] ) * 2; qx = (m_fM[0][2] + m_fM[2][0] ) / fS; qy = (m_fM[1][2] + m_fM[2][1] ) / fS; qz = 0.25f * fS; qw = (m_fM[0][1] - m_fM[1][0] ) / fS; } result.SetW(qw); result.SetV(CVector3(qx, qy, qz)); } return result; }
CVector3 AABox::Corner( int idx ) const { CVector3 rval; rval.SetX( ((idx & 1) == 1) ? mMax.GetX() : mMin.GetX() ); rval.SetY( ((idx & 2) == 1) ? mMax.GetY() : mMin.GetY() ); rval.SetZ( ((idx & 4) == 1) ? mMax.GetZ() : mMin.GetZ() ); return rval; }
double cPrimitives::PrimitiveSphere(CVector3 _point, const sPrimitiveSphere &sphere) const { CVector3 point = _point - sphere.position; point = sphere.rotationMatrix.RotateVector(point); point = point.mod(sphere.repeat); double dist = point.Length() - sphere.radius; return sphere.empty ? fabs(dist) : dist; }
// --[ Method ]--------------------------------------------------------------- // // - Class : CVector3 // - Prototype : bool operator != (const CVector3& vector) const // // - Purpose : Comparison operator // // --------------------------------------------------------------------------- bool CVector3::operator != (const CVector3& vector) const { if(!ARE_EQUAL(vector.X(), m_fX)) return true; if(!ARE_EQUAL(vector.Y(), m_fY)) return true; if(!ARE_EQUAL(vector.Z(), m_fZ)) return true; return false; }
bool CEntityPhysics::BoundingCircleCollide(const CEntityPhysics& that, const CEntityTransform& thistransform, const CEntityTransform& thattransform) const { CVector3 thatPos = thattransform.GetPosition(); CVector3 thisPos = thistransform.GetPosition(); CVector3 centerToCenter = thatPos - thisPos; return centerToCenter.LengthSq() <= (this->GetBoundingCircleRadiusSq() + that.GetBoundingCircleRadiusSq()); }
void CBuzzControllerSpiri::SetDirection(const CVector3& c_heading) { CVector3 cDir = c_heading; if(cDir.SquareLength() > 0.01f) { cDir.Normalize(); cDir *= 0.01; } m_pcPropellers->SetRelativePosition(cDir); }
double sPrimitiveSphere::PrimitiveDistance(CVector3 _point) const { CVector3 point = _point - position; point = rotationMatrix.RotateVector(point); point = point.mod(repeat); double dist = point.Length() - radius; return empty ? fabs(dist) : dist; }
void CTargetingComputer::render() { // Display surround renderQuad(); char strFont[256]; if (m_pTarget) { // Calculate position of targeting reticle CVector3 pos = m_pTarget->m_ppMasses[0]->m_vecPos; // Get viewport int viewport[4]; double modelview[16]; double projection[16]; glGetIntegerv(GL_VIEWPORT,viewport); glGetDoublev(GL_MODELVIEW_MATRIX,modelview); glGetDoublev(GL_PROJECTION_MATRIX,projection); // Project to 2d screen coords double dX, dY, dZ; gluProject(pos.X(),pos.Y(),pos.Z(), modelview, projection, viewport, &dX, &dY, &dZ); // If behind, invert and scale everything up lots to force it to the edge // This could perhaps work better... not too happy, but it's late if (dZ > 1.0f) { dX = -(dX - (viewport[2]/2)) * viewport[2] + viewport[2]/2; dY = -(dY - (viewport[3]/2)) * viewport[3] + viewport[3]/2; } // Clip if (dX < 0) dX = 0; else if (dX > viewport[2]) dX = viewport[2]; if (dY < 0) dY = 0; else if (dY > viewport[3]) dY = viewport[3]; // Rescale to 0..1 dX /= viewport[2]; dY /= viewport[3]; double dW = 32.0f / viewport[2]; double dH = 32.0f / viewport[3]; // Render reticle m_poTargetingReticle->setPosition(dX-dW, (1-dY)-dH, dW*2, dH*2); m_poTargetingReticle->setTexturePercentage(100.0f); m_poTargetingReticle->renderQuad(); // Radar imagexs m_poHoloTarget->renderQuad(); // Calculate range NSDMath::CVector3 vecTarget = m_pTarget->m_ppMasses[0]->m_vecPos - m_pPlayerShip->m_ppMasses[0]->m_vecPos; int iRange = static_cast<int>(vecTarget.length()); // Range sprintf(strFont,"%5d m", iRange); m_poFont->print("Range:", CVector2(0.03f, 0.25f), 0.0075f, CVector3(0,1,0)); m_poFont->print(strFont, CVector2(0.03f, 0.28f), 0.0075f, CVector3(0,1,0)); // Velocity sprintf(strFont,"%5d m/s", static_cast<int>(m_pTarget->m_fVel)); g_oTextureManager.render(m_auiOffScreenTexture); m_poFont->print("Velocity:", CVector2(0.03f, 0.32f), 0.0075f, CVector3(0,1,0)); m_poFont->print(strFont, CVector2(0.03f, 0.35f), 0.0075f, CVector3(0,1,0)); } }
void game_physics_engine::CParticalDrag::UpdateForce( CPartical* pPartical, const real duration ) { CVector3 force = pPartical->GetVelocity(); real dragCoeff = force.Magnitude(); dragCoeff = m_k1 * dragCoeff + m_k2 * dragCoeff * dragCoeff; force.Normalize(); force *= -dragCoeff; pPartical->AddForce(force); }