float EmberEntity::getHeight(const WFMath::Point<2>& localPosition) const { if (mHeightProvider) { float height = 0; if (mHeightProvider->getHeight(WFMath::Point<2>(localPosition.x(), localPosition.y()), height)) { return height; } } //A normal EmberEntity shouldn't know anything about the terrain, so we can't handle the area here. //Instead we just pass it on to the parent until we get to someone who knows how to handle this (preferably the terrain). if (getEmberLocation()) { WFMath::Point<2> adjustedLocalPosition(getPredictedPos().x(), getPredictedPos().y()); WFMath::Vector<3> xVec = WFMath::Vector<3>(1.0, 0.0, 0.0).rotate(getOrientation()); double theta = atan2(xVec.y(), xVec.x()); // rotation about Z WFMath::RotMatrix<2> rm; WFMath::Vector<2> adjustment(localPosition.x(), localPosition.y()); adjustment.rotate(rm.rotation(theta)); adjustedLocalPosition += adjustment; return getEmberLocation()->getHeight(adjustedLocalPosition) - getPredictedPos().z(); } WFMath::Point<3> predictedPos = getPredictedPos(); if (predictedPos.isValid()) { return predictedPos.z(); } else { return 0.0f; } }
void SizeAdapter::fillElementFromGui() { WFMath::AxisBox<3> axisBox; WFMath::Point<3> lowerPoint = axisBox.lowCorner(); WFMath::Point<3> upperPoint = axisBox.highCorner(); if (mWidgets.lowerXWindow) { lowerPoint.x() = atof(mWidgets.lowerXWindow->getText().c_str()); } if (mWidgets.lowerYWindow) { lowerPoint.y() = atof(mWidgets.lowerYWindow->getText().c_str()); } if (mWidgets.lowerZWindow) { lowerPoint.z() = atof(mWidgets.lowerZWindow->getText().c_str()); } if (mWidgets.upperXWindow) { upperPoint.x() = atof(mWidgets.upperXWindow->getText().c_str()); } if (mWidgets.upperYWindow) { upperPoint.y() = atof(mWidgets.upperYWindow->getText().c_str()); } if (mWidgets.upperZWindow) { upperPoint.z() = atof(mWidgets.upperZWindow->getText().c_str()); } axisBox.setCorners(lowerPoint, upperPoint); mEditedValue = axisBox.toAtlas(); }
ModelBlock::ModelBlock(Ogre::SceneNode* baseNode,const Carpenter::BuildingBlock* buildingBlock, Model::Model* model, Construction* construction) : mBuildingBlock(buildingBlock) , mModel(model) , mModelNode(0) , mConstruction(construction) { mNode = baseNode->createChildSceneNode(Convert::toOgre(buildingBlock->getPosition()), Convert::toOgre(buildingBlock->getOrientation())); mPointBillBoardSet = mNode->getCreator()->createBillboardSet( std::string("__construction_") + construction->getBluePrint()->getName() + "_" + buildingBlock->getName() + "_billboardset__" + mNode->getName()); mPointBillBoardSet->setDefaultDimensions(1, 1); mPointBillBoardSet->setMaterialName("carpenter/flare"); mPointBillBoardSet->setVisible(false); // Ogre::SceneNode* aNode = EmberOgre::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(); mNode->attachObject(mPointBillBoardSet); if (model) { JesusPickerObject* pickerObject = new JesusPickerObject(this, 0); model->setUserObject(pickerObject); mModelNode = mNode->createChildSceneNode(); mModelNode->attachObject(model); model->setQueryFlags(Jesus::CM_MODELBLOCK); //only autoscale the model if we've not set the scale in the modeldefinition //TODO: it would of course be best if all models were correctly scaled and this code could be removed if (model->getDefinition()->getScale() == 0) { const Ogre::AxisAlignedBox ogreBoundingBox = model->getBoundingBox(); const Ogre::Vector3 ogreMax = ogreBoundingBox.getMaximum(); const Ogre::Vector3 ogreMin = ogreBoundingBox.getMinimum(); const WFMath::AxisBox<3> wfBoundingBox = buildingBlock->getBuildingBlockSpec()->getBlockSpec()->getBoundingBox(); const WFMath::Point<3> wfMax = wfBoundingBox.highCorner(); const WFMath::Point<3> wfMin = wfBoundingBox.lowCorner(); Ogre::Real scaleX; Ogre::Real scaleY; Ogre::Real scaleZ; scaleX = fabs((wfMax.x() - wfMin.x()) / (ogreMax.x - ogreMin.x)); scaleY = fabs((wfMax.z() - wfMin.z()) / (ogreMax.y - ogreMin.y)); scaleZ = fabs((wfMax.y() - wfMin.y()) / (ogreMax.z - ogreMin.z)); mModelNode->setScale(scaleX, scaleY, scaleZ); } } }
void HeightMapUpdateTask::injectHeightMapSegmentsIntoHeightMap() { for (HeightMapSegmentStore::const_iterator I = mHeightMapSegments.begin(); I != mHeightMapSegments.end(); ++I) { WFMath::Point<2> position = I->first; IHeightMapSegment* heightMapSegment = I->second; mHeightMap.insert(position.x(), position.y(), heightMapSegment); } }
void PolygonPoint::setLocalPosition(const WFMath::Point<2>& position) { mNode->setPosition(position.x(), mNode->getPosition().y, -position.y()); if (mPolygon.getPositionProvider()) { Ogre::Vector3 pos = getNode()->getPosition(); pos.y = mPolygon.getPositionProvider()->getHeightForPosition(Convert::toWF<WFMath::Point<2>>(pos)); getNode()->setPosition(pos); } }
TerrainDefPointStore TerrainParser::parseTerrain(const Atlas::Message::Element& terrain, const WFMath::Point<3>& offset) const { //_fpreset(); if (!terrain.isMap()) { S_LOG_FAILURE("Terrain is not a map"); } const Atlas::Message::MapType & tmap = terrain.asMap(); Atlas::Message::MapType::const_iterator I = tmap.find("points"); if (I == tmap.end()) { S_LOG_FAILURE("No terrain points"); } Terrain::TerrainDefPointStore pointStore; if (I->second.isList()) { // Legacy support for old list format. const Atlas::Message::ListType& plist = I->second.asList(); Atlas::Message::ListType::const_iterator J = plist.begin(); for (; J != plist.end(); ++J) { if (!J->isList()) { S_LOG_INFO("Non list in points"); continue; } const Atlas::Message::ListType & point = J->asList(); if (point.size() != 3) { S_LOG_INFO("Point without 3 nums."); continue; } Terrain::TerrainDefPoint defPoint(static_cast<int> (point[0].asNum() + offset.x()), static_cast<int> (point[1].asNum() + offset.y()), static_cast<float> (point[3].asNum() + offset.z())); pointStore.push_back(defPoint); } } else if (I->second.isMap()) { const Atlas::Message::MapType& plist = I->second.asMap(); Atlas::Message::MapType::const_iterator J = plist.begin(); for (; J != plist.end(); ++J) { if (!J->second.isList()) { S_LOG_INFO("Non list in points."); continue; } const Atlas::Message::ListType & point = J->second.asList(); if (point.size() != 3) { S_LOG_INFO("Point without 3 nums."); continue; } int x = static_cast<int> (point[0].asNum()); int y = static_cast<int> (point[1].asNum()); float z = point[2].asNum(); Terrain::TerrainDefPoint defPoint(x + offset.x(), y + offset.y(), z + offset.z()); pointStore.push_back(defPoint); } } else { S_LOG_FAILURE("Terrain is the wrong type"); } return pointStore; }
bool SizeAdapter::slider_ValueChanged(const CEGUI::EventArgs& e) { float value = mWidgets.scaler->getCurrentValue(); WFMath::AxisBox<3> newBox; try { newBox.fromAtlas(mOriginalValue); } catch (...) { newBox = WFMath::AxisBox<3>(WFMath::Point<3>(-0.5f, -0.5f, -0.5f), WFMath::Point<3>(0.5, 0.5, 0.5)); } WFMath::Point<3> lowerPoint = newBox.lowCorner(); WFMath::Point<3> upperPoint = newBox.highCorner(); lowerPoint.x() *= value; lowerPoint.y() *= value; lowerPoint.z() *= value; upperPoint.x() *= value; upperPoint.y() *= value; upperPoint.z() *= value; newBox.setCorners(lowerPoint, upperPoint); // newBox *= value; updateGui(newBox.toAtlas()); return true; }
/** * @brief Updates the marker, and any line drawn to it. */ void updateMarker() { //Check if we should adjust to the height of the world WFMath::Point<3> adjustedPoint(mPoint); float height = adjustedPoint.z(); if (mHeightProvider.getHeight(TerrainPosition(mPoint.x(), mPoint.y()), height)) { adjustedPoint.z() = height; } mMarkerNode->setPosition(Convert::toOgre(adjustedPoint)); WFMath::Segment<3> shape(adjustedPoint, mEntity.getViewPosition() + WFMath::Vector<3>(mEntity.getBBox().getCenter())); mMarkerDirectionIndicator->update(shape); }
void SoundService::updateListenerPosition(const WFMath::Point<3>& pos, const WFMath::Vector<3>& direction, const WFMath::Vector<3>& up) { if (!isEnabled()) { return; } alListener3f(AL_POSITION, pos.x(), pos.y(), pos.z()); SoundGeneral::checkAlError("Setting the listener position."); //Set the direction of the listener. ALfloat aluVectors[6]; aluVectors[0] = direction.x(); aluVectors[1] = direction.y(); aluVectors[2] = direction.z(); aluVectors[3] = up.x(); aluVectors[4] = up.y(); aluVectors[5] = up.z(); alListenerfv(AL_ORIENTATION, aluVectors); SoundGeneral::checkAlError("Setting the listener orientation."); }
void FoliageBase::reloadAtPosition(const WFMath::Point<2>& worldPosition) { if (mPagedGeometry) { mPagedGeometry->reloadGeometryPage(Ogre::Vector3(worldPosition.x(), 0, -worldPosition.y()), true); } }
void SoundSource::setPosition(const WFMath::Point<3>& pos) { assert(pos.isValid()); alSource3f(mALSource, AL_POSITION, pos.x(), pos.y(), pos.z()); SoundGeneral::checkAlError("Setting sound source position."); }
void Steering::update() { if (mSteeringEnabled) { if (mUpdateNeeded) { updatePath(); } auto entity = mAvatar.getEntity(); if (!mPath.empty()) { const auto& finalDestination = mPath.back(); auto entity3dPosition = entity->getViewPosition(); const WFMath::Point<2> entityPosition(entity3dPosition.x(), entity3dPosition.z()); //First check if we've arrived at our actual destination. if (WFMath::Distance(WFMath::Point<2>(finalDestination.x(), finalDestination.z()), entityPosition) < 0.1f) { //We've arrived at our destination. If we're moving we should stop. if (mLastSentVelocity.isValid() && mLastSentVelocity != WFMath::Vector<2>::ZERO()) { moveInDirection(WFMath::Vector<2>::ZERO()); } stopSteering(); } else { //We should send a move op if we're either not moving, or we've reached a waypoint, or we need to divert a lot. WFMath::Point<2> nextWaypoint(mPath.front().x(), mPath.front().z()); if (WFMath::Distance(nextWaypoint, entityPosition) < 0.1f) { mPath.pop_front(); nextWaypoint = WFMath::Point<2>(mPath.front().x(), mPath.front().z()); } WFMath::Vector<2> velocity = nextWaypoint - entityPosition; WFMath::Point<2> destination; velocity.normalize(); if (mPath.size() == 1) { //if the next waypoint is the destination we should send a "move to position" update to the server, to make sure that we stop when we've arrived. //otherwise, if there's too much lag, we might end up overshooting our destination and will have to double back destination = nextWaypoint; } //Check if we need to divert in order to avoid colliding. WFMath::Vector<2> newVelocity; bool avoiding = mAwareness.avoidObstacles(entityPosition, velocity * mSpeed, newVelocity); if (avoiding) { auto newMag = newVelocity.mag(); auto relativeMag = mSpeed / newMag; velocity = newVelocity; velocity.normalize(); velocity *= relativeMag; mUpdateNeeded = true; } bool shouldSend = false; if (velocity.isValid()) { if (mLastSentVelocity.isValid()) { //If the entity has stopped, and we're not waiting for confirmation to a movement request we've made, we need to start moving. if (!entity->isMoving() && !mExpectingServerMovement) { shouldSend = true; } else { auto currentTheta = std::atan2(mLastSentVelocity.y(), mLastSentVelocity.x()); auto newTheta = std::atan2(velocity.y(), velocity.x()); //If we divert too much from where we need to go we must adjust. if (std::abs(currentTheta - newTheta) > WFMath::numeric_constants<double>::pi() / 20) { shouldSend = true; } } } else { //If we've never sent a movement update before we should do that now. shouldSend = true; } } if (shouldSend) { //If we're moving to a certain destination and aren't avoiding anything we should tell the server to move to the destination. if (destination.isValid() && !avoiding) { moveToPoint(WFMath::Point<3>(destination.x(), entity3dPosition.y(), destination.y())); } else { moveInDirection(velocity); } } } } else { //We are steering, but the path is empty, which means we can't find any path. If we're moving we should stop movement. //But we won't stop steering; perhaps we'll find a path later. if (mLastSentVelocity.isValid() && mLastSentVelocity != WFMath::Vector<2>::ZERO()) { moveInDirection(WFMath::Vector<2>::ZERO()); } } } }