/*************************************************************************
Handler for mouse button down events
*************************************************************************/
void FrameWindow::onMouseButtonDown(MouseEventArgs& e)
{
// default processing (this is now essential as it controls event firing).
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
if (isSizingEnabled())
{
// get position of mouse as co-ordinates local to this window.
Point localPos(CoordConverter::screenToWindow(*this, e.position));
// if the mouse is on the sizing border
if (getSizingBorderAtPoint(localPos) != SizingNone)
{
// ensure all inputs come to us for now
if (captureInput())
{
// setup the 'dragging' state variables
d_beingSized = true;
d_dragPoint = localPos;
e.handled = true;
}
}
}
}
}
bool eventFilter(QObject *watched, QEvent *event) {
if (event->type() == QEvent::MouseButtonDblClick ||
event->type() == QEvent::MouseButtonPress ||
event->type() == QEvent::MouseButtonRelease) {
auto ev = static_cast<QMouseEvent*>(event);
if (ev->button() == Qt::RightButton) {
auto buttons = ev->buttons();
if (buttons & Qt::RightButton) {
buttons ^= Qt::RightButton;
buttons |= Qt::LeftButton;
}
QMouseEvent lev{ev->type(),
ev->localPos(),
ev->windowPos(),
ev->screenPos(),
Qt::LeftButton,
buttons,
ev->modifiers(),
ev->source()};
Q_ASSERT(! (lev.buttons() & Qt::RightButton));
QCoreApplication::sendEvent(watched, &lev);
return true;
}
}
return QObject::eventFilter(watched, event);
}
// |----------------------------------------------------------------------------|
// | Logic() |
// |----------------------------------------------------------------------------|
bool Player::Logic() {
DebugLog ("Player: Logic() called.", DB_LOGIC, 10);
// If crashed, don't process
if (m_crashed) return true;
// Get time for this frame
float time = TimerManager::GetRef()->GetTime() / 1000;
// TODO: Get player input (Update direction, speed), set camera based on this
// For now, keep using mouselookcamera and get it from the camera
Camera* camera = GraphicsManager::GetRef()->GetCamera();
Coord cameraOrientation = camera->GetOrientation();
SetOrientation(Coord(
0.0f+cameraOrientation.y*3.14/180,
-1*(3.14f/6.0f)+cameraOrientation.x*3.14/180,
0.0f+cameraOrientation.z*3.14/180));
// Ship just stays with the camera
Coord localPos(
10.0f*sin(3.14/2-cameraOrientation.x*3.14/180-1*(3.14f/16.0f))*sin(cameraOrientation.y*3.14/180),
-10.0f*cos(3.14/2-cameraOrientation.x*3.14/180-1*(3.14f/16.0f)),
10.0f*sin(3.14/2-cameraOrientation.x*3.14/180-1*(3.14f/16.0f))*cos(cameraOrientation.y*3.14/180) );
Coord unbounded = localPos + camera->GetPosition();
m_linearVelocity = unbounded - m_position;
SetPosition(unbounded);
localPos = Coord(
9.3f*sin(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f))*sin(cameraOrientation.y*3.14/180-0.6*(3.14f/32.0f)),
-9.3f*cos(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f)),
9.3f*sin(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f))*cos(cameraOrientation.y*3.14/180-0.6*(3.14f/32.0f)) );
m_leftThruster->SetPosition(localPos+camera->GetPosition());
localPos = Coord(
9.3f*sin(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f))*sin(cameraOrientation.y*3.14/180+0.6*(3.14f/32.0f)),
-9.3f*cos(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f)),
9.3f*sin(3.14/2-cameraOrientation.x*3.14/180-1.25*(3.14f/16.0f))*cos(cameraOrientation.y*3.14/180+0.6*(3.14f/32.0f)) );
m_rightThruster->SetPosition(localPos+camera->GetPosition());
// Alternate controlling method:
//Coord unbounded(camera->GetPosition()+Coord(0.0f,-2.0f,10.0f));
// If the position gets too far from the camera direction vector, move it to that point.
// Need bounding points to left, right, up, and down.
// Need to keep ship a certain distance from camera...
// TODO: Update velocity of thrusters to shoot backwards
Coord thrusterVel = Coord(
sin(3.14/2-camera->GetOrientation().x*3.14/180+1.25*(3.14f/16.0f))*sin(camera->GetOrientation().y*3.14/180),
-1*cos(3.14/2-camera->GetOrientation().x*3.14/180+1.25*(3.14f/16.0f)),
sin(3.14/2-camera->GetOrientation().x*3.14/180+1.25*(3.14f/16.0f))*cos(camera->GetOrientation().y*3.14/180) );
thrusterVel *= -2.0f;
m_leftThruster->SetParticleVelocity(thrusterVel);
m_rightThruster->SetParticleVelocity(thrusterVel);
// Call logic functions for child objects
m_ship->Logic();
m_leftThruster->Logic();
m_rightThruster->Logic();
return true;
}
unsigned int Forest::onCollideJumper(unsigned int id, Matrix4f* matrix, void* data)
{
Forest* __this = reinterpret_cast<Forest*>( data );
// determine obb of instance
NxBox instanceOBB = calculateOBB(
__this->_canopyBatch->getBatchScheme()->lodGeometry[0],
*matrix,
__this->_desc.collScale
);
__this->_debugBoxes.push_back( instanceOBB );
// collide obbs
if( NxBoxBoxIntersect( instanceOBB, __this->_jumperOBB ) )
{
Jumper* jumper = dynamic_cast<Jumper*>( __this->_currentJumper );
// add impulse to jumper body
NxVec3 linearVelocity = __this->_currentJumperActor->getLinearVelocity();
NxVec3 impulse = linearVelocity * getCore()->getRandToolkit()->getUniform( __this->_desc.minImpulseFactor, __this->_desc.maxImpulseFactor ) * -1;
NxVec3 localPos(
__this->_jumperOBB.extents.x * getCore()->getRandToolkit()->getUniform( -1, 1 ),
__this->_jumperOBB.extents.y * getCore()->getRandToolkit()->getUniform( -1, 1 ),
__this->_jumperOBB.extents.z * getCore()->getRandToolkit()->getUniform( -1, 1 )
);
__this->_currentJumperActor->addForceAtLocalPos( impulse, localPos, NX_IMPULSE );
// damage jumper
jumper->damage( __this->_desc.damageFactor * impulse.magnitude(), 0.0f, linearVelocity.magnitude() );
// play rustle sound
__this->playRustleSound( __this->_currentJumperCollision->getFrame()->getPos() );
}
return id;
}
/*************************************************************************
Handler for when mouse button is pressed
*************************************************************************/
void Listbox::onMouseButtonDown(MouseEventArgs& e)
{
// base class processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
bool modified = false;
// clear old selections if no control key is pressed or if multi-select is off
if (!(e.sysKeys & Control) || !d_multiselect)
{
modified = clearAllSelections_impl();
}
Point localPos(screenToWindow(e.position));
if (getMetricsMode() == Relative)
{
localPos = relativeToAbsolute(localPos);
}
ListboxItem* item = getItemAtPoint(localPos);
if (item != NULL)
{
modified = true;
// select range or item, depending upon keys and last selected item
if (((e.sysKeys & Shift) && (d_lastSelected != NULL)) && d_multiselect)
{
selectRange(getItemIndex(item), getItemIndex(d_lastSelected));
}
else
{
item->setSelected(item->isSelected() ^ true);
}
// update last selected item
d_lastSelected = item->isSelected() ? item : NULL;
}
// fire event if needed
if (modified)
{
WindowEventArgs args(this);
onSelectionChanged(args);
}
e.handled = true;
}
}
void NzGeneratePlane(const NzVector2ui& subdivision, const NzVector2f& size, const NzMatrix4f& matrix, const NzRectf& textureCoords, NzMeshVertex* vertices, NzIndexIterator indices, NzBoxf* aabb, unsigned int indexOffset)
{
// Pour plus de facilité, on va construire notre plan en considérant que la normale est de 0,1,0
// Et appliquer ensuite une matrice "finissant le travail"
// Le nombre de faces appartenant à un axe est équivalent à 2 exposant la subdivision (1,2,4,8,16,32,...)
unsigned int horizontalFaceCount = (1 << subdivision.x);
unsigned int verticalFaceCount = (1 << subdivision.y);
// Et le nombre de sommets est ce nombre ajouté de 1 (2,3,5,9,17,33,...)
unsigned int horizontalVertexCount = horizontalFaceCount + 1;
unsigned int verticalVertexCount = verticalFaceCount + 1;
NzVector3f normal(NzVector3f::UnitY());
normal = matrix.Transform(normal, 0.f);
normal.Normalize();
NzVector3f tangent(1.f, 1.f, 0.f);
tangent = matrix.Transform(tangent, 0.f);
tangent.Normalize();
float halfSizeX = size.x / 2.f;
float halfSizeY = size.y / 2.f;
float invHorizontalVertexCount = 1.f/(horizontalVertexCount-1);
float invVerticalVertexCount = 1.f/(verticalVertexCount-1);
for (unsigned int x = 0; x < horizontalVertexCount; ++x)
{
for (unsigned int y = 0; y < verticalVertexCount; ++y)
{
NzVector3f localPos((2.f*x*invHorizontalVertexCount - 1.f) * halfSizeX, 0.f, (2.f*y*invVerticalVertexCount - 1.f) * halfSizeY);
vertices->position = matrix * localPos;
vertices->uv.Set(textureCoords.x + x*invHorizontalVertexCount*textureCoords.width, textureCoords.y + y*invVerticalVertexCount*textureCoords.height);
vertices->normal = normal;
vertices->tangent = tangent;
vertices++;
if (x != horizontalVertexCount-1 && y != verticalVertexCount-1)
{
*indices++ = (x+0)*verticalVertexCount + y + 0 + indexOffset;
*indices++ = (x+0)*verticalVertexCount + y + 1 + indexOffset;
*indices++ = (x+1)*verticalVertexCount + y + 0 + indexOffset;
*indices++ = (x+1)*verticalVertexCount + y + 0 + indexOffset;
*indices++ = (x+0)*verticalVertexCount + y + 1 + indexOffset;
*indices++ = (x+1)*verticalVertexCount + y + 1 + indexOffset;
}
}
}
if (aabb)
aabb->Set(matrix.Transform(NzVector3f(-halfSizeX, 0.f, -halfSizeY), 0.f), matrix.Transform(NzVector3f(halfSizeX, 0.f, halfSizeY), 0.f));
}
/*************************************************************************
Handler for mouse movement events
*************************************************************************/
void ComboDropList::onMouseMove(MouseEventArgs& e)
{
Listbox::onMouseMove(e);
// if mouse is within our area (but not our children)
if (isHit(e.position))
{
if (!getChildAtPosition(e.position))
{
// handle auto-arm
if (d_autoArm)
{
d_armed = true;
}
if (d_armed)
{
//
// Convert mouse position to absolute window pixels
//
Point localPos(CoordConverter::screenToWindow(*this, e.position));
// check for an item under the mouse
ListboxItem* selItem = getItemAtPoint(localPos);
// if an item is under mouse, select it
if (selItem)
{
setItemSelectState(selItem, true);
}
else
{
clearAllSelections();
}
}
}
e.handled = true;
}
// not within the list area
else
{
// if left mouse button is down, clear any selection
if (e.sysKeys & LeftMouse)
{
clearAllSelections();
}
}
}
void ImageNode::getElementsByPos(const glm::vec2& pos, vector<NodePtr>& pElements)
{
if (reactsToMouseEvents()) {
OffscreenCanvasPtr pCanvas = m_pGPUImage->getCanvas();
if (pCanvas && pCanvas->getHandleEvents()) {
glm::vec2 nodeSize(getSize());
glm::vec2 canvasSize(pCanvas->getSize());
glm::vec2 localPos(pos.x*(canvasSize.x/nodeSize.x),
pos.y*(canvasSize.y/nodeSize.y));
pCanvas->getRootNode()->getElementsByPos(localPos, pElements);
}
RasterNode::getElementsByPos(pos, pElements);
}
}
void SimpleLightSource::valueChanged(Value *value) {
LightSource::valueChanged(value);
if(value == 0) {
return;
}
if(value == mCenterBrightness) {
updateLightCone();
}
else if(value == mRadius) {
CylinderGeom *geom = dynamic_cast<CylinderGeom*>
(mBodyCollisionObject->getGeometry());
if(geom != 0) {
geom->setRadius(mRadius->get());
}
}
else if(value == mHideLightCone) {
updateLightCone();
}
else if(value == mLightColor) {
updateLightCone();
}
else if(mReferenceObject != 0
&& (value == mReferenceObject->getPositionValue()
|| value == mReferenceObject->getQuaternionOrientationValue()))
{
// TODO change this? see Test line 247
//
Quaternion localPos(
0.0,
mLocalPosition->getX(),
mLocalPosition->getY(),
mLocalPosition->getZ()
);
Quaternion bodyOrientationInverse = mReferenceObject->
getQuaternionOrientationValue()->get().getInverse();
Quaternion rotatedLocalPosQuat = mReferenceObject->
getQuaternionOrientationValue()->get() * localPos *
bodyOrientationInverse;
Vector3D rotatedLocalPos(
rotatedLocalPosQuat.getX(),
rotatedLocalPosQuat.getY(),
rotatedLocalPosQuat.getZ()
);
mPositionValue->set(mReferenceObject->
getPositionValue()->get() + rotatedLocalPos);
}
}
bool GUIWidget::inBounds(const Vector2I& position) const
{
Viewport* target = getTarget();
if (target == nullptr)
return false;
// Technically GUI widget bounds can be larger than the viewport, so make sure we clip to viewport first
if(!target->getArea().contains(position))
return false;
Vector3 vecPos((float)position.x, (float)position.y, 0.0f);
vecPos = mTransform.inverse().multiplyAffine(vecPos);
Vector2I localPos(Math::roundToInt(vecPos.x), Math::roundToInt(vecPos.y));
return mBounds.contains(localPos);
}
bool ApResourceUnit::_AddImagePanelToRightBottom(const MkHashStr& name, const MkPathName& imgPath, const MkHashStr& ssName, float localDepth)
{
if (m_SceneNode == NULL)
return true;
if (!_AddImagePanel(name, imgPath, ssName, localDepth))
return false;
MkPanel& panel = *m_SceneNode->GetPanel(name);
const MkFloat2& indexSize = panel.GetPanelSize();
MkFloat2 localPos(ApStaticDefinition::Instance().GetResourceTileSize().x - indexSize.x, 0.f); // right bottom
localPos += MkFloat2(-5.f, 5.f); // offset
localPos -= ApStaticDefinition::Instance().GetResourceTileSize() * 0.5f; // pivot to center
panel.SetLocalPosition(localPos);
return true;
}
/**
* Called when a parameter Value changed.
* @param value the value that changed.
*/
void WavefrontBody::valueChanged(Value *value) {
SimBody::valueChanged(value);
if(value == 0) {
return;
}
else if(mReferenceObject != 0
&& (value == mReferenceObject->getPositionValue()
|| value == mReferenceObject->getQuaternionOrientationValue()))
{
Quaternion localPos(0.0,
mLocalPosition->getX(),
mLocalPosition->getY(),
mLocalPosition->getZ());
Quaternion bodyOrientationInverse =
mReferenceObject->getQuaternionOrientationValue()->get().getInverse();
Quaternion rotatedLocalPosQuat = mReferenceObject->getQuaternionOrientationValue()->get()
* localPos * bodyOrientationInverse;
Vector3D rotatedLocalPos(rotatedLocalPosQuat.getX(),
rotatedLocalPosQuat.getY(),
rotatedLocalPosQuat.getZ());
mPositionValue->set(mReferenceObject->getPositionValue()->get() + rotatedLocalPos);
}
else if(mReferenceObject != 0 && value == mReferenceObject->getOrientationValue()) {
Vector3D orientation = mReferenceObject->getOrientationValue()->get() + mLocalOrientation->get();
while(orientation.getX() > 180.0) {
orientation.setX(orientation.getX() - 360.0);
}
while(orientation.getX() < -180.0) {
orientation.setX(orientation.getX() + 360.0);
}
while(orientation.getY() > 180.0) {
orientation.setY(orientation.getY() - 360.0);
}
while(orientation.getY() < -180.0) {
orientation.setY(orientation.getY() + 360.0);
}
while(orientation.getZ() > 180.0) {
orientation.setZ(orientation.getZ() - 360.0);
}
while(orientation.getZ() < -180.0) {
orientation.setZ(orientation.getZ() + 360.0);
}
getOrientationValue()->set(orientation);
}
}
void btWorldFactory::createRuins(QVariantList &shapesList, double areaX, double areaZ, btVector3 pos, btVector3 boxMin, btVector3 boxMax, int nbBoxes, double density) {
// Ruin Floor
for(int i=0;i<nbBoxes;++i){
btVector3 size(Tools::random((double)boxMin.x(), (double)boxMax.x()),
Tools::random((double)boxMin.y(), (double)boxMax.y()),
Tools::random((double)boxMin.z(), (double)boxMax.z()));
btVector3 localPos(Tools::random((double)-areaX/2.0, (double)areaX/2.0),
size.y()/2.0,
Tools::random(-areaZ/2.0, areaZ/2.0));
btVector3 euler(Tools::random(-SIMD_PI, SIMD_PI),
Tools::random(-SIMD_PI, SIMD_PI),
Tools::random(-SIMD_PI, SIMD_PI));
createBox(shapesList,size,pos + localPos, euler, density);
}
}
//--------------------------------------------------------------------
// setWorldPosition()
//--------------------------------------------------------------------
void LLJoint::setWorldPosition( const LLVector3& pos )
{
if (mParent == NULL)
{
this->setPosition( pos );
return;
}
LLMatrix4a temp_matrix = getWorldMatrix();
temp_matrix.setTranslate_affine(pos);
LLMatrix4a invParentWorldMatrix = mParent->getWorldMatrix();
invParentWorldMatrix.invert();
invParentWorldMatrix.mul(temp_matrix);
LLVector3 localPos( invParentWorldMatrix.getRow<LLMatrix4a::ROW_TRANS>().getF32ptr() );
setPosition( localPos );
}
/*************************************************************************
Handler for when mouse buttons are pushed
*************************************************************************/
void ListHeaderSegment::onMouseButtonDown(MouseEventArgs& e)
{
// base class processing
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
// ensure all inputs come to us for now
if (captureInput())
{
// get position of mouse as co-ordinates local to this window.
Point localPos(CoordConverter::screenToWindow(*this, e.position));
// store drag point for possible sizing or moving operation.
d_dragPoint = localPos;
// if the mouse is in the sizing area
if (d_splitterHover)
{
if (isSizingEnabled())
{
// setup the 'dragging' state variables
d_dragSizing = true;
}
}
else
{
d_segmentPushed = true;
}
}
++e.handled;
}
}
Grid* Grid::createGridFromId(int potencialId, const std::list<Piece*> pieces) {
Grid *grid = new Grid(pieces);
bool fakeResult = false;
if (!fakeResult) {
int id = potencialId;
for (auto piece : pieces) {
int localId = id % (GRID_X*GRID_Y);
GridPos localPos(localId / GRID_X, localId%GRID_Y);
if (grid->pieceInPos(localPos) != NULL) {
Analytics::reportEvent("Invalid id for grid creation");
delete grid;
return NULL;
}
grid->setPieceToPos(piece, localPos);
id = id / (GRID_X*GRID_Y);
}
}
else {
GridPos fixedPositions[6];
fixedPositions[0].set(4,2);
fixedPositions[1].set(0,4);
fixedPositions[2].set(0,3);
fixedPositions[3].set(0,2);
fixedPositions[4].set(0,1);
fixedPositions[5].set(0,0);
int i=0;
for (auto piece : pieces) {
grid->setPieceToPos(piece, fixedPositions[i++]);
}
}
return grid;
}
//--------------------------------------------------------------------
// setWorldPosition()
//--------------------------------------------------------------------
void LLJoint::setWorldPosition( const LLVector3& pos )
{
if (mParent == NULL)
{
this->setPosition( pos );
return;
}
LLMatrix4 temp_matrix = getWorldMatrix();
temp_matrix.mMatrix[VW][VX] = pos.mV[VX];
temp_matrix.mMatrix[VW][VY] = pos.mV[VY];
temp_matrix.mMatrix[VW][VZ] = pos.mV[VZ];
LLMatrix4 parentWorldMatrix = mParent->getWorldMatrix();
LLMatrix4 invParentWorldMatrix = parentWorldMatrix.invert();
temp_matrix *= invParentWorldMatrix;
LLVector3 localPos( temp_matrix.mMatrix[VW][VX],
temp_matrix.mMatrix[VW][VY],
temp_matrix.mMatrix[VW][VZ] );
setPosition( localPos );
}
/*************************************************************************
Handler for when mouse button is pressed
*************************************************************************/
void Tree::onMouseButtonDown(MouseEventArgs& e)
{
// base class processing
// populateGeometryBuffer();
Window::onMouseButtonDown(e);
if (e.button == LeftButton)
{
//bool modified = false;
Vector2f localPos(CoordConverter::screenToWindow(*this, e.position));
// Point localPos(screenToWindow(e.position));
TreeItem* item = getItemAtPoint(localPos);
if (item != 0)
{
//modified = true;
TreeEventArgs args(this);
args.treeItem = item;
populateGeometryBuffer();
Rectf buttonLocation = item->getButtonLocation();
if ((localPos.d_x >= buttonLocation.left()) && (localPos.d_x <= buttonLocation.right()) &&
(localPos.d_y >= buttonLocation.top()) && (localPos.d_y <= buttonLocation.bottom()))
{
item->toggleIsOpen();
if (item->getIsOpen())
{
TreeItem *lastItemInList = item->getTreeItemFromIndex(item->getItemCount() - 1);
ensureItemIsVisible(lastItemInList);
ensureItemIsVisible(item);
onBranchOpened(args);
}
else
{
onBranchClosed(args);
}
// Update the item screen locations, needed to update the scrollbars.
// populateGeometryBuffer();
// Opened or closed a tree branch, so must update scrollbars.
configureScrollbars();
}
else
{
// clear old selections if no control key is pressed or if multi-select is off
if (!(e.sysKeys & Control) || !d_multiselect)
clearAllSelections_impl();
// select range or item, depending upon keys and last selected item
#if 0 // TODO: fix this
if (((e.sysKeys & Shift) && (d_lastSelected != 0)) && d_multiselect)
selectRange(getItemIndex(item), getItemIndex(d_lastSelected));
else
#endif
item->setSelected(item->isSelected() ^ true);
// update last selected item
d_lastSelected = item->isSelected() ? item : 0;
onSelectionChanged(args);
}
}
else
{
// clear old selections if no control key is pressed or if multi-select is off
if (!(e.sysKeys & Control) || !d_multiselect)
{
if (clearAllSelections_impl())
{
// Changes to the selections were actually made
TreeEventArgs args(this);
args.treeItem = item;
onSelectionChanged(args);
}
}
}
++e.handled;
}
}
void AccelSensor::updateSensorValues() {
if(mHostBody == 0) {
return;
}
if(mTimeStepSize->get() == 0.0) {
Core::log("AccelSensor warning: Time step size was 0.0, prevented division by zero.");
return;
}
Quaternion localPos(0.0,
mLocalPosition->getX(),
mLocalPosition->getY(),
mLocalPosition->getZ());
Quaternion bodyOrientationInverse =
mHostBody->getQuaternionOrientationValue()->get().getInverse();
Quaternion rotatedLocalPosQuat = mHostBody->getQuaternionOrientationValue()->get()
* localPos * bodyOrientationInverse;
Vector3D rotatedLocalPos(rotatedLocalPosQuat.getX(),
rotatedLocalPosQuat.getY(),
rotatedLocalPosQuat.getZ());
mPosition = mHostBody->getPositionValue()->get() + rotatedLocalPos;
mVelocity = (mPosition - mLastPosition) * (1.0 / mTimeStepSize->get());
mAcceleration = (mVelocity - mLastVelocity) * (1.0 / mTimeStepSize->get());
mAcceleration.setY(mAcceleration.getY() + mGravitation);
Quaternion bodyRotation = mHostBody->getQuaternionOrientationValue()->get();
bodyRotation.normalize();
Quaternion bodyRotationInverse = bodyRotation.getInverse();
bodyRotationInverse.normalize();
//Axis 1
Quaternion xAxisQuat(0.0,
mSensorAxisOne.getX(),
mSensorAxisOne.getY(),
mSensorAxisOne.getZ());
Quaternion xAxisRotatedQuat = bodyRotation * xAxisQuat * bodyRotationInverse;
mRotatedSensorAxisOne.set(xAxisRotatedQuat.getX(),
xAxisRotatedQuat.getY(),
xAxisRotatedQuat.getZ());
//Axis 2
Quaternion yAxisQuat(0.0,
mSensorAxisTwo.getX(),
mSensorAxisTwo.getY(),
mSensorAxisTwo.getZ());
Quaternion yAxisRotatedQuat = bodyRotation * yAxisQuat * bodyRotationInverse;
mRotatedSensorAxisTwo.set(yAxisRotatedQuat.getX(),
yAxisRotatedQuat.getY(),
yAxisRotatedQuat.getZ());
//Axis 3
Quaternion zAxisQuat(0.0,
mSensorAxisThree.getX(),
mSensorAxisThree.getY(),
mSensorAxisThree.getZ());
Quaternion zAxisRotatedQuat = bodyRotation * zAxisQuat * bodyRotationInverse;
mRotatedSensorAxisThree.set(zAxisRotatedQuat.getX(),
zAxisRotatedQuat.getY(),
zAxisRotatedQuat.getZ());
double sensorValue1 = mAcceleration.getX() * xAxisRotatedQuat.getX()
+ mAcceleration.getY() * xAxisRotatedQuat.getY()
+ mAcceleration.getZ() * xAxisRotatedQuat.getZ();
sensorValue1 = -1 * sensorValue1;
double sensorValue2 = mAcceleration.getX() * yAxisRotatedQuat.getX()
+ mAcceleration.getY() * yAxisRotatedQuat.getY()
+ mAcceleration.getZ() * yAxisRotatedQuat.getZ();
sensorValue2 = -1 * sensorValue2;
double sensorValue3 = mAcceleration.getX() * zAxisRotatedQuat.getX()
+ mAcceleration.getY() * zAxisRotatedQuat.getY()
+ mAcceleration.getZ() * zAxisRotatedQuat.getZ();
sensorValue3 = -1 * sensorValue3;
// freeze all sensorValues if one of them exceeds the maximum value.
if(fabs(sensorValue1) > mMaxSensorValue
|| (fabs(sensorValue2) > mMaxSensorValue && mNumberOfAxes > 1)
|| (fabs(sensorValue3) > mMaxSensorValue && mNumberOfAxes > 2))
{
sensorValue1 = mLastAxisOneMeasurement;
sensorValue2 = mLastAxisTwoMeasurement;
sensorValue3 = mLastAxisThreeMeasurement;
}
else {
mLastAxisOneMeasurement = sensorValue1;
mLastAxisTwoMeasurement = sensorValue2;
mLastAxisThreeMeasurement = sensorValue3;
}
if(mValueOneHistory.size() >= mLowPassFilterDelay) {
mValueOneHistory.pop_front();
mValueTwoHistory.pop_front();
mValueThreeHistory.pop_front();
}
mValueOneHistory.push_back(sensorValue1);
mValueTwoHistory.push_back(sensorValue2);
mValueThreeHistory.push_back(sensorValue3);
// perform low pass filtering
QList<double> result = calculateFilteredSensorValues(sensorValue1, sensorValue2, sensorValue3);
sensorValue1 = result.at(0);
sensorValue2 = result.at(1);
sensorValue3 = result.at(2);
// add noise
sensorValue1 = Math::calculateGaussian(sensorValue1, mGlobalNoiseDeviation);
sensorValue2 = Math::calculateGaussian(sensorValue2, mGlobalNoiseDeviation);
sensorValue3 = Math::calculateGaussian(sensorValue3, mGlobalNoiseDeviation);
mFirstSensorValue->set(sensorValue1);
mSecondSensorValue->set(sensorValue2);
mThirdSensorValue->set(sensorValue3);
mLastVelocity = mVelocity;
mLastPosition = mPosition;
}
void AccelSensor::setup() {
SimObject::setup();
if(mInitialized == false) {
mHostBody = Physics::getPhysicsManager()->getSimBody(mReferenceBodyName->get());
if(mHostBody == 0) {
Core::log("AccelSensor: Sensor has no valid reference body. Name was ["
+ mReferenceBodyName->get() + "]! Ignoring", true);
return;
}
createSensor();
mFirstSensorValue->set(0.0);
mSecondSensorValue->set(0.0);
mThirdSensorValue->set(0.0);
mTimeStepSize = dynamic_cast<DoubleValue*>(Core::getInstance()->
getValueManager()->getValue(SimulationConstants::VALUE_TIME_STEP_SIZE));
DoubleValue *mGravitationValue = dynamic_cast<DoubleValue*>(Core::getInstance()->
getValueManager()->getValue("/Simulation/Gravitation"));
if(mTimeStepSize == 0 || mGravitationValue == 0) {
Core::log("AccelSensor: Required Event or Value could not be found.");
return;
}
mGravitation = mGravitationValue->get();
mLastAxisOneMeasurement = 0.0;
mLastAxisTwoMeasurement = 0.0;
mLastAxisThreeMeasurement = 0.0;
mInitialized = true;
}
// rotate chosen axis about the localRotation of this sensor
Quaternion localOrientation = mLocalOrientation->get();
localOrientation.normalize();
mLocalOrientation->set(localOrientation);
Quaternion localOrientationInverse = localOrientation.getInverse();
localOrientationInverse.normalize();
Quaternion xAxis(0.0,
mSensorAxisOneValue->getX(),
mSensorAxisOneValue->getY(),
mSensorAxisOneValue->getZ());
Quaternion xAxisRotated = localOrientation * xAxis * localOrientationInverse;
mSensorAxisOne.set(xAxisRotated.getX(), xAxisRotated.getY(), xAxisRotated.getZ());
mRotatedSensorAxisOne.set(xAxisRotated.getX(),
xAxisRotated.getY(),
xAxisRotated.getZ());
Quaternion yAxis(0.0,
mSensorAxisTwoValue->getX(),
mSensorAxisTwoValue->getY(),
mSensorAxisTwoValue->getZ());
Quaternion yAxisRotated = localOrientation * yAxis * localOrientationInverse;
mSensorAxisTwo.set(yAxisRotated.getX(), yAxisRotated.getY(), yAxisRotated.getZ());
mRotatedSensorAxisTwo.set(yAxisRotated.getX(),
yAxisRotated.getY(),
yAxisRotated.getZ());
Quaternion zAxis(0.0,
mSensorAxisThreeValue->getX(),
mSensorAxisThreeValue->getY(),
mSensorAxisThreeValue->getZ());
Quaternion zAxisRotated = localOrientation * zAxis * localOrientationInverse;
mSensorAxisThree.set(zAxisRotated.getX(), zAxisRotated.getY(), zAxisRotated.getZ());
mRotatedSensorAxisThree.set(zAxisRotated.getX(),
zAxisRotated.getY(),
zAxisRotated.getZ());
if(mSensorBody == 0 || mHostBody == 0) {
Core::log("AccelSensor: The sensor has no valid host or sensor-body.");
return;
}
mSensorBody->setTextureType("None");
mSensorBody->setFaceTexture(5, "AccelBoard");
mSensorGeometry->setLocalOrientation(mLocalOrientation->get());
mSensorBody->getGeometry()->setLocalPosition(mLocalPosition->get());
Quaternion localPos(0,
mLocalPosition->getX(),
mLocalPosition->getY(),
mLocalPosition->getZ());
Quaternion bodyOrientationInverse = mHostBody->getQuaternionOrientationValue()->get().getInverse();
Quaternion rotatedLocalPosQuat = mHostBody->getQuaternionOrientationValue()->get()
* localPos * bodyOrientationInverse;
Vector3D rotatedLocalPos(rotatedLocalPosQuat.getX(),
rotatedLocalPosQuat.getY(),
rotatedLocalPosQuat.getZ());
mLastPosition = mHostBody->getPositionValue()->get() + rotatedLocalPos;
if(mLowPassFilterDelayValue != 0) {
mLowPassFilterDelay = mLowPassFilterDelayValue->get();
}
mValueOneHistory.clear();
mValueTwoHistory.clear();
mValueThreeHistory.clear();
mGlobalNoiseDeviation = mGlobalNoiseDeviationValue->get();
}
void LayoutBox::layout() {
Layout::layout();
if (m_eDirection == CCLayoutBoxDirectionHorizontal)
{
// Get the maximum height
float maxHeight = 0;
for(auto it = _children.cbegin(); it != _children.cend(); ++it) {
float height = (*it)->getContentSize().height;
if (height > maxHeight) maxHeight = height;
}
// Position the nodes
float width = 0;
for(auto it = _children.cbegin(); it != _children.cend(); ++it) {
Size childSize = (*it)->getContentSize();
Point offset = (*it)->getAnchorPointInPoints();
Point localPos(roundf(width), roundf((maxHeight-childSize.height)/2.0f));
Point position = localPos + offset;
(*it)->setPosition(position);
// (*it)->setPositionType(CCPositionTypePoints);
width += childSize.width;
width += m_nSpacing;
}
// Account for last added increment
width -= m_nSpacing;
if (width < 0) width = 0;
this->setContentSize(Size(roundUpToEven(width), roundUpToEven(maxHeight)));
}
else
{
// Get the maximum height
float maxWidth = 0;
for(auto it = _children.cbegin(); it != _children.cend(); ++it) {
float width = (*it)->getContentSize().width;
if (width > maxWidth) maxWidth = width;
}
// Position the nodes
float height = 0;
for(auto it = _children.cbegin(); it != _children.cend(); ++it) {
Size childSize = (*it)->getContentSize();
Point offset = (*it)->getAnchorPointInPoints();
Point localPos(roundf((maxWidth-childSize.width)/2.0f), roundf(height));
Point position = localPos + offset;
(*it)->setPosition(position);
// (*it)->setPositionType(CCPositionTypePoints);
height += childSize.height;
height += m_nSpacing;
}
// Account for last added increment
height -= m_nSpacing;
if (height < 0) height = 0;
this->setContentSize(Size(roundUpToEven(maxWidth), roundUpToEven(height)));
}
}
