C++ AxisAlignedBox::getSize方法代码示例

btoCylinder::btoCylinder(btoWorld *world, BulletOgreEngine *btoEngine, btScalar radius, btScalar height, const btTransform &transform, const btScalar density)
    : btCylinder(world, radius, height, transform, density)
{
    this->btoEngine = btoEngine;

    // New entity
    btoCylinder::mNumEntitiesInstanced++;

    // Create Ogre Entity
    entity = btoEngine->getOgreEngine()->getOgreSceneManager()->createEntity(
                 "CylinderEntity_" + StringConverter::toString(btoCylinder::mNumEntitiesInstanced),
                 "Barrel.mesh");

    // Material
    entity->setMaterialName("GeneCraft/RockWall");
    entity->setCastShadows(true);

    // Attach
    node = btoEngine->getOgreEngine()->getOgreSceneManager()->getRootSceneNode()->createChildSceneNode();

    // Scale
    AxisAlignedBox boundingB = entity->getBoundingBox(); // we need the bounding box of the box to be able to set the size of the Bullet-box
    Vector3 sizeBB = boundingB.getSize();
    sizeBB /= 2.0f;     // only the half needed
    sizeBB *= 0.95f;    // Bullet margin is a bit bigger so we need a smaller size (Bullet 2.76 Physics SDK Manual page 18)
    Vector3 ogreSize(radius*2,height,radius*2);
    Vector3 scale = ogreSize  / boundingB.getSize();
    node->scale(scale);	// the cube is too big for us
    sizeBB *= scale;	// don't forget to scale down the Bullet-box too
}

void btoCylinder::setSize(btScalar radius, btScalar height)
{
    btoCylinder::setSize(radius,height);

    // Scale
    AxisAlignedBox boundingB = entity->getBoundingBox(); // we need the bounding box of the box to be able to set the size of the Bullet-box
    Vector3 sizeBB = boundingB.getSize();
    sizeBB /= 2.0f;     // only the half needed
    sizeBB *= 0.95f;    // Bullet margin is a bit bigger so we need a smaller size (Bullet 2.76 Physics SDK Manual page 18)
    Vector3 ogreSize(radius*2,height,radius*2);
    Vector3 scale = ogreSize  / boundingB.getSize();
    node->scale(scale);	// the cube is too big for us
}

	void RenderBoxScene::updateViewport()
	{
		if (mCanvas->getWidth() <= 1 || mCanvas->getHeight() <= 1)
			return;

		if (mEntity != nullptr && mCamera != nullptr)
		{
			mCamera->setAspectRatio((float)mCanvas->getWidth() / (float)mCanvas->getHeight());

			AxisAlignedBox box;
			const Vector3& dpos = mEntity->getParentSceneNode()->_getDerivedPosition();
			box.merge(mEntity->getBoundingBox().getMinimum() + dpos);
			box.merge(mEntity->getBoundingBox().getMaximum() + dpos);
			if (box.isNull()) return;

			Vector3 vec = box.getSize();
			float width = sqrt(vec.x * vec.x + vec.z * vec.z), height = vec.y;
			float len2 = width / mCamera->getAspectRatio(), len1 = height;
			if (len1 < len2)  len1 = len2;
			len1 /= 0.86;  // [sqrt(3)/2] for 60 degrees field of view

			Vector3 pos = box.getCenter();
			pos.z += vec.z / 2 + len1 + 1/* min dist*/;
			pos += Vector3(0, height * 0.9f/* pitch*/, len1 * 0.1f);
			pos *= 0.85f;  //* closer
			Vector3 look = Vector3(0, box.getCenter().y * 0.8f, 0);

			mCameraNode->setPosition(pos);
			mCameraNode->lookAt(look, Node::TS_WORLD);
		}
	}

//-------------------------------------------------------------------------------------
bool OBTutorial2::processUnbufferedInput(const Ogre::FrameEvent& evt)
{
    static float mToggle = 0;

    if (mToggle>0)
        mToggle -= evt.timeSinceLastFrame;

	// create and throw a box if 'B' is pressed
	if(mKeyboard->isKeyDown(OIS::KC_B) && mToggle <=0)
	{
		Vector3 size = Vector3::ZERO;	// size of the box
		// starting position of the box
		Vector3 position = (mCamera->getDerivedPosition() + mCamera->getDerivedDirection().normalisedCopy() * 10);
 
		// create an ordinary, Ogre mesh with texture
	    Entity *entity = mSceneMgr->createEntity(
 					"Box" + StringConverter::toString(mNumEntitiesInstanced),
 					"cube.mesh");			    
		entity->setCastShadows(true);
                createBoxShape(entity, position, false);
		// we need the bounding box of the box to be able to set the size of the Bullet-box
		AxisAlignedBox boundingB = entity->getBoundingBox();
		size = boundingB.getSize(); size /= 2.0f; // only the half needed
		size *= 1.00f;	// Bullet margin is a bit bigger so we need a smaller size
 									// (Bullet 2.76 Physics SDK Manual page 18)
		entity->setMaterialName("Examples/BumpyMetal");
		SceneNode *node = mSceneMgr->getRootSceneNode()->createChildSceneNode();
		node->attachObject(entity);
		node->scale(0.05f, 0.05f, 0.05f);	// the cube is too big for us
		size *= 0.05f;						// don't forget to scale down the Bullet-box too
 
		// after that create the Bullet shape with the calculated size
		/*OgreBulletCollisions::BoxCollisionShape *sceneBoxShape = new OgreBulletCollisions::BoxCollisionShape(size);
		// and the Bullet rigid body
		OgreBulletDynamics::RigidBody *defaultBody = new OgreBulletDynamics::RigidBody(
 					"defaultBoxRigid" + StringConverter::toString(mNumEntitiesInstanced), 
 					mWorld);
		defaultBody->setShape(	node,
 						sceneBoxShape,
 						0.6f,			// dynamic body restitution
 						0.6f,			// dynamic body friction
 						1.0f, 			// dynamic bodymass
 						position,		// starting position of the box
 						Quaternion(0,0,0,1));// orientation of the box
        mNumEntitiesInstanced++;				
 
		defaultBody->setLinearVelocity(
					mCamera->getDerivedDirection().normalisedCopy() * Ogre::Math::RangeRandom(0.7f,20.0f) ); // shooting speed
		// push the created objects to the dequese
		mShapes.push_back(sceneBoxShape);
		mBodies.push_back(defaultBody);		**/		
		mToggle = 0.5;
	}


    return true;
}

void SurveyMapManager::init()
{
    AxisAlignedBox aab   = App::GetSimTerrain()->getTerrainCollisionAAB();
    Vector3 terrain_size = App::GetSimTerrain()->getMaxTerrainSize();
    bool use_aab         = App::GetSimTerrain()->isFlat() && std::min(aab.getSize().x, aab.getSize().z) > 50.0f;

    if (terrain_size.isZeroLength() || use_aab && (aab.getSize().length() < terrain_size.length()))
    {
        terrain_size = aab.getSize();
        terrain_size.y = aab.getMaximum().y;
        Vector3 offset = aab.getCenter() - terrain_size / 2;
        mMapCenterOffset = Vector2(offset.x, offset.z);
    }

    mTerrainSize = Vector2(terrain_size.x, terrain_size.z);
    mPlayerPosition = mTerrainSize / 2;
    mMapCenter = mTerrainSize / 2;
    mMapSize = mTerrainSize;

    ConfigOptionMap ropts = App::GetOgreSubsystem()->GetOgreRoot()->getRenderSystem()->getConfigOptions();
    int resolution = StringConverter::parseInt(StringUtil::split(ropts["Video Mode"].currentValue, " x ")[0], 1024);
    int fsaa = StringConverter::parseInt(ropts["FSAA"].currentValue, 0);
    int res = std::pow(2, std::floor(std::log2(resolution)));

    mMapTextureCreatorStatic = std::unique_ptr<SurveyMapTextureCreator>(new SurveyMapTextureCreator(terrain_size.y));
    mMapTextureCreatorStatic->init(res, fsaa);
    mMapTextureCreatorStatic->update(mMapCenter + mMapCenterOffset, mMapSize);

    // TODO: Find out how to zoom into the static texture instead
    mMapTextureCreatorDynamic = std::unique_ptr<SurveyMapTextureCreator>(new SurveyMapTextureCreator(terrain_size.y));
    mMapTextureCreatorDynamic->init(res / 4, fsaa);
    mMapTextureCreatorDynamic->update(mMapCenter + mMapCenterOffset, mMapSize);

    mMapTexture->eventMouseSetFocus      += MyGUI::newDelegate(this, &SurveyMapManager::setFocus);
    mMapTexture->eventMouseLostFocus     += MyGUI::newDelegate(this, &SurveyMapManager::lostFocus);
    mMapTexture->eventMouseMove          += MyGUI::newDelegate(this, &SurveyMapManager::mouseMove);
    mMapTexture->eventMouseButtonPressed += MyGUI::newDelegate(this, &SurveyMapManager::mousePressed);

    mCursorEntity = createMapEntity("other");
    mCursorEntity->setVisibility(false);
    mCursorEntity->setCaption(_L("Teleport"));
}

    /** Returns true is the box will fit in a child.
    */
    bool Octree::_isTwiceSize( const AxisAlignedBox &box ) const
    {
	    // infinite boxes never fit in a child - always root node
	    if (box.isInfinite())
		    return false;

        Vector3 halfMBoxSize = mBox.getHalfSize();
        Vector3 boxSize = box.getSize();
        return ((boxSize.x <= halfMBoxSize.x) && (boxSize.y <= halfMBoxSize.y) && (boxSize.z <= halfMBoxSize.z));

    }

Extrusion::Extrusion(Vector3 pos, Vector3 size, Vector3 axis, float extrusionTravel, hkpWorld * world, SceneManager * sceneMgr):
	mWorld(world), mSceneMgr(sceneMgr)
{
	hkVector4 halfSize(size.x * 0.5f, size.y * 0.5, size.z * 0.5);
	hkpBoxShape * shape = new hkpBoxShape(halfSize, 0);

	hkpRigidBodyCinfo info;
	info.m_shape = shape;
	info.m_mass = 800.0f;
	hkpInertiaTensorComputer::setShapeVolumeMassProperties(shape, info.m_mass, info);
	info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
	info.m_position.set(pos.x, pos.y, pos.z);
	mBody = new hkpRigidBody(info);
	mWorld->addEntity(mBody);
	shape->removeReference();


	hkpRigidBodyCinfo anchorInfo;
	anchorInfo.m_motionType = hkpMotion::MOTION_FIXED;
	anchorInfo.m_position = hkVector4(pos.x + (20.0f * axis.x), pos.y, pos.z + (20.0f * axis.z));
	anchorInfo.m_shape = new hkpSphereShape(0.1f);
	hkpRigidBody * anchor = new hkpRigidBody(anchorInfo);
	mWorld->addEntity(anchor);

	// Setup prismatic constraint
	hkVector4 a(axis.x, axis.y, axis.z);
	hkpPrismaticConstraintData * prismatic = new hkpPrismaticConstraintData();
	prismatic->setMaxLinearLimit(extrusionTravel);
	prismatic->setMinLinearLimit(0.0f);
	prismatic->setInWorldSpace(mBody->getTransform(), anchor->getTransform(), hkVector4(pos.x, pos.y, pos.z), a);
	hkpConstraintInstance * prismaticConstraint = new hkpConstraintInstance(mBody, anchor, prismatic);
	mWorld->addConstraint(prismaticConstraint);
	prismaticConstraint->removeReference();
	prismatic->removeReference();

	// Ogre
	char entityName[] = "000ExtrusionEntity";
	entityName[0] += numExtrusions;
	mMesh = mSceneMgr->createEntity(entityName, "cube.mesh");
	AxisAlignedBox aab = mMesh->getBoundingBox();
	mMesh->setMaterialName("Examples/CubeDefault");

	Vector3 meshSize = aab.getSize();
	Vector3 scaling = size / meshSize;

	char nodeName[] = "000ExtrusionNode";
	nodeName[0] += numExtrusions;
	mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(nodeName);
	mNode->setPosition(pos.x, pos.y, pos.z);
	mNode->setScale(scaling);
	mNode->attachObject(mMesh);

	numExtrusions++;
}

    /** Returns true is the box will fit in a child.
    */
    bool PagingLandScapeOctree::_isTwiceCullSize(const AxisAlignedBox &box) const
	{
		// infinite boxes never fit in a child - always root node
		if (box.isInfinite())
			return false;

		const Vector3 &boxSize = box.getSize();
        return(boxSize.x  <= mCullHalfSize.x) &&
              (boxSize.y  <= mCullHalfSize.y) &&
              (boxSize.z  <= mCullHalfSize.z) ;

    }

Actor::Actor(const Ogre::String& name)
{
	_strName	= name;
	_AnimSpeed	= 1.0;
	_pCurAnim	= 0;
	_bPaused	= false;

	_bShowAxes			= false;
	_bShowBone			= false;
	_bShowBoundingBox	= false;

	_axesBoneTagPoint		= 0;

	//the body
	_pBodyEntity	= OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity(_strName, _strName);
	_pBodySceneNode	= OgreFramework::getSingletonPtr()->m_pSceneMgr->getRootSceneNode()->createChildSceneNode(_strName);
	_pBodySceneNode->attachObject(_pBodyEntity);

	//the body axes
	String axesName = _strName + "_" + "axes";
	_axesEntity = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity(axesName, "axes.mesh");
	SceneNode* pAxesNode = _pBodySceneNode->createChildSceneNode(axesName);
	pAxesNode->attachObject(_axesEntity);
	_axesEntity->setVisible(_bShowAxes);

	//the bone axes
	axesName = _strName + "_Bone_" + "axes";
	_axesBoneEntity = OgreFramework::getSingletonPtr()->m_pSceneMgr->createEntity(axesName, "axes.mesh");

	AxisAlignedBox aabb = _pBodyEntity->getBoundingBox();
	_vInitCenter = aabb.getCenter();
	_fVolumeSize = aabb.getSize().length();

	_scaleAxes = _fVolumeSize * 0.01;		//for Axes mesh size is about 13, i want the axes to be 1/10 of the mesh
	pAxesNode->setScale(_scaleAxes, _scaleAxes, _scaleAxes);

	AddBoneVisualizer();

	OgreFramework::getSingletonPtr()->AddActor(this);
}

//Constructor
EnvironmentObject::EnvironmentObject(PGFrameListener* frameListener, OgreBulletDynamics::DynamicsWorld *mWorld, int mNumEntitiesInstanced, SceneManager* mSceneMgr, std::string object[24])
{
	//Initialise variables
	mName = object[0];
	mMesh = object[1];
	mPosition = Vector3(atof(object[2].c_str()), atof(object[3].c_str()), atof(object[4].c_str()));
	mOrientation = Quaternion(atof(object[5].c_str()), atof(object[6].c_str()), atof(object[7].c_str()), atof(object[8].c_str()));
	mScale = Vector3(atof(object[9].c_str()), atof(object[10].c_str()), atof(object[11].c_str()));
	mRestitution = atof(object[12].c_str());
	mFriction = atof(object[13].c_str());
	mMass = atof(object[14].c_str());
	mAnimated = atoi(object[15].c_str());
	mXMovement = atof(object[16].c_str());
	mYMovement = atof(object[17].c_str());
	mZMovement = atof(object[18].c_str());
	mSpeed = atof(object[19].c_str());;
	mRotationX = atof(object[20].c_str());
	mRotationY = atof(object[21].c_str());
	mRotationZ = atof(object[22].c_str());
	mBillBoard = atoi(object[23].c_str());

	//Initially targets haven't been hit
	counted = false;

	//Generate new Ogre entity
	Entity* entity = mSceneMgr->createEntity(mName + StringConverter::toString(mNumEntitiesInstanced), mMesh);
	
	//Create bounding box for entity
	AxisAlignedBox boundingB = entity->getBoundingBox();
	Vector3 size = boundingB.getSize() * mScale;
	size /= 2.0f;
	size *= 0.97f;
	
	//Attach entity to a scene node so it can be displayed in the environment
	SceneNode* objectNode = mSceneMgr->getRootSceneNode()->createChildSceneNode();
 	objectNode->attachObject(entity);
	objectNode->setScale(mScale);
	
	//Generate a new rigidbody for the object
	mBody = new OgreBulletDynamics::RigidBody(mName + StringConverter::toString(mNumEntitiesInstanced), mWorld);

	//Different objects require different collision shapes
	if(mName == "Target") {
		OgreBulletCollisions::CylinderCollisionShape* ccs = new OgreBulletCollisions::CylinderCollisionShape(size, Ogre::Vector3(0,0,1));	
		mBody->setShape(objectNode, ccs, mRestitution, mFriction, mMass, mPosition, mOrientation);
		mBody->setDebugDisplayEnabled(true);
		mBody->getBulletRigidBody()->setCollisionFlags(mBody->getBulletRigidBody()->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
	} 
	else if(mName == "Palm") {
		OgreBulletCollisions::StaticMeshToShapeConverter* acs = new OgreBulletCollisions::StaticMeshToShapeConverter(entity);
		OgreBulletCollisions::TriangleMeshCollisionShape* ccs = acs->createTrimesh();
		OgreBulletCollisions::CollisionShape* finalCollisionShape = (OgreBulletCollisions::CollisionShape*) ccs;
	
		Ogre::Vector3 scale = objectNode->getScale();
		btVector3 scale2(scale.x, scale.y, scale.z);
		finalCollisionShape->getBulletShape()->setLocalScaling(scale2);
		mBody->setShape(objectNode, (OgreBulletCollisions::CollisionShape*) ccs, mRestitution, mFriction, mMass, mPosition, mOrientation);
		mBody->getBulletRigidBody()->setFriction(0.5f);
		palmAnimation = entity->getAnimationState("my_animation");
	}
	else if(mName == "GoldCoconut") {
		float biggestSize = 0;
		if (size.x > biggestSize)
			biggestSize = size.x;
		if (size.y > biggestSize)
			biggestSize = size.y;
		if (size.z > biggestSize)
			biggestSize = size.z;

		entity->setMaterialName("GoldCoconut");
		OgreBulletCollisions::CollisionShape *sceneSphereShape = new OgreBulletCollisions::SphereCollisionShape(biggestSize);
 		mBody->setShape(objectNode, sceneSphereShape, mRestitution, mFriction, mMass, mPosition, mOrientation);
		mBody->getBulletRigidBody()->setCollisionFlags(mBody->getBulletRigidBody()->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
	}
	else {
		if (mName=="Orange" ||mName=="Blue" || mName=="Red" || mName=="Block")
		{
			mMass=50;
		}
		if (mName == "Orange")
			entity->setMaterialName("Orange");
		else if (mName == "Blue")
			entity->setMaterialName("Blue");
		else if (mName == "Red")
			entity->setMaterialName("Red");
		OgreBulletCollisions::BoxCollisionShape* sceneBoxShape = new OgreBulletCollisions::BoxCollisionShape(size);
		mBody->setShape(objectNode, sceneBoxShape, mRestitution, mFriction, mMass, mPosition, mOrientation);
		mBody->getBulletRigidBody()->setCollisionFlags(mBody->getBulletRigidBody()->getCollisionFlags()  | btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
	}

	mBody->setCastShadows(true);

	//Add a billboard for scores if necessary
	if(mBillBoard != 0) {
		mText = new MovableText("targetText" + StringConverter::toString(mNumEntitiesInstanced), "100", "[email protected]_33", 17.0f);
		mText->setTextAlignment(MovableText::H_CENTER, MovableText::V_ABOVE); // Center horizontally and display above the node
		
		//Create scene node for bill board and attach text to it
		mBillNode = static_cast<SceneNode*>(mSceneMgr->getRootSceneNode()->createChild());
//.........这里部分代码省略.........