SceneObjectPtr LinearGradient::createRenderable()
{
ASSERT_LOG(color_stops_.size() >= 2, "Must be at least two color stops.");
//ASSERT_LOG(std::abs(color_stops_.front().length) < FLT_EPSILON, "First stop must be at 0");
//ASSERT_LOG(std::abs(color_stops_.back().length - 1.0f) < FLT_EPSILON, "Last stop must be at 1");
// attempt one.
int number_strips = color_stops_.size() - 1;
auto gr = std::make_shared<GradientRenderable>();
gr->setRotation(-angle_, z_axis);
//auto clip_mask = std::make_shared<SimpleClipShape>();
//clip_mask->setRotation(angle_, z_axis);
//gr->setClipSettings(get_stencil_mask_settings(), clip_mask);
std::vector<KRE::vertex_color> vc;
vc.reserve(6 * number_strips);
// assume a box size from 0 -> 1, 0 -> 1
for(int strip = 0; strip < number_strips; ++strip) {
const float vx1 = -0.5f;
const float vy1 = color_stops_[strip].length - 0.5f;
const float vx2 = 0.5f;
const float vy2 = color_stops_[strip + 1].length - 0.5f;
vc.emplace_back(glm::vec2(vx1, vy1), color_stops_[strip].color.as_u8vec4());
vc.emplace_back(glm::vec2(vx1, vy2), color_stops_[strip + 1].color.as_u8vec4());
vc.emplace_back(glm::vec2(vx2, vy2), color_stops_[strip + 1].color.as_u8vec4());
vc.emplace_back(glm::vec2(vx1, vy1), color_stops_[strip].color.as_u8vec4());
vc.emplace_back(glm::vec2(vx2, vy2), color_stops_[strip + 1].color.as_u8vec4());
vc.emplace_back(glm::vec2(vx2, vy1), color_stops_[strip].color.as_u8vec4());
}
gr->update(&vc);
return gr;
}
void PowerUp::updateSelf( const double & delta )
{
mRotationAngle += delta * 100.0f;
setRotation( QQuaternion::fromAxisAndAngle( 0,1,0, mRotationAngle ) );
QSharedPointer<Player> player = mLandscape->world()->player();
float dist = ( player->worldPosition() - worldPosition() ).length();
if( mRespawning )
{
mRespawnCoolDown -= delta;
if( mRespawnCoolDown < 0.0f )
{
mRespawnCoolDown = 0.0f;
mRespawning = false;
}
}
else
{
if( dist <= 2.0f )
{
switch( mPowerType )
{
case HEALTH:
player->setLife( qMin( player->life() + 25, 100 ) );
break;
case ARMOR:
player->setArmor( qMin( player->armor() + 40, 100 ) );
break;
case WEAPON_LASER:
player->giveWeapon( QSharedPointer<AWeapon>( new Laser( world() ) ) );
break;
}
respawn();
}
}
}
void EnPlayer::spawn()
{
osg::Quat rotation;
osg::Vec3f position;
// check if the level has spawn points
EnSpawnPoint* p_spwanEntity = static_cast< EnSpawnPoint* >( yaf3d::EntityManager::get()->findEntity( ENTITY_NAME_SPAWNPOINT ) );
if ( p_spwanEntity )
{
if ( !EnSpawnPoint::getNextSpawnPoint( position, rotation ) )
{
log_error << "EnPlayer: all spawn points are occupied, taking default position and rotation!" << std::endl;
}
}
else
{
position = _attributeContainer._pos;
rotation = osg::Quat( osg::DegreesToRadians( _attributeContainer._rot ), osg::Vec3f( 0.0f, 0.0f, 1.0f ) );
}
// set initial rotation and position
setPosition( position );
setRotation( rotation );
}
void Samsquamptch::updateCurrent(sf::Time dt, sf::Vector2f target, sf::Vector2f bounds)
{
acquireTarget(target,bounds);
m_velocity *= dt.asSeconds()*m_aggressionLevel;
if(getPosition().y >= m_target.y
&& getPosition().y < m_target.y + m_bounds.y
&& getPosition().x >= m_target.x
&& getPosition().x < m_target.x + m_bounds.y)
{
//achieved goal - target acquired
}
else
{
//work towards goal
setRotation(toDegree(m_angle) + 90.f);
move(m_velocity);
m_rect.setPosition(getPosition());
m_rect.setRotation(getRotation());
//std::cout<<"Chasing..."<<std::endl;
}
}
void QgsMapCanvas::readProject( const QDomDocument & doc )
{
QDomNodeList nodes = doc.elementsByTagName( "mapcanvas" );
if ( nodes.count() )
{
QDomNode node = nodes.item( 0 );
QgsMapSettings tmpSettings;
tmpSettings.readXML( node );
setMapUnits( tmpSettings.mapUnits() );
setCrsTransformEnabled( tmpSettings.hasCrsTransformEnabled() );
setDestinationCrs( tmpSettings.destinationCrs() );
setExtent( tmpSettings.extent() );
setRotation( tmpSettings.rotation() );
mSettings.datumTransformStore() = tmpSettings.datumTransformStore();
clearExtentHistory(); // clear the extent history on project load
}
else
{
QgsDebugMsg( "Couldn't read mapcanvas information from project" );
}
}
void FaceModel::simulate(float deltaTime, bool fullUpdate) {
updateGeometry();
Avatar* owningAvatar = static_cast<Avatar*>(_owningHead->_owningAvatar);
glm::vec3 neckPosition;
if (!owningAvatar->getSkeletonModel().getNeckPosition(neckPosition)) {
neckPosition = owningAvatar->getPosition();
}
setTranslation(neckPosition);
glm::quat neckParentRotation;
if (!owningAvatar->getSkeletonModel().getNeckParentRotationFromDefaultOrientation(neckParentRotation)) {
neckParentRotation = owningAvatar->getOrientation();
}
setRotation(neckParentRotation);
setScale(glm::vec3(1.0f, 1.0f, 1.0f) * _owningHead->getScale());
setPupilDilation(_owningHead->getPupilDilation());
setBlendshapeCoefficients(_owningHead->getBlendshapeCoefficients());
if (isActive()) {
setOffset(-_geometry->getFBXGeometry().neckPivot);
Model::simulateInternal(deltaTime);
}
}
void
TrackMoveHandle::registerLowSlot(TrackComponent *trackComponent)
{
lowSlot_ = trackComponent;
// Observer //
//
lowSlot_->attachObserver(this);
// Transformation //
//
if (!highSlot_) // do not set pos twice
{
setFlag(QGraphicsItem::ItemSendsGeometryChanges, false);
setPos(lowSlot_->getGlobalPoint(lowSlot_->getSEnd()));
setRotation(lowSlot_->getGlobalHeading(lowSlot_->getSEnd()));
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
}
// Degrees Of Freedom Fries //
//
updateDOF();
}
TextGraphicsItem::TextGraphicsItem(Text& text,
const IF_GraphicsLayerProvider& lp,
QGraphicsItem* parent) noexcept
: PrimitiveTextGraphicsItem(parent), mText(text), mLayerProvider(lp) {
setFont(TextGraphicsItem::Font::SansSerif);
setPosition(mText.getPosition());
setRotation(mText.getRotation());
setText(mText.getText());
setHeight(mText.getHeight());
setAlignment(mText.getAlign());
setLayer(mLayerProvider.getLayer(*mText.getLayerName()));
setFlag(QGraphicsItem::ItemIsSelectable, true);
setZValue(5);
// add origin cross
mOriginCrossGraphicsItem.reset(new OriginCrossGraphicsItem(this));
mOriginCrossGraphicsItem->setSize(UnsignedLength(1000000));
mOriginCrossGraphicsItem->setLayer(
mLayerProvider.getLayer(GraphicsLayer::sSchematicReferences)); // TODO
// register to the text to get attribute updates
mText.registerObserver(*this);
}
void RenderTextureSave::saveImage(cocos2d::Ref *sender)
{
static int counter = 0;
char png[20];
sprintf(png, "image-%d.png", counter);
auto callback = [&](RenderTexture* rt, const std::string& path)
{
auto sprite = Sprite::create(path);
addChild(sprite);
sprite->setScale(0.3f);
sprite->setPosition(Vec2(40, 40));
sprite->setRotation(counter * 3);
};
_target->saveToFile(png, Image::Format::PNG, true, callback);
//Add this function to avoid crash if we switch to a new scene.
Director::getInstance()->getRenderer()->render();
CCLOG("Image saved %s", png);
counter++;
}
void GameScene::addEnemyTankBullet(Node* node)
{
auto* enemyTankGun = (EnemyTankGun*)node;
auto etankbullet = Sprite::create(enemyName[enemyTankGun->getEnemyTankIndex()-1].c_str());
switch (enemyTankGun->getEnemyTankIndex()) {
case 1:
case 2:
enemyBullet->addChild(etankbullet);
break;
case 3:
case 4:
enemyBazooka->addChild(etankbullet);
break;
default:
break;
}
float enemyTankGunRotation = enemyTankGun->getRotation();
etankbullet->setRotation(enemyTankGunRotation);
enemyTankGunRotation = enemyTankGunRotation*pi/180.0f;
Vec2 enemyTankGunPos = enemyTankGun->getPosition();
enemyTankGunPos = enemyTankGun->convertToWorldSpaceAR(enemyTankGunPos);
etankbullet->setPosition(enemyTankGunPos.x+40*sin(enemyTankGunRotation),enemyTankGunPos.y+40*cos(enemyTankGunRotation));
auto moveAct = MoveTo::create(8, Vec2(enemyTankGunPos.x+1600*sin(enemyTankGunRotation),enemyTankGunPos.y+1200*cos(enemyTankGunRotation)));
if (enemyTankGun->getEnemyTankIndex() < 3) {
auto funcAct = CallFuncN::create(CC_CALLBACK_1(GameScene::removeEnemyTankBullet, this));
etankbullet->runAction(Sequence::create(moveAct,funcAct, NULL));
}
else
{
auto funcAct = CallFuncN::create(CC_CALLBACK_1(GameScene::removeEnemyTankBazooka, this));
etankbullet->runAction(Sequence::create(moveAct,funcAct, NULL));
}
}
void obj::advance(int step)
{
if (!step)
return;
// Don't move too far away
QLineF lineToCenter(QPointF(0, 0), mapFromScene(0, 0));
if (lineToCenter.length() > 150) {
qreal angleToCenter = ::acos(lineToCenter.dx() / lineToCenter.length());
if (lineToCenter.dy() < 0)
angleToCenter = TwoPi - angleToCenter;
angleToCenter = normalizeAngle((Pi - angleToCenter) + Pi / 2);
if (angleToCenter < Pi && angleToCenter > Pi / 4) {
// Rotate left
angle += (angle < -Pi / 2) ? 0.25 : -0.25;
} else if (angleToCenter >= Pi && angleToCenter < (Pi + Pi / 2 + Pi / 4)) {
// Rotate right
angle += (angle < Pi / 2) ? 0.25 : -0.25;
}
} else if (::sin(angle) < 0) {
angle += 0.25;
} else if (::sin(angle) > 0) {
angle -= 0.25;
}
if (qrand() % 1)
angle += (qrand() % 100) / 500.0;
else
angle -= (qrand() % 100) / 500.0;
speed += (-50 + qrand() % 100) / 100.0;
qreal dx = ::sin(angle) * 10;
setRotation(rotation() + dx);
setPos(mapToParent(0, -(3 + sin(speed) * 3)));
}
void Widget::copyProperties(Widget *widget)
{
setEnabled(widget->isEnabled());
setVisible(widget->isVisible());
setBright(widget->isBright());
setTouchEnabled(widget->isTouchEnabled());
_touchPassedEnabled = false;
setLocalZOrder(widget->getLocalZOrder());
setTag(widget->getTag());
setName(widget->getName());
setActionTag(widget->getActionTag());
_ignoreSize = widget->_ignoreSize;
_size = widget->_size;
_customSize = widget->_customSize;
copySpecialProperties(widget);
_sizeType = widget->getSizeType();
_sizePercent = widget->_sizePercent;
_positionType = widget->_positionType;
_positionPercent = widget->_positionPercent;
setPosition(widget->getPosition());
setAnchorPoint(widget->getAnchorPoint());
setScaleX(widget->getScaleX());
setScaleY(widget->getScaleY());
setRotation(widget->getRotation());
setRotationSkewX(widget->getRotationSkewX());
setRotationSkewY(widget->getRotationSkewY());
setFlippedX(widget->isFlippedX());
setFlippedY(widget->isFlippedY());
setColor(widget->getColor());
setOpacity(widget->getOpacity());
Map<int, LayoutParameter*>& layoutParameterDic = widget->_layoutParameterDictionary;
for (auto iter = layoutParameterDic.begin(); iter != layoutParameterDic.end(); ++iter)
{
setLayoutParameter(iter->second->clone());
}
onSizeChanged();
}
void PhysShape::unpack(BitStream* stream)
{
bool enabled = stream->readFlag();
if (isEnabled()!=enabled)
setEnable(enabled);
if (enabled)
{
bool active = stream->readFlag();
bool toInactive = false;
if (!active)
{
toInactive = stream->readFlag();
if (!toInactive)
return;
}
if (!isActive())
setActive(true);
QuatF q;
VectorF vec;
mathRead(*stream, &vec);
setPosition(vec);
mathRead(*stream, &q);
setRotation(q);
mathRead(*stream, &vec);
setForce(vec);
mathRead(*stream, &vec);
setTorque(vec);
mathRead(*stream, &vec);
setLinVelocity(vec);
mathRead(*stream, &vec);
setAngVelocity(vec);
if (toInactive)
setActive(false);
}
}
/// Creds to http://chess.eecs.berkeley.edu/eecs149/documentation/differentialDrive.pdf
double Robby::go(int motLeft,int motRight,double speed,double deltaTime) {
double mLeft = -(((double)motLeft)/200)*speed;
double mRight = -(((double)motRight)/200)*speed;
double xprime,yprime,rprime;
double length = getSize().x;
double rX = getPosition().x;
double rY = getPosition().y;
double rTheta = getRotation()*0.0174532925;
double omega = (mRight-mLeft)/length;
if (mLeft == mRight) {
xprime = rX + mLeft*cos(rTheta)*deltaTime;
yprime = rY + mLeft*sin(rTheta)*deltaTime;
rprime = rTheta;
} else {
double radius = (length/2)*(mLeft+mRight)/(mRight-mLeft);
double iccX = rX - radius*sin(rTheta);
double iccY = rY + radius*cos(rTheta);
xprime = iccX + (cos(omega*deltaTime)*(rX-iccX)+
-sin(omega*deltaTime)*(rY-iccY));
yprime = iccY + (sin(omega*deltaTime)*(rX-iccX)+
cos(omega*deltaTime)*(rY-iccY));
rprime = rTheta + omega*deltaTime;
}
setPosition(xprime,yprime);
setRotation(rprime*57.2957795);
m1Last = motLeft;
m2Last = motRight;
return omega*10000;
}
bool RoleEmemyBig::init() {
//////////////////////////////
// 1. super init first
if (!Sprite::initWithSpriteFrameName("hero1.png")) {
return false;
}
setTag(TAG_ENEMY_PLANE);
auto body = PhysicsBody::createBox(getContentSize());
body->setGroup(PHYSICAL_BODY_ENEMY_GROUP);
body->setCategoryBitmask(PHYSICAL_BODY_ENEMY_BITMASK_CATEGORY);
body->setContactTestBitmask(PHYSICAL_BODY_ENEMY_BITMASK_CONTACT_TEST);
body->setCollisionBitmask(PHYSICAL_BODY_ENEMY_BITMASK_COLLISION);
setPhysicsBody(body);
setRotation(-90);
Point endPos = Point(0, 100);
runAction(
Sequence::create(MoveTo::create(3.0, endPos),
CallFunc::create(
CC_CALLBACK_0(RoleEmemyBig::doRemoveSelf, this, this)),
NULL));
return true;
}
void USBCamera::setup(kerberos::StringMap &settings)
{
int width = std::atoi(settings.at("captures.USBCamera.frameWidth").c_str());
int height = std::atoi(settings.at("captures.USBCamera.frameHeight").c_str());
int deviceNumber = std::atoi(settings.at("captures.USBCamera.deviceNumber").c_str());
int angle = std::atoi(settings.at("captures.USBCamera.angle").c_str());
int delay = std::atoi(settings.at("captures.USBCamera.delay").c_str());
std::string fourcc = settings.at("captures.USBCamera.fourcc");
// Initialize executor (update the usb camera at specific times).
tryToUpdateCapture.setAction(this, &USBCamera::update);
tryToUpdateCapture.setInterval("thrice in 10 functions calls");
// Save width and height in settings
Capture::setup(settings, width, height, angle);
setImageSize(width, height);
setRotation(angle);
setDelay(delay);
setDeviceNumber(deviceNumber);
setFourcc(fourcc);
// Initialize USB Camera
open();
}
/*!
* \brief BitmapAnnotation::BitmapAnnotation
* Used by OMSimulator FMU ModelWidget\n
* We always make this shape as inherited shape since its not allowed to be modified.
* \param classFileName
* \param pGraphicsView
*/
BitmapAnnotation::BitmapAnnotation(QString classFileName, GraphicsView *pGraphicsView)
: ShapeAnnotation(true, pGraphicsView, 0)
{
mpComponent = 0;
mClassFileName = classFileName;
// set the default values
GraphicItem::setDefaults();
ShapeAnnotation::setDefaults();
// set users default value by reading the settings file.
ShapeAnnotation::setUserDefaults();
QList<QPointF> extents;
extents << QPointF(-100, -100) << QPointF(100, 100);
setExtents(extents);
setPos(mOrigin);
setRotation(mRotation);
setShapeFlags(true);
setFileName(mClassFileName);
if (!mFileName.isEmpty() && QFile::exists(mFileName)) {
mImage.load(mFileName);
} else {
mImage = QImage(":/Resources/icons/bitmap-shape.svg");
}
}
//----------------------------------------------------------------------
void SpaceGameActor::update( double deltaTime )
{
Actor::update( deltaTime );
m_wasSpawnedLastFrame = false;
float dt = static_cast< float >( deltaTime );
setRotation( mat3f::createMatrixFromQuaternion( quatf::makeQuaternionFromAxisAngle( MathFuncs<float>::degreesToRadians( m_rotation ), vec3f( 0.0f, 0.0f, 1.0f ) ) ) );
//vec3f impulseInDirOfShip = transformVector( vec3f( 0.0f, IMPULSE_POWER, 0.0f ), getLocalRotation() );
//impulseInDirOfShip *= m_forwardImpulse;
//
//m_vel += vec2f( impulseInDirOfShip.x, impulseInDirOfShip.y );
m_frames[ m_currentFrame ].position += m_vel*dt;
m_vel -= m_vel * m_drag * dt;
//m_forwardImpulse = 0.0f;
m_frames[ m_currentFrame ].position.x = (float)MathFuncs<int>::wrap( (int)m_frames[ m_currentFrame ].position.x, 0, SCREEN_WIDTH );
m_frames[ m_currentFrame ].position.y = (float)MathFuncs<int>::wrap( (int)m_frames[ m_currentFrame ].position.y, 0, SCREEN_HEIGHT );
vec3f tempDir = transformVector( vec3f( 0.0f, 1.0f, 0.0f ), getLocalRotation() );
tempDir.normalize();
m_dir = vec2f( tempDir.x, tempDir.y );
}
void ITank::reborn()
{
setStatus(NORMAL);
_mini_map_tank->setVisible(true);
_frame_animation_dead = 0;
_frame_animation_level_up = 39;
//se le asigna el ángulo inicial
setRotation(0);
setTurretRotation(0);
setCurrentLive(_max_live, this, false);
setCurrentMana(_max_mana, false);
//se le asignan los estados del movimiento
_move_forward = false;
_move_backward = false;
//se le asignan los estados de la rotación
_rotate_left = false;
_rotate_right = false;
//indica que todos las habilidades están desactivadas
setHurledSkill(1,false);
setHurledSkill(2,false);
setHurledSkill(3,false);
_info_bar->setLiveBarData(_current_live, _max_live);
_info_bar->setManaBarData(_current_mana, _max_mana);
_info_bar->show();
_last_tank_cause_damage = NULL;
emit notifyReborn();
}
void FaceModel::simulate(float deltaTime, bool fullUpdate) {
updateGeometry();
Avatar* owningAvatar = static_cast<Avatar*>(_owningHead->_owningAvatar);
glm::vec3 neckPosition;
if (!owningAvatar->getSkeletonModel().getNeckPosition(neckPosition)) {
neckPosition = owningAvatar->getPosition();
}
setTranslation(neckPosition);
glm::quat neckParentRotation = owningAvatar->getOrientation();
setRotation(neckParentRotation);
setScale(glm::vec3(1.0f, 1.0f, 1.0f) * _owningHead->getScale());
setPupilDilation(_owningHead->getPupilDilation());
setBlendshapeCoefficients(_owningHead->getBlendshapeCoefficients());
// FIXME - this is very expensive, we shouldn't do it if we don't have to
//invalidCalculatedMeshBoxes();
if (isActive()) {
setOffset(-_geometry->getFBXGeometry().neckPivot);
Model::simulateInternal(deltaTime);
}
}
void Adafruit_ST7789::init(uint16_t width, uint16_t height, uint8_t mode) {
// Save SPI data mode. commonInit() calls begin() (in Adafruit_ST77xx.cpp),
// which in turn calls initSPI() (in Adafruit_SPITFT.cpp), passing it the
// value of spiMode. It's done this way because begin() really should not
// be modified at this point to accept an SPI mode -- it's a virtual
// function required in every Adafruit_SPITFT subclass and would require
// updating EVERY such library...whereas, at the moment, we know that
// certain ST7789 displays are the only thing that may need a non-default
// SPI mode, hence this roundabout approach...
spiMode = mode;
// (Might get added similarly to other display types as needed on a
// case-by-case basis.)
commonInit(NULL);
_colstart = ST7789_240x240_XSTART;
_rowstart = ST7789_240x240_YSTART;
_width = width;
_height = height;
displayInit(cmd_240x240);
setRotation(0);
}
//=======================================================
// 飞絮 //season5_dandelion_15-ipadhd.png
//=======================================================
Dandelion::Dandelion(float posx,float posy,float endPosX,float endPosY)
{
int index = 15.0f*CCRANDOM_0_1()+1;
if (index > 15) {
index = 15;
}
char fileName[64];
sprintf(fileName, "dandelion_%d.png",index);
initWithFile(resMgr->getSharedFilePath(fileName).c_str());
setRotation(30);//旋转角度
setAnchorPoint(ccp(0.5, 3));//设置精灵锚点
setPosition(ccp(posx, posy));//叶子1第一次初始位置
setScale(0.5);//设置叶片大小
time = 10 + 10*CCRANDOM_0_1();//叶子下落的时间
roTime = 1.5 + CCRANDOM_0_1();//叶子单向摆动一次时间
fAngle1 = -40 - (CCRANDOM_0_1()*30);//叶子逆时针摆动角度
fAngle2 = 40 + (CCRANDOM_0_1()*30);//顺时针摆动角度
runAction(createFallAction(time, endPosX, endPosY, roTime,
fAngle1,fAngle2, SEL_CallFuncN(&Dandelion::arrived)));
}
Jenia::Jenia() : Qwt3D::SurfacePlot() {
for (unsigned i=0; i!=coordinates()->axes.size(); ++i)
{
coordinates()->axes[i].setMajors(7);
coordinates()->axes[i].setMinors(4);
}
coordinates()->axes[Qwt3D::X1].setLabelString("x");
coordinates()->axes[Qwt3D::Y1].setLabelString("y");
coordinates()->axes[Qwt3D::Z1].setLabelString("z");
setCoordinateStyle(Qwt3D::BOX);
setPlotStyle(Qwt3D::WIREFRAME);
Qwt3D::RGBA color(1, 0, 0, 1);
setMeshColor(color);
setRotation(30,0,15);
setScale(1,1,1);
setShift(0.15,0,0);
setZoom(0.9);
resize(800, 600);
}
/**
* Synchronizes the state of this body with the internal Box2D state.
*/
void Box2DBody::synchronize()
{
Q_ASSERT(mBody);
mSynchronizing = true;
const b2Vec2 position = mBody->GetPosition();
const float32 angle = mBody->GetAngle();
const qreal newX = position.x * scaleRatio;
const qreal newY = -position.y * scaleRatio;
const qreal newRotation = -(angle * 360.0) / (2 * M_PI);
// Do fuzzy comparisions to avoid small inaccuracies causing repaints
if (!qFuzzyCompare(x(), newX) || !qFuzzyCompare(y(), newY))
setPos(newX, newY);
if (!qFuzzyCompare(rotation(), newRotation))
setRotation(newRotation);
b2Vec2 linearVelocity = mBody->GetLinearVelocity();
setLinearVelocity(QPointF(linearVelocity.x * scaleRatio,
-linearVelocity.y * scaleRatio));
mSynchronizing = false;
}
/*----- CarBSS --------------------------------------------------------------*/
void CarBSS::turnDirection()
{
QPointF curLocation = this->mapToScene( 0, 0 );
if ( curLocation == BSS2RHE ) {
if ( dist != eBSN ) {
setRotation( -90 );
}
}
else if ( curLocation == RHW2TBS ) {
if ( dist == eTBS ) // Head to TBS
{
setRotation( 0 );
}
}
else if ( curLocation == RHUp ) {
if ( dist != eRHE ) // else Head to RHE
{
setRotation( 180 );
}
}
else if ( curLocation == RHLeft ) {
setRotation( 90 );
}
else if ( curLocation == RHE2TBN ) {
if ( dist == eTBN ) // Head to TBN
{
setRotation( 180 );
}
}
else if ( curLocation == RHE2BSN) {
if ( dist == eBSN ) // Head to BSN
{
setRotation( 180 );
}
}
// else Head to RHW
}
/*----- CarTBN --------------------------------------------------------------*/
void CarTBN::turnDirection()
{
QPointF curLocation = this->mapToScene( 0, 0 );
if ( curLocation == TBN2RHW ) {
if ( dist != eTBS ) {
setRotation( 90 );
}
}
else if ( curLocation == RHE2BSN ) {
if ( dist == eBSN ) // Head to BSN
{
setRotation( 180 );
}
}
else if ( curLocation == RHDown ) {
if ( dist != eRHW ) // else Head to RHW
{
setRotation( 0 );
}
}
else if ( curLocation == RHRight ) {
setRotation( -90 );
}
else if ( curLocation == RHW2BSS ) {
if ( dist == eBSS ) // Head to BSS
{
setRotation( 0 );
}
}
else if ( curLocation == RHW2TBS ) {
if ( dist == eTBS ) // Head to TBS
{
setRotation( 0 );
}
}
// else Head to RHE
}
/*----- CarRHW --------------------------------------------------------------*/
void CarRHW::turnDirection()
{
QPointF curLocation = this->mapToScene( 0, 0 );
if ( curLocation == RHRight ) {
}
else if ( curLocation == RHW2BSS ) {
if ( dist == eBSS ) { // Head to BSS
setRotation( 0 );
}
}
else if ( curLocation == RHW2TBS ) {
if ( dist == eTBS ) { // Head to TBS
setRotation( 0 );
}
}
else if ( curLocation == RHUp ) {
if ( dist != eRHE ) { // esle Head to RHE
setRotation( 180 );
}
}
else if ( curLocation == RHLeft ) { // turnning
setRotation( 90 );
}
else if ( curLocation == RHE2TBN ) {
if ( dist = eTBN ) { // Head to TBN
setRotation( 180 );
}
}
else if ( curLocation == RHE2BSN ) {
if ( dist == eBSN ) { // Head to BSN
setRotation( 180 );
}
}
// else go to the adverse direction
}
bool LLTextureEntry::fromLLSD(const LLSD& sd)
{
const char *w, *x;
w = "imageid";
if (sd.has(w))
{
setID( sd[w] );
} else goto fail;
w = "colors";
if (sd.has(w))
{
setColor( ll_color4_from_sd(sd["colors"]) );
} else goto fail;
w = "scales";
x = "scalet";
if (sd.has(w) && sd.has(x))
{
setScale( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
} else goto fail;
w = "offsets";
x = "offsett";
if (sd.has(w) && sd.has(x))
{
setOffset( (F32)sd[w].asReal(), (F32)sd[x].asReal() );
} else goto fail;
w = "imagerot";
if (sd.has(w))
{
setRotation( (F32)sd[w].asReal() );
} else goto fail;
w = "bump";
if (sd.has(w))
{
setBumpShiny( sd[w].asInteger() );
} else goto fail;
w = "fullbright";
if (sd.has(w))
{
setFullbright( sd[w].asInteger() );
} else goto fail;
w = "media_flags";
if (sd.has(w))
{
setMediaTexGen( sd[w].asInteger() );
} else goto fail;
// If the "has media" flag doesn't match the fact that
// media data exists, updateMediaData will "fix" it
// by either clearing or setting the flag
w = TEXTURE_MEDIA_DATA_KEY;
if (hasMedia() != sd.has(w))
{
llwarns << "LLTextureEntry::fromLLSD: media_flags (" << hasMedia() <<
") does not match presence of media_data (" << sd.has(w) << "). Fixing." << llendl;
}
updateMediaData(sd[w]);
w = "glow";
if (sd.has(w))
{
setGlow((F32)sd[w].asReal() );
}
return true;
fail:
return false;
}
//! [4]
void Mouse::advance(int step)
{
if (!step)
return;
if (mReplay) {
std::cout << "___________________" <<mPosList->size() << std::endl;
if (mI < mPosList->size()) {
setPos(mPosList->at(mI));
std::cout << mPosList->at(mI).x() << "---" << mPosList->at(mI).y() << "---" << x() << "---" << y() << std::endl;
mI++;
} else {
finished = true;
emit animationFinished();
}
} else {
//! [4]
// Don't move too far away
//! [5]
QLineF lineToCenter(QPointF(0, 0), mapFromScene(0, 0));
if (lineToCenter.length() > 150) {
qreal angleToCenter = ::acos(lineToCenter.dx() / lineToCenter.length());
if (lineToCenter.dy() < 0)
angleToCenter = TwoPi - angleToCenter;
angleToCenter = normalizeAngle((Pi - angleToCenter) + Pi / 2);
if (angleToCenter < Pi && angleToCenter > Pi / 4) {
// Rotate left
angle += (angle < -Pi / 2) ? 0.25 : -0.25;
} else if (angleToCenter >= Pi && angleToCenter < (Pi + Pi / 2 + Pi / 4)) {
// Rotate right
angle += (angle < Pi / 2) ? 0.25 : -0.25;
}
} else if (::sin(angle) < 0) {
angle += 0.25;
} else if (::sin(angle) > 0) {
angle -= 0.25;
//! [5] //! [6]
}
//! [6]
// Try not to crash with any other mice
//! [7]
QList<QGraphicsItem *> dangerMice = scene()->items(QPolygonF()
<< mapToScene(0, 0)
<< mapToScene(-30, -50)
<< mapToScene(30, -50));
foreach (QGraphicsItem *item, dangerMice) {
if (item == this)
continue;
QLineF lineToMouse(QPointF(0, 0), mapFromItem(item, 0, 0));
qreal angleToMouse = ::acos(lineToMouse.dx() / lineToMouse.length());
if (lineToMouse.dy() < 0)
angleToMouse = TwoPi - angleToMouse;
angleToMouse = normalizeAngle((Pi - angleToMouse) + Pi / 2);
if (angleToMouse >= 0 && angleToMouse < Pi / 2) {
// Rotate right
angle += 0.5;
} else if (angleToMouse <= TwoPi && angleToMouse > (TwoPi - Pi / 2)) {
// Rotate left
angle -= 0.5;
//! [7] //! [8]
}
//! [8] //! [9]
}
//! [9]
// Add some random movement
//! [10]
if (dangerMice.size() > 1 && (qrand() % 10) == 0) {
if (qrand() % 1)
angle += (qrand() % 100) / 500.0;
else
angle -= (qrand() % 100) / 500.0;
}
//! [10]
//! [11]
speed += (-50 + qrand() % 100) / 100.0;
qreal dx = ::sin(angle) * 10;
mouseEyeDirection = (qAbs(dx / 5) < 1) ? 0 : dx / 5;
setRotation(rotation() + dx);
setPos(mapToParent(0, -(3 + sin(speed) * 3)));
std::cout << QTime().elapsed() << ":" << data(0).toString().toLocal8Bit().constData() << ":" << x() << ":" << y() <<std::endl;
}
}
void Transformable::rotate(float degrees) {
setRotation(m_rotation + degrees);
}
