// use quaternion rotation instead? more efficient void Transformation::getTransformationMatrix(double gyroXrate, double gyroYrate, double gyroZrate, double dt) { double alpha = getRotationAngle(gyroXrate, dt); double beta = getRotationAngle(gyroYrate, dt); double gamma = getRotationAngle(gyroZrate, dt); matrix[0][0] = cos(beta)*cos(gamma); matrix[0][1] = -sin(gamma); matrix[0][2] = sin(beta); matrix[1][0] = sin(gamma); matrix[1][1] = cos(alpha)*cos(gamma); matrix[1][2] = -sin(alpha); matrix[2][0] = -sin(beta); matrix[2][1] = sin(alpha); matrix[2][2] = cos(alpha)*cos(beta); }
void Vehicles::update(double dt){ if (health <= 0){ isDead = true; } if (!isDead){ speedControl(dt); newVehicle.pathRoute(dt); Pos = newVehicle.getCurrentLocation(); updateHitbox(); SetInteraction(AABB(Vector3(Pos.x - InteractionMin.x, Pos.y - InteractionMin.y, Pos.z - InteractionMin.z), Vector3(Pos.x + InteractionMax.x, Pos.y + InteractionMax.y, Pos.z + InteractionMax.z))); Yaw = getRotationAngle(); if (currAttackTarget != nullptr){ newVehicle.updateWayPoints(currAttackTarget->Pos); } Pos.y = 0; } bulletCurrCooldown += dt; }
bool RMatrix::isRotationAndUniformScale() const { double a = getRotationAngle(); if (RMath::isNaN(a)) { return false; } if (fabs(cos(a))<RS::PointTolerance) { return RMath::fuzzyCompare(get(0,1) / -sin(a), get(1,0) / sin(a)) && RMath::fuzzyCompare(get(0,0), get(1,1)); } if (fabs(sin(a))<RS::PointTolerance) { return RMath::fuzzyCompare(get(0,0) / cos(a), get(1,1) / cos(a)) && RMath::fuzzyCompare(-get(0,1), get(1,0)); } double s00 = get(0,0) / cos(a); double s01 = get(0,1) / -sin(a); double s10 = get(1,0) / sin(a); double s11 = get(1,1) / cos(a); return (RMath::fuzzyCompare(s00, s01) && RMath::fuzzyCompare(s00, s10) && RMath::fuzzyCompare(s00, s11)); }
inline axies_angle Quaternion::getRotationAxiesAngle() const { axies_angle res; res.angle = getRotationAngle(); res.axies = getRotationAxis(); return res; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RotateSampleRefFrame::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setCellAttributeMatrixPath( reader->readDataArrayPath("CellAttributeMatrixPath", getCellAttributeMatrixPath() ) ); setRotationAxis( reader->readFloatVec3("RotationAxis", getRotationAxis() ) ); setRotationAngle( reader->readValue("RotationAngle", getRotationAngle()) ); reader->closeFilterGroup(); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int RotateEulerRefFrame::writeFilterParameters(AbstractFilterParametersWriter* writer, int index) { writer->openFilterGroup(this, index); writer->writeValue("RotationAxis", getRotationAxis() ); writer->writeValue("RotationAngle", getRotationAngle() ); writer->closeFilterGroup(); return ++index; // we want to return the next index that was just written to }
double RMatrix::getUniformScaleFactor() const { if (getRows()!=2 || getCols()!=2) { return RNANDOUBLE; } double a = getRotationAngle(); if (RMath::isNaN(a)) { return RNANDOUBLE; } return get(0,0) / cos(a); }
float HMC5583L::getAngle(){ //modify the angle using the starting angle float angle=startingAngle-getRotationAngle(); if(angle>=360.0f){ angle-=360.0f; } if(angle<0.0f){ angle+=360.0f; } return angle; }
Vehicles::Vehicles(Vector3 position, Vector3 viewDirection, float newSpeed, int newHealth, float newFireRate, float newBulletDamage) : board(false), isDead(false), bulletCooldown(0){ Vector3 initialPosition = position + viewDirection.Normalize(); Pos = position; View = viewDirection; newVehicle.setMaxSpeed(newSpeed); newVehicle.setCurrentLocation(position); initialYaw = getRotationAngle(viewDirection); currAttackTarget = nullptr; maxHealth = newHealth; health = maxHealth; bulletFireRate = newFireRate; bulletDamage = newBulletDamage; }
types::RowCol<double> SceneGeometry::getGroundResolution(const types::RgAz<double>& res) const { const Vector3 z = math::linear::cross(getImageRowVector(), getImageColVector()); const double grazingAngleRad = asin(mXs.dot(z)); const double tiltAngleRad = atan2(z.dot(mYs), z.dot(mZs)); const double rotAngleRad = getRotationAngle() * math::Constants::DEGREES_TO_RADIANS; const double cosRot = cos(rotAngleRad); const double sinRot = sin(rotAngleRad); const double sin2Rot = sin(2 * rotAngleRad); const double secGraz = 1.0 / cos(grazingAngleRad); const double tanGraz = tan(grazingAngleRad); const double secTilt = 1.0 / cos(tiltAngleRad); const double tanTilt = tan(tiltAngleRad); const double sinRotSq = square(sinRot); const double kr1 = (sinRotSq * tanGraz * tanTilt - sin2Rot * secGraz) * tanGraz* tanTilt + square(cosRot * secGraz); const double kr2 = square(sinRot * secTilt); const double kc1 = (sinRotSq * secGraz - sin2Rot * tanGraz * tanTilt) * secGraz + square(cosRot * tanGraz * tanTilt); const double kc2 = square(cosRot * secTilt); const types::RgAz<double> resSq(square(res.rg), square(res.az)); const types::RowCol<double> groundRes( sqrt(kr1 * resSq.rg + kr2 * resSq.az), sqrt(kc1 * resSq.rg + kc2 * resSq.az)); return groundRes; }
void Bus::draw() { float rotAngle = getRotationAngle(); Vector3D * rotation = getRotation(); Vector3D * scale = getScale(); getVSML()->loadIdentity(VSMathLib::MODEL); // Bus getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(getPosition()->getX(), getPosition()->getY(), getPosition()->getZ()); //getVSML()->rotate(rotAngle, rotation->getX(), rotation->getY(), rotation->getZ()); //getVSML()->scale(scale->getX(), scale->getY(), scale->getZ()); // body getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->scale(3.0f, 0.8f, 1.4f); // cube getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(-0.5f, -0.5f, -0.5f); glUseProgram((*getShader()).getProgramIndex()); getVSML()->matricesToGL(); glBindVertexArray(vaoBus); glDrawElements(GL_TRIANGLES, faceCountBus * 3, GL_UNSIGNED_INT, 0); getVSML()->popMatrix(VSMathLib::MODEL); // cube getVSML()->popMatrix(VSMathLib::MODEL); // body // window getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(0.2f, 0.0f, 0.35f); getVSML()->scale(2.6004f, 0.8006f, 0.5f); // cube getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(-0.5f, -0.5f, -0.5f); glUseProgram((*getShader()).getProgramIndex()); getVSML()->matricesToGL(); glBindVertexArray(vaoBus2); glDrawElements(GL_TRIANGLES, faceCountBus * 3, GL_UNSIGNED_INT, 0); getVSML()->popMatrix(VSMathLib::MODEL); // cube getVSML()->popMatrix(VSMathLib::MODEL); // window // back wheels getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(-1.0f, 0.0f, -0.7f); glUseProgram((*getShader()).getProgramIndex()); getVSML()->matricesToGL(); getResSurfRev().render(); getVSML()->popMatrix(VSMathLib::MODEL); getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(-0.3f, 0.0f, -0.7f); glUseProgram((*getShader()).getProgramIndex()); getVSML()->matricesToGL(); getResSurfRev().render(); getVSML()->popMatrix(VSMathLib::MODEL); // back wheels // front wheels getVSML()->pushMatrix(VSMathLib::MODEL); getVSML()->translate(1.0f, 0.0f, -0.7f); glUseProgram((*getShader()).getProgramIndex()); getVSML()->matricesToGL(); getResSurfRev().render(); getVSML()->popMatrix(VSMathLib::MODEL); // front wheels getVSML()->popMatrix(VSMathLib::MODEL); // Bus }
float HMC5583L::getRawAngle(){ float angle=getRotationAngle(); return angle; }
void HMC5583L::setStartingAngle(){ startingAngle=getRotationAngle(); }
//-------------------------------------------------------------- ofQuaternion ofxBulletBaseShape::getRotationQuat() const { ofVec3f axis = getRotationAxis(); return ofQuaternion( axis.x, axis.y, axis.z, getRotationAngle()); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RotateSampleRefFrame::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FloatVec3FilterParameter::New("Rotation Axis (ijk)", "RotationAxis", getRotationAxis(), FilterParameter::Parameter)); parameters.push_back(DoubleFilterParameter::New("Rotation Angle (Degrees)", "RotationAngle", getRotationAngle(), FilterParameter::Parameter)); parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::RequiredArray)); { AttributeMatrixSelectionFilterParameter::RequirementType req = AttributeMatrixSelectionFilterParameter::CreateRequirement(DREAM3D::AttributeMatrixType::Cell, DREAM3D::GeometryType::ImageGeometry); parameters.push_back(AttributeMatrixSelectionFilterParameter::New("Cell Attribute Matrix", "CellAttributeMatrixPath", getCellAttributeMatrixPath(), FilterParameter::RequiredArray, req)); } setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void RotateEulerRefFrame::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FloatVec3FilterParameter::New("Rotation Axis (ijk)", "RotationAxis", getRotationAxis(), FilterParameter::Parameter)); parameters.push_back(DoubleFilterParameter::New("Rotation Angle (Degrees)", "RotationAngle", getRotationAngle(), FilterParameter::Parameter)); { DataArraySelectionFilterParameter::RequirementType req = DataArraySelectionFilterParameter::CreateCategoryRequirement(SIMPL::TypeNames::Float, 3, SIMPL::AttributeMatrixObjectType::Element); parameters.push_back(DataArraySelectionFilterParameter::New("Euler Angles", "CellEulerAnglesArrayPath", getCellEulerAnglesArrayPath(), FilterParameter::RequiredArray, req)); } setFilterParameters(parameters); }