예제 #1
0
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++;
}
예제 #2
0
static void HK_CALL createHinge(hkpWorld* world, 
								hkpCollidableQualityType bodyQualityType, 
								hkpConstraintInstance::ConstraintPriority constraintPriority,
								hkVector4& position, 
								hkVector4& velocity)
{
	// create to boards connected by a hinge
	hkpRigidBody* bodyA;
	hkpRigidBody* bodyB;
	hkReal pivotY = 0.40f;
	{
		hkVector4 halfSize(.1f, 1.0f, 0.1f);
		hkpConvexShape* shape = new hkpBoxShape(halfSize, 0.01f); 
		
		hkpRigidBodyCinfo ci;
		ci.m_motionType = hkpMotion::MOTION_SPHERE_INERTIA;
		ci.m_shape = shape;
		ci.m_angularDamping = 0.0f;
		ci.m_linearDamping = 0.0f;
		ci.m_restitution = 0.0f;
		ci.m_friction = 0.2f;
		ci.m_linearVelocity = velocity;
		hkpInertiaTensorComputer::setShapeVolumeMassProperties( shape, 1.0f, ci );
		ci.m_qualityType = bodyQualityType;
		ci.m_collisionFilterInfo = hkpGroupFilter::calcFilterInfo(30);


		ci.m_position.set( -2.0f, -1.0f - pivotY, 0.0f );
		bodyA = new hkpRigidBody(ci);
		bodyA->setName("Body0");
		world->addEntity( bodyA );

		ci.m_position.set( -2.0f, 1.0f - pivotY, 0.0f );
		bodyB = new hkpRigidBody(ci);
		bodyB->setName("Body1");
		world->addEntity( bodyB );

		shape->removeReference();
	}

	// create a hing connecting the two bodies
	{
		hkVector4 axis( 0,0,1.f);
		hkVector4 pivot( -2.0f, -pivotY, 0.0f );
		hkpHingeConstraintData* constraintData = new hkpHingeConstraintData();
		constraintData->setInWorldSpace( bodyA->getTransform(), bodyB->getTransform(), pivot, axis );

		world->addConstraint( new hkpConstraintInstance( bodyA, bodyB, constraintData, constraintPriority ))->removeReference();
		constraintData->removeReference();
	}

	bodyA->removeReference();
	bodyB->removeReference();
}
예제 #3
0
bool CCmpPathfinder::CheckBuildingPlacement(const IObstructionTestFilter& filter,
	entity_pos_t x, entity_pos_t z, entity_pos_t a, entity_pos_t w,
	entity_pos_t h, entity_id_t id, pass_class_t passClass)
{
	// Check unit obstruction
	CmpPtr<ICmpObstructionManager> cmpObstructionManager(GetSimContext(), SYSTEM_ENTITY);
	if (cmpObstructionManager.null())
		return false;

	if (cmpObstructionManager->TestStaticShape(filter, x, z, a, w, h, NULL))
		return false;

	// Test against terrain:

	UpdateGrid();

	CmpPtr<ICmpObstruction> cmpObstruction(GetSimContext(), id);
	if (cmpObstruction.null())
		return false;

	ICmpObstructionManager::ObstructionSquare square;
	if (!cmpObstruction->GetObstructionSquare(square))
		return false;

	// Expand bounds by 1/sqrt(2) tile (multiply by TERRAIN_TILE_SIZE since we want world coordinates)
	entity_pos_t expand = entity_pos_t::FromInt(2).Sqrt().Multiply(entity_pos_t::FromInt(TERRAIN_TILE_SIZE / 2));
	CFixedVector2D halfSize(square.hw + expand, square.hh + expand);
	CFixedVector2D halfBound = Geometry::GetHalfBoundingBox(square.u, square.v, halfSize);

	u16 i0, j0, i1, j1;
	NearestTile(square.x - halfBound.X, square.z - halfBound.Y, i0, j0);
	NearestTile(square.x + halfBound.X, square.z + halfBound.Y, i1, j1);
	for (u16 j = j0; j <= j1; ++j)
	{
		for (u16 i = i0; i <= i1; ++i)
		{
			entity_pos_t x, z;
			TileCenter(i, j, x, z);
			if (Geometry::PointIsInSquare(CFixedVector2D(x - square.x, z - square.z), square.u, square.v, halfSize)
				&& !IS_TERRAIN_PASSABLE(m_Grid->get(i,j), passClass))
			{
				return false;
			}
		}
	}

	return true;
}
예제 #4
0
void Path::addRoundedRect(const FloatRect& rect, const FloatSize& roundingRadii)
{
    if (rect.isEmpty())
        return;

    FloatSize radius(roundingRadii);
    FloatSize halfSize(rect.width() / 2, rect.height() / 2);

    // If rx is greater than half of the width of the rectangle
    // then set rx to half of the width (required in SVG spec)
    if (radius.width() > halfSize.width())
        radius.setWidth(halfSize.width());

    // If ry is greater than half of the height of the rectangle
    // then set ry to half of the height (required in SVG spec)
    if (radius.height() > halfSize.height())
        radius.setHeight(halfSize.height());

    moveTo(FloatPoint(rect.x() + radius.width(), rect.y()));

    if (radius.width() < halfSize.width())
        addLineTo(FloatPoint(rect.x() + rect.width() - roundingRadii.width(), rect.y()));

    addBezierCurveTo(FloatPoint(rect.x() + rect.width() - radius.width() * gCircleControlPoint, rect.y()), FloatPoint(rect.x() + rect.width(), rect.y() + radius.height() * gCircleControlPoint), FloatPoint(rect.x() + rect.width(), rect.y() + radius.height()));

    if (radius.height() < halfSize.height())
        addLineTo(FloatPoint(rect.x() + rect.width(), rect.y() + rect.height() - radius.height()));

    addBezierCurveTo(FloatPoint(rect.x() + rect.width(), rect.y() + rect.height() - radius.height() * gCircleControlPoint), FloatPoint(rect.x() + rect.width() - radius.width() * gCircleControlPoint, rect.y() + rect.height()), FloatPoint(rect.x() + rect.width() - radius.width(), rect.y() + rect.height()));

    if (radius.width() < halfSize.width())
        addLineTo(FloatPoint(rect.x() + radius.width(), rect.y() + rect.height()));

    addBezierCurveTo(FloatPoint(rect.x() + radius.width() * gCircleControlPoint, rect.y() + rect.height()), FloatPoint(rect.x(), rect.y() + rect.height() - radius.height() * gCircleControlPoint), FloatPoint(rect.x(), rect.y() + rect.height() - radius.height()));

    if (radius.height() < halfSize.height())
        addLineTo(FloatPoint(rect.x(), rect.y() + radius.height()));

    addBezierCurveTo(FloatPoint(rect.x(), rect.y() + radius.height() * gCircleControlPoint), FloatPoint(rect.x() + radius.width() * gCircleControlPoint, rect.y()), FloatPoint(rect.x() + radius.width(), rect.y()));

    closeSubpath();
}
예제 #5
0
파일: Path.cpp 프로젝트: 1833183060/wke
void Path::addRoundedRect(const FloatRect& rect, const FloatSize& roundingRadii)
{
    if (rect.isEmpty())
        return;

    FloatSize radius(roundingRadii);
    FloatSize halfSize(rect.width() / 2, rect.height() / 2);

    // If rx is greater than half of the width of the rectangle
    // then set rx to half of the width (required in SVG spec)
    if (radius.width() > halfSize.width())
        radius.setWidth(halfSize.width());

    // If ry is greater than half of the height of the rectangle
    // then set ry to half of the height (required in SVG spec)
    if (radius.height() > halfSize.height())
        radius.setHeight(halfSize.height());

    addBeziersForRoundedRect(rect, radius, radius, radius, radius);
}
예제 #6
0
fixed CCmpPathfinder::DistanceToGoal(CFixedVector2D pos, const CCmpPathfinder::Goal& goal)
{
	switch (goal.type)
	{
	case CCmpPathfinder::Goal::POINT:
		return (pos - CFixedVector2D(goal.x, goal.z)).Length();

	case CCmpPathfinder::Goal::CIRCLE:
		return ((pos - CFixedVector2D(goal.x, goal.z)).Length() - goal.hw).Absolute();

	case CCmpPathfinder::Goal::SQUARE:
	{
		CFixedVector2D halfSize(goal.hw, goal.hh);
		CFixedVector2D d(pos.X - goal.x, pos.Y - goal.z);
		return Geometry::DistanceToSquare(d, goal.u, goal.v, halfSize);
	}

	default:
		debug_warn(L"invalid type");
		return fixed::Zero();
	}
}
예제 #7
0
std::shared_ptr<CSG> 
Ring(float halfWidth, float halfHeight, float centerX, 
     float centerY, float thickness,
     const Color * inputColorPointer)
{
    Vector center(centerX, centerY);
    Vector halfSize(halfWidth, halfHeight);
    Vector low = center - halfSize;
    Vector high = center + halfSize;

    std::shared_ptr<CSG> u(new Union(inputColorPointer, true));
    std::shared_ptr<CSG> in(new Intersection(inputColorPointer, true));
    std::shared_ptr<Shape> outer(new Ellipse(low, high, inputColorPointer));

    Vector innerWay(thickness, thickness);
    low = low + innerWay;
    high = high - innerWay;
    std::shared_ptr<Shape> inner(new Ellipse(low, high, inputColorPointer, false));
    in->AddElement(outer);
    in->AddElement(inner);
    u->AddElement(in);
    return (std::shared_ptr<CSG>) u;
}
예제 #8
0
void VideoDecoderThread::sendFrame(AVFrame* pFrame)
{
    VideoMsgPtr pMsg(new VideoMsg());
    vector<BitmapPtr> pBmps;
    if (pixelFormatIsPlanar(m_PF)) {
        ScopeTimer timer(CopyImageProfilingZone);
        IntPoint halfSize(m_Size.x/2, m_Size.y/2);
        pBmps.push_back(getBmp(m_pBmpQ, m_Size, I8));
        pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
        pBmps.push_back(getBmp(m_pHalfBmpQ, halfSize, I8));
        if (m_PF == YCbCrA420p) {
            pBmps.push_back(getBmp(m_pBmpQ, m_Size, I8));
        }
        for (unsigned i = 0; i < pBmps.size(); ++i) {
            m_pFrameDecoder->copyPlaneToBmp(pBmps[i], pFrame->data[i], 
                    pFrame->linesize[i]);
        }
    } else {
        pBmps.push_back(getBmp(m_pBmpQ, m_Size, m_PF));
        m_pFrameDecoder->convertFrameToBmp(pFrame, pBmps[0]);
    }
    pMsg->setFrame(pBmps, m_pFrameDecoder->getCurTime());
    pushMsg(pMsg);
}
예제 #9
0
 AARect Area::MakeAARect(const Vector2 &centre) const
 {
    Vector2 halfSize(Vector2(m_width, m_height) * 0.5f);
    return AARect(-halfSize + centre, halfSize + centre);
 }
예제 #10
0
파일: Primitives.cpp 프로젝트: BodyViz/osg
osg::ref_ptr<osg::Geometry> ReaderWriterVRML2::convertVRML97Box(openvrml::node* vrml_box) const
{
    std::auto_ptr<openvrml::field_value> fv = vrml_box->field("size");
    const openvrml::vec3f &size = static_cast<const openvrml::sfvec3f *> (fv.get())->value();

    osg::Vec3 halfSize(size[0] * 0.5f, size[1] * 0.5f, size[2] * 0.5f);

    BoxLibrary::const_iterator it = m_boxLibrary.find(halfSize);
    if (it != m_boxLibrary.end())
    {
        return (*it).second.get();
    }

    osg::ref_ptr<osg::Geometry> osg_geom = new osg::Geometry();
    osg::ref_ptr<osg::Vec3Array> osg_vertices = new osg::Vec3Array();
    osg::ref_ptr<osg::Vec2Array> osg_texcoords = new osg::Vec2Array();
    osg::ref_ptr<osg::Vec3Array> osg_normals = new osg::Vec3Array();

    osg::ref_ptr<osg::DrawArrays> box = new osg::DrawArrays(osg::PrimitiveSet::QUADS);

    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2]));

    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2]));

    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2]));

    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2]));

    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], halfSize[1], -halfSize[2]));

    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], halfSize[2]));
    osg_vertices->push_back(osg::Vec3(-halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], -halfSize[2]));
    osg_vertices->push_back(osg::Vec3(halfSize[0], -halfSize[1], halfSize[2]));

    for (int i = 0; i != 6; ++i)
    {
        osg_texcoords->push_back(osg::Vec2(0.0f, 1.0f));
        osg_texcoords->push_back(osg::Vec2(0.0f, 0.0f));
        osg_texcoords->push_back(osg::Vec2(1.0f, 0.0f));
        osg_texcoords->push_back(osg::Vec2(1.0f, 1.0f));
    }

    osg_normals->push_back(osg::Vec3(0.0f, 0.0f, 1.0f));
    osg_normals->push_back(osg::Vec3(0.0f, 0.0f, -1.0f));
    osg_normals->push_back(osg::Vec3(1.0f, 0.0f, 0.0f));
    osg_normals->push_back(osg::Vec3(-1.0f, 0.0f, 0.0f));
    osg_normals->push_back(osg::Vec3(0.0f, 1.0f, 0.0f));
    osg_normals->push_back(osg::Vec3(0.0f, -1.0f, 0.0f));

    box->setCount(osg_vertices->size());

    osg_geom->addPrimitiveSet(box.get());

    osg_geom->setVertexArray(osg_vertices.get());
    osg_geom->setTexCoordArray(0, osg_texcoords.get());
    osg_geom->setNormalArray(osg_normals.get());
    osg_geom->setNormalBinding(osg::Geometry::BIND_PER_PRIMITIVE);

    osg_geom->getOrCreateStateSet()->setAttributeAndModes(new osg::CullFace(osg::CullFace::BACK));

    m_boxLibrary[halfSize] = osg_geom;

    return osg_geom.get();
}
예제 #11
0
DisablingConstraintsDemo::DisablingConstraintsDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{
	m_time = 0.0f;
	m_constraintsEnabled = true;

	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, 0.0f, 10.0f);
		hkVector4 to  (0.0f, 0.0f, 0.0f);
		hkVector4 up  (0.0f, 1.0f, 0.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_8ITERS_HARD); 
		info.setBroadPhaseWorldSize( 100.0f );
		info.m_enableDeactivation = false;
		m_world = new hkpWorld( info );
		m_world->lock();

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;

		setupGraphics();

		// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );
	}

	//
	// Create vectors to be used for setup
	//
	hkVector4 halfSize(0.5f, 0.5f, 0.5f);
	hkVector4 size;
	size.setMul4(2.0f, halfSize);
	hkVector4 position(size(0), -size(1) -0.1f, 0.0f);


	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	//
	// Get fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		fixedBody = m_world->getFixedRigidBody();
	}



	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{

		hkpRigidBodyCinfo info;
		info.m_position = position;
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;	
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}

	//
	//	Cleanup references to shared shapes
	//
	boxShape->removeReference();
	boxShape = HK_NULL;


	//
	// CREATE LIMITED HINGE CONSTRAINT
	// 
	{
		hkpLimitedHingeConstraintData* lhc = new hkpLimitedHingeConstraintData();

		// Set the pivot
		hkVector4 pivot;		
		pivot.setAdd4(position, halfSize);

		// Move pivot to center of side on cube
		pivot(0) -= size(0);	
		pivot(2) -= halfSize(2);

		hkVector4 axis(0.0f, 0.0f, 1.0f);

		// Create constraint
		lhc->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivot, axis);
		lhc->setMinAngularLimit(-HK_REAL_PI/3.0f);
		lhc->setMaxAngularLimit(HK_REAL_PI/4.0f);
		

		{
			hkpConstraintInstance* constraint = new hkpConstraintInstance( moveableBody, fixedBody, lhc );
			m_world->addConstraint(constraint);
			constraint->removeReference();
		}
		
		lhc->removeReference();  
	}

	//
	// Create ground box
	//

	hkVector4 groundSize; groundSize.set(10.0f, 0.01f, 10.0f);
	hkpRigidBody* groundBody = GameUtils::createBox( groundSize, 0, hkVector4(0.0f, -3.0f, 0.0f) );
	m_world->addEntity(groundBody);
	groundBody->removeReference();

	m_world->unlock();
}
예제 #12
0
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
cPoint cRect::centerPoint() const
{
    return position_ + halfSize();
}
예제 #13
0
PointToPlaneDemo::PointToPlaneDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{

	//
	// Setup the camera
	//
	{
		hkVector4 from(5.0f, 2.0f, 10.0f);
		hkVector4 to  (2.0f, 0.0f,  0.0f);
		hkVector4 up  (0.0f, 1.0f,  0.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.setBroadPhaseWorldSize( 100.0f );
		info.m_enableDeactivation = false;
		m_world = new hkpWorld( info );
		m_world->lock();

				// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;
	
		setupGraphics();
	}

	//
	// Create vectors to be used for setup
	//
	hkVector4 halfSize (0.5f, 0.5f, 0.5f);
	hkVector4 position1(0.f,0.f,0.f);
	hkVector4 position2(3.0f,-0.5f,0.f);
	
	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position = position1;
		info.m_shape = boxShape;
		info.m_motionType = hkpMotion::MOTION_FIXED;
		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}

	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{

		hkpRigidBodyCinfo info;
		info.m_position = position2;
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}

	//
	//	Cleanup shared shape references
	//
	boxShape->removeReference();
	boxShape = HK_NULL;

	
	//
	// Create point to plane constraint
	// 
	{
		hkpPointToPlaneConstraintData* plane = new hkpPointToPlaneConstraintData();

		hkVector4 up(0.0f, 1.0f, 0.0f);

		// Create constraint
		hkVector4 pivotW; pivotW.setAdd4(position2, hkVector4(-0.5f, 0.5f, 0.5f));
		plane->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivotW, up);

		//
		//	Create and add the constraint
		//
		{
			hkpConstraintInstance* constraint = new hkpConstraintInstance( moveableBody, fixedBody, plane );
			m_world->addConstraint(constraint);
			constraint->removeReference();
		}		

		plane->removeReference();  
	}

	m_world->unlock();
}
예제 #14
0
BallAndSocketDemo::BallAndSocketDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{
	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, 0.0f, 10.0f);
		hkVector4 to  (0.0f, 0.0f,  0.0f);
		hkVector4 up  (0.0f, 1.0f,  0.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		{
			info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
			info.setBroadPhaseWorldSize( 100.0f );
			info.m_enableDeactivation = false;
		}
		m_world = new hkpWorld(info);

		m_world->lock();

		// Register the single agent required (a hkBoxBoxAgent)
		hkpBoxBoxAgent::registerAgent(m_world->getCollisionDispatcher());

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;

		setupGraphics();
	}

	//
	// Some vectors to be used for setup
	//
	hkVector4 halfSize(0.5f, 0.5f, 0.5f);
	hkVector4 size;
	size.setMul4(2.0f, halfSize);
	hkVector4 position(size(0), -size(1) -0.1f, 0);

	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape = new hkpBoxShape(halfSize , 0);

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		{
			info.m_position		. set(0.0f, 0.0f, 0.0f);
			info.m_shape		= boxShape;
			info.m_motionType	= hkpMotion::MOTION_FIXED;
		}

		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}

	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{

		hkpRigidBodyCinfo info;
		{
			hkReal mass = 10.0f;

			// Compute the box inertia tensor
			hkpMassProperties massProperties;
			hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, mass, massProperties);

			info.m_position			= position;
			info.m_shape			= boxShape;
			info.m_mass				= mass;
			info.m_inertiaTensor	= massProperties.m_inertiaTensor;
			info.m_centerOfMass		= massProperties.m_centerOfMass;
			info.m_motionType		= hkpMotion::MOTION_BOX_INERTIA;
		}

		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}

	//  Remove reference from shape
	boxShape->removeReference();

	//
	// Create ball and socket constraint.
	// 
	{
		// Set the pivot
		hkVector4 pivot;
		pivot.setAdd4(position, halfSize);
		pivot(0) -= size(0);	// Move pivot to corner of cube

		// Create the constraint
		hkpBallAndSocketConstraintData* data = new hkpBallAndSocketConstraintData(); 
		data->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivot);
		hkpConstraintInstance* constraint = new hkpConstraintInstance(moveableBody, fixedBody, data);
		m_world->addConstraint( constraint); 	
		data->removeReference();
		constraint->removeReference();
	}

	m_world->unlock();
}
예제 #15
0
ConstraintKitDemo::ConstraintKitDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{
	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, 5.0f, 15.0f);
		hkVector4 to  (0.0f, -2.0f, 0.0f);
		hkVector4 up  (0.0f, 1.0f, 0.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.setBroadPhaseWorldSize( 100.0f );
		info.m_enableDeactivation = false;
		m_world = new hkpWorld( info );
		m_world->lock();

		setupGraphics();
	}

	//
	// Register the box-box collision agent
	//
	{
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );
	}

	//
	// Create vectors to be used for setup
	//

	hkVector4 halfSize(0.5f, 0.5f, 0.5f);

	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(0.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		info.m_motionType = hkpMotion::MOTION_FIXED;
			
		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}


	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{

		hkpRigidBodyCinfo info;
		info.m_position.set(2.0f, 2.0f, 0.0f);
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;	
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

		moveableBody = new hkpRigidBody(info);

			// Add some damping to this body to allow it to come to rest.
		moveableBody->setAngularDamping(0.1f);
		moveableBody->setLinearDamping(0.1f);

		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}

	// Done with shape - remove reference since bodies have ownership
	boxShape->removeReference();



	//
	// CREATE GENERIC CONSTRAINT
	// 
	{
		
		hkpGenericConstraintData* constraintData = new hkpGenericConstraintData();
		
		hkpConstraintConstructionKit kit;

			// Must always start with this command (the constraintData works like a program, every
			// command being executed sequentially).
		kit.begin(constraintData);
		{
				// Set the pivots. These will be the points which are constrained by any linear constraintData
				// specified later. The fixed body has its pivot in the middle of its base. The movable
				// body has its pivot on one corner.
			hkVector4 pivotB(0.0f, -0.5f, 0.0f);
			m_pivotBIndex = kit.setPivotB(pivotB);
			hkVector4 pivotA(-0.5f, 0.5f, 0.5f);
			m_pivotAIndex = kit.setPivotA(pivotA);

				// Set the axis	in World space. This means we can easily update it
				// to pass through the pivots of the two bodies in our step code. Initially
				// we calculate this using the current location of the bodies and their pivots
			// <programlisting id="setInWorldSpace">
			const int axisId = 0;
			hkVector4 axis0;
			{
				hkVector4 pivotAW, pivotBW;
				pivotAW.setTransformedPos(moveableBody->getTransform(), pivotA);
				pivotBW.setTransformedPos(fixedBody->getTransform(), pivotB);
				axis0.setSub4(pivotBW, pivotAW);
				axis0.normalize3();
			}
				// Record the index we get back when we set this axis so we can query the
				// constraintData later using it as a "parameter ID".
			m_axisIndex = kit.setLinearDofWorld(axis0, axisId);
			

				// Set the limits of this axis ([0, 5])
			
			kit.setLinearLimit(axisId, 0.0f, 5.0f);
			
		}
			// Must always end with this command.
		
		kit.end();
		
				
		hkpConstraintInstance* constraint = new hkpConstraintInstance( moveableBody, fixedBody, constraintData );
		m_world->addConstraint(constraint);
		m_constraintData = constraintData;
		m_constraint = constraint;
	}

	m_world->unlock();
}
void TSLastDetail::_update()
{
   // We're gonna render... make sure we can.
   bool sceneBegun = GFX->canCurrentlyRender();
   if ( !sceneBegun )
      GFX->beginScene();

   _validateDim();

   Vector<GBitmap*> bitmaps;
   Vector<GBitmap*> normalmaps;

   // We need to create our own instance to render with.
   TSShapeInstance *shape = new TSShapeInstance( mShape, true );

   // Animate the shape once.
   shape->animate( mDl );

   // So we don't have to change it everywhere.
   const GFXFormat format = GFXFormatR8G8B8A8;  

   S32 imposterCount = ( ((2*mNumPolarSteps) + 1 ) * mNumEquatorSteps ) + ( mIncludePoles ? 2 : 0 );

   // Figure out the optimal texture size.
   Point2I texSize( smMaxTexSize, smMaxTexSize );
   while ( true )
   {
      Point2I halfSize( texSize.x / 2, texSize.y / 2 );
      U32 count = ( halfSize.x / mDim ) * ( halfSize.y / mDim );
      if ( count < imposterCount )
      {
         // Try half of the height.
         count = ( texSize.x / mDim ) * ( halfSize.y / mDim );
         if ( count >= imposterCount )
            texSize.y = halfSize.y;
         break;
      }

      texSize = halfSize;
   }

   GBitmap *imposter = NULL;
   GBitmap *normalmap = NULL;
   GBitmap destBmp( texSize.x, texSize.y, true, format );
   GBitmap destNormal( texSize.x, texSize.y, true, format );

   U32 mipLevels = destBmp.getNumMipLevels();

   ImposterCapture *imposterCap = new ImposterCapture();

   F32 equatorStepSize = M_2PI_F / (F32)mNumEquatorSteps;

   static const MatrixF topXfm( EulerF( -M_PI_F / 2.0f, 0, 0 ) );
   static const MatrixF bottomXfm( EulerF( M_PI_F / 2.0f, 0, 0 ) );

   MatrixF angMat;

   F32 polarStepSize = 0.0f;
   if ( mNumPolarSteps > 0 )
      polarStepSize = -( 0.5f * M_PI_F - mDegToRad( mPolarAngle ) ) / (F32)mNumPolarSteps;

   PROFILE_START(TSLastDetail_snapshots);

   S32 currDim = mDim;
   for ( S32 mip = 0; mip < mipLevels; mip++ )
   {
      if ( currDim < 1 )
         currDim = 1;
      
      dMemset( destBmp.getWritableBits(mip), 0, destBmp.getWidth(mip) * destBmp.getHeight(mip) * GFXFormat_getByteSize( format ) );
      dMemset( destNormal.getWritableBits(mip), 0, destNormal.getWidth(mip) * destNormal.getHeight(mip) * GFXFormat_getByteSize( format ) );

      bitmaps.clear();
      normalmaps.clear();

      F32 rotX = 0.0f;
      if ( mNumPolarSteps > 0 )
         rotX = -( mDegToRad( mPolarAngle ) - 0.5f * M_PI_F );

      // We capture the images in a particular order which must
      // match the order expected by the imposter renderer.

      imposterCap->begin( shape, mDl, currDim, mRadius, mCenter );

      for ( U32 j=0; j < (2 * mNumPolarSteps + 1); j++ )
      {
         F32 rotZ = -M_PI_F / 2.0f;

         for ( U32 k=0; k < mNumEquatorSteps; k++ )
         {            
            angMat.mul( MatrixF( EulerF( rotX, 0, 0 ) ),
                        MatrixF( EulerF( 0, 0, rotZ ) ) );

            imposterCap->capture( angMat, &imposter, &normalmap );

            bitmaps.push_back( imposter );
            normalmaps.push_back( normalmap );

            rotZ += equatorStepSize;
         }

         rotX += polarStepSize;

         if ( mIncludePoles )
         {
            imposterCap->capture( topXfm, &imposter, &normalmap );

            bitmaps.push_back(imposter);
            normalmaps.push_back( normalmap );

            imposterCap->capture( bottomXfm, &imposter, &normalmap );

            bitmaps.push_back( imposter );
            normalmaps.push_back( normalmap );
         }         
      }

      imposterCap->end();

      Point2I texSize( destBmp.getWidth(mip), destBmp.getHeight(mip) );

      // Ok... pack in bitmaps till we run out.
      for ( S32 y=0; y+currDim <= texSize.y; )
      {
         for ( S32 x=0; x+currDim <= texSize.x; )
         {
            // Copy the next bitmap to the dest texture.
            GBitmap* bmp = bitmaps.first();
            bitmaps.pop_front();
            destBmp.copyRect( bmp, RectI( 0, 0, currDim, currDim ), Point2I( x, y ), 0, mip );
            delete bmp;

            // Copy the next normal to the dest texture.
            GBitmap* normalmap = normalmaps.first();
            normalmaps.pop_front();
            destNormal.copyRect( normalmap, RectI( 0, 0, currDim, currDim ), Point2I( x, y ), 0, mip );
            delete normalmap;

            // Did we finish?
            if ( bitmaps.empty() )
               break;

            x += currDim;
         }

         // Did we finish?
         if ( bitmaps.empty() )
            break;

         y += currDim;
      }

      // Next mip...
      currDim /= 2;
   }

   PROFILE_END(); // TSLastDetail_snapshots

   delete imposterCap;
   delete shape;   
   
   
   // Should we dump the images?
   if ( Con::getBoolVariable( "$TSLastDetail::dumpImposters", false ) )
   {
      String imposterPath = mCachePath + ".imposter.png";
      String normalsPath = mCachePath + ".imposter_normals.png";

      FileStream stream;
      if ( stream.open( imposterPath, Torque::FS::File::Write  ) )
         destBmp.writeBitmap( "png", stream );
      stream.close();

      if ( stream.open( normalsPath, Torque::FS::File::Write ) )
         destNormal.writeBitmap( "png", stream );
      stream.close();
   }

   // DEBUG: Some code to force usage of a test image.
   //GBitmap* tempMap = GBitmap::load( "./forest/data/test1234.png" );
   //tempMap->extrudeMipLevels();
   //mTexture.set( tempMap, &GFXDefaultStaticDiffuseProfile, false );
   //delete tempMap;

   DDSFile *ddsDest = DDSFile::createDDSFileFromGBitmap( &destBmp );
   DDSUtil::squishDDS( ddsDest, GFXFormatDXT3 );

   DDSFile *ddsNormals = DDSFile::createDDSFileFromGBitmap( &destNormal );
   DDSUtil::squishDDS( ddsNormals, GFXFormatDXT5 );

   // Finally save the imposters to disk.
   FileStream fs;
   if ( fs.open( _getDiffuseMapPath(), Torque::FS::File::Write ) )
   {
      ddsDest->write( fs );
      fs.close();
   }
   if ( fs.open( _getNormalMapPath(), Torque::FS::File::Write ) )
   {
      ddsNormals->write( fs );
      fs.close();
   }

   delete ddsDest;
   delete ddsNormals;

   // If we did a begin then end it now.
   if ( !sceneBegun )
      GFX->endScene();
}
예제 #17
0
BallAndSocketChainsDemo::BallAndSocketChainsDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{

	// Disable warnings:
	hkError::getInstance().setEnabled(0x2a1db936, false); //'Constraint added between two *colliding* dynamic rigid bodies. Check your collision filter logic...' 

	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, 0.0f, 10.0f);
		hkVector4 to(0.0f, 0.0f, 0.0f);
		hkVector4 up(0.0f, 1.0f, 0.0f);

		// Change the camera for displaying 10 constraints
		from.set(-9.0f,  0.0f, 15.0f);
		to.set( 8.0f, -6.0f,  0.0f);

		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.setBroadPhaseWorldSize( 100.0f );
		info.m_enableDeactivation = false;
		info.m_collisionTolerance = 0.01f;
		m_world = new hkpWorld( info );
		m_world->lock();

		// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		
		setupGraphics();
	}

	//
	// Some vectors to be used for setup
	//
	hkVector4 halfSize(0.5f, 0.5f, 0.5f);
	hkVector4 size;
	size.setMul4(2.0f, halfSize);
	hkVector4 position(0.0f, 0.0f, 0.0f);
	hkReal xSpacing = 3;
	hkReal ySpacing = size(1) + 0.1f;

	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	const int numPairs = 10;
	for (int i = 0; i < numPairs; ++i)
	{
		position(1) = 0;

		//
		// Create fixed rigid body
		//
		hkpRigidBody* rb0;
		{
			hkpRigidBodyCinfo info;
			info.m_position.set(i * xSpacing, 0.0f, 0.0f);
			info.m_shape = boxShape;
			info.m_motionType = hkpMotion::MOTION_FIXED;
			rb0 = new hkpRigidBody(info);
			m_world->addEntity(rb0);
			rb0->removeReference();	
		}

		for (int k=0; k<10; k++)
		{

			hkVector4 positionRb0 = position;

			position(1) -= ySpacing;

			//
			// Create movable rigid body
			//
			hkpRigidBody* rb1;
			{

				hkpRigidBodyCinfo info;
				info.m_position = position;
				info.m_shape = boxShape;
				
					// Compute the box inertia tensor
				hkpMassProperties massProperties;
				info.m_mass = 10.0f;
				hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
				info.m_inertiaTensor = massProperties.m_inertiaTensor;
				info.m_centerOfMass = massProperties.m_centerOfMass;
				info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

				rb1 = new hkpRigidBody(info);
				m_world->addEntity(rb1);
				rb1->removeReference();	
			}

		
			//
			// CREATE BALL AND SOCKET CONSTRAINT
			// 
			hkpBallAndSocketConstraintData* bs;
			{
				
				// Create the constraint
				bs = new hkpBallAndSocketConstraintData(); 

				// Set the pivot
				hkVector4 pivot = positionRb0;
				bs->setInWorldSpace(rb1->getTransform(), rb0->getTransform(), pivot);

				hkpConstraintInstance* constraint = new hkpConstraintInstance(rb1, rb0, bs);

				m_world->addConstraint( constraint); 	
				constraint->removeReference();
			}
			bs->removeReference(); 

			rb0 = rb1;

		}

		position(0) += xSpacing;

	}

	//  Remove reference from shape
	boxShape->removeReference();

	//
	//	As our demo does not use any references to the ball socket constraint, we can remove our reference
	//

	m_world->unlock();

}
예제 #18
0
SqueezedBallDemo::SqueezedBallDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{
	enableDisplayingToiInformation( true );

	// Disable warnings
	hkError::getInstance().setEnabled(0xf0de4356, false);	// 'Your m_contactRestingVelocity seems to be too small'
	hkError::getInstance().setEnabled(0xad45d441, false);	// 'SCR generated invalid velocities'
	hkError::getInstance().setEnabled(0xafe97523, false); //'This utility is intended primarily for Havok demo use. If you wish to step the world asynchronously,...'

	
	//
	// Setup the camera
	//
	{
		hkVector4 from( 6, 0, 50);
		hkVector4 to  ( 6, 0, 0);
		hkVector4 up  ( 0, 1, 0);
		setupDefaultCameras(env, from, to, up);
	}


	//
	// Setup and create the hkpWorld
	//
	{
		hkpWorldCinfo info;
		info.setBroadPhaseWorldSize(350.0f);
		info.m_collisionTolerance = .03f; 
		info.m_gravity.set(0.0f, -100.0f, 0.0f);
		info.m_enableDeactivation = false;
		info.m_simulationType = info.SIMULATION_TYPE_CONTINUOUS;

		m_world = new hkpWorld( info );
		m_world->lock();

		m_debugViewerNames.pushBack( hkpBroadphaseViewer::getName() );

		hkRegisterAlternateShapeTypes(  m_world->getCollisionDispatcher() );
		hkpPredGskfAgent::registerAgent( m_world->getCollisionDispatcher() );

		setupGraphics();		
	}


	// Create a row of boxes
	int numBodies = 0;

	for (int r = 0; r < 1; r++)
	{
		for (int i = 0; i < 1; i++)
		{
			//hkVector4 boxSize(  0.5f, 0.5f, 0.5f);			// the end pos
			//hkpConvexShape* shape = new hkpBoxShape( boxSize, 0.05f );
			hkpConvexShape* shape = new hkpSphereShape( 0.5f ); 

			hkpRigidBodyCinfo ci;
			ci.m_motionType = hkpMotion::MOTION_DYNAMIC;
			ci.m_shape = shape;
			ci.m_mass = 1.0f;
			ci.m_angularDamping = 0.0f;
			ci.m_linearDamping = 0.0f;
			hkReal d = 1.0f;
			ci.m_inertiaTensor.setDiagonal( d,d,d );
			ci.m_position.set( i * -5.0f, i * -5.0f, 0);
			ci.m_restitution = 0.9f;
			ci.m_qualityType = HK_COLLIDABLE_QUALITY_CRITICAL;
			ci.m_maxLinearVelocity = 1000.0f;
	
			hkpRigidBody* body = new hkpRigidBody(ci);
			char buff[10];
			hkString::sprintf(buff, "body%d", numBodies++);
			body->setName(buff);
			hkVector4 vel(1500.0f, 500.0f, 0.0f);
			body->setLinearVelocity(vel);

			m_world->addEntity( body )->removeReference();

			shape->removeReference();


		}
	}

	hkVector4 halfSize(40.0f, 0.5f, 10.0f);

	// Create bottom fixed body
	{
		hkpConvexShape* shape = new hkpBoxShape(halfSize, 0.0f); 

		hkpRigidBodyCinfo ci;
		ci.m_motionType = hkpMotion::MOTION_FIXED;
		ci.m_shape = shape;
		ci.m_mass = 1.0f;
		ci.m_angularDamping = 0.0f;
		ci.m_linearDamping = 0.0f;
		hkReal d = 1.0f;
		ci.m_inertiaTensor.setDiagonal( d,d,d );
		ci.m_position.set( halfSize(0), -2.0f, 0);
		ci.m_restitution = 0.9f;

		hkpRigidBody* body = new hkpRigidBody(ci);
		
		char buff[10];
		hkString::sprintf(buff, "wall%d", 0);
		body->setName(buff);

		//bodies.pushBack( body );
		m_world->addEntity( body );
		body->removeReference();
		shape->removeReference();

	}

	// Create top body
	{
		hkpConvexShape* shape = new hkpBoxShape(halfSize, 0.0f); 

		hkpRigidBodyCinfo ci;
		ci.m_motionType = hkpMotion::MOTION_DYNAMIC;
		ci.m_shape = shape;
		ci.m_mass = 1000.0f;
		ci.m_angularDamping = 0.0f;
		ci.m_linearDamping = 0.0f;
		ci.m_inertiaTensor.setDiagonal( 10e7,10e7,10e5 );
		ci.m_position.set( halfSize(0), 2.1f, 0);
		ci.m_restitution = 0.9f;
		ci.m_rotation = hkQuaternion(hkVector4(0,0,-1), 4.0f * HK_REAL_PI / 180.0f);
		ci.m_qualityType = HK_COLLIDABLE_QUALITY_MOVING;

		hkpMassProperties mp;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, ci.m_mass, mp);

		hkpRigidBody* body = new hkpRigidBody(ci);

		char buff[10];
		hkString::sprintf(buff, "wall%d", 1);
		body->setName(buff);

		//bodies.pushBack( body );
		m_world->addEntity( body );
		body->removeReference();

		shape->removeReference();
	}

	m_world->unlock();
}
예제 #19
0
int main()
{

	//speed coefficient
	float levelSpeed = 200.0f;

	// Create the main rendering window
	sf::RenderWindow rendy(sf::VideoMode::GetMode(0), "SFML Graphics", sf::Style::Fullscreen);
	
	// Load the sprite images from files
	sf::Image back;
	back.LoadFromFile("background.jpg");
	sf::Image belt;
	belt.LoadFromFile("belt.png");
	
	// Create the sprites
	sf::Sprite background;
	background.SetImage(back);
	sf::Sprite belt1;
	belt1.SetImage(belt);
	sf::Sprite belt2;
	belt2.SetImage(belt);
	sf::Sprite belt3;
	belt3.SetImage(belt);
	sf::Sprite belt4;
	belt4.SetImage(belt);
	
	// Sprites configuration
	background.SetPosition(0.0f, -750.0f);
	belt1.SetPosition(100.0f, 500.0f);
	belt2.SetPosition(500.0f, 100.0f);
	belt3.SetPosition(1300.0f, 700.0f);
	belt4.SetPosition(1800.0f, 0.0f);
	
	// Create a view
	sf::Vector2f center(720.0f, 450.0f);
	sf::Vector2f halfSize(720.0f, 450.0f);
	sf::View view(center, halfSize);
	rendy.SetView(view);
	
	// Start game loop
	while (rendy.IsOpened())
	{
		float elapsedTime = rendy.GetFrameTime();
		
		// Process events
		sf::Event event;
		while (rendy.GetEvent(event))
		{
			// Close window : exit
			if (event.Type == sf::Event::Closed)
				rendy.Close();
			if ((event.Type == sf::Event::KeyPressed) && (event.Key.Code == sf::Key::Escape))
				rendy.Close();
		}

		//Move the view and the background
		if (rendy.GetInput().IsKeyDown(sf::Key::Left))
		{
			view.Move(-levelSpeed * elapsedTime, 0.0f);
			background.Move((-levelSpeed / 2) * elapsedTime, 0.0f);
		}
		if (rendy.GetInput().IsKeyDown(sf::Key::Right))
		{
			view.Move( levelSpeed * elapsedTime, 0.0f);
			background.Move((levelSpeed / 2) * elapsedTime, 0.0f);
		}
		
		// Clear the screen (fill it with black color)
		rendy.Clear(sf::Color(100.0f, 100.0f, 200.0f));

		// Draw the sprites
		rendy.Draw(background);
		rendy.Draw(belt1);
		rendy.Draw(belt2);
		rendy.Draw(belt3);
		rendy.Draw(belt4);
		

		// Display window contents on screen
		rendy.Display();
	}

	return EXIT_SUCCESS;
}
예제 #20
0
PulleyDemo::PulleyDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{

	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, -15.0f, 0.0f);
		hkVector4 to(0.0f, 0.0f, 0.0f);
		hkVector4 up(0.0f, 0.0f, 1.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.setBroadPhaseWorldSize( 3000.0f );
		info.m_enableDeactivation = false;
		info.m_gravity.set(0,0,-10);
		m_world = new hkpWorld( info );
		m_world->lock();

		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );

		//
		// Create constraint viewer 
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;
		
		setupGraphics();
	}


	{
		//
		// Create Box Shape
		//
		hkVector4 halfSize(0.5f, 0.5f, 0.5f);
		hkpBoxShape* boxShape = new hkpBoxShape( halfSize , 0 );
		
		//
		// Create movable rigid bodies
		//
		hkpRigidBody* moveableBody0;
		hkpRigidBody* moveableBody1;
		{

			hkpRigidBodyCinfo info;
			info.m_shape = boxShape;
			
				// Compute the box inertia tensor
			hkpInertiaTensorComputer::setShapeVolumeMassProperties(boxShape, info.m_mass, info);
			info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

			hkVector4 from(1.0f, 1.0f, 1.0f);
			from.normalize3();
			hkVector4 to(0.0f, 0.0f, 1.0f);
			info.m_rotation.setShortestRotation( from, to );
			info.m_rotation.normalize();

			info.m_position.set(-3.0f, 0.0f, -2.25f);
			moveableBody0 = new hkpRigidBody(info);

			info.m_position.set(3.0f, 0.0f, -1.25f);
			moveableBody1 = new hkpRigidBody(info);

			m_world->addEntity(moveableBody0);
			m_world->addEntity(moveableBody1);

			boxShape->removeReference();

		}

		//
		// Create the pulley constraint
		// 
		hkVector4 worldPivots[2];
		worldPivots[0] = hkVector4(-3.0,0,1);
		worldPivots[1] = hkVector4(3.0,0,1);
		{
			
			hkpPulleyConstraintData* pulley = new hkpPulleyConstraintData(); 

			hkVector4 bodyPivots[2];
			bodyPivots[0] = halfSize;
			bodyPivots[1] = halfSize;
			hkReal leverageOnBodyB = 3.0f;

			pulley->setInBodySpace(moveableBody1->getTransform(), moveableBody0->getTransform(), 
									bodyPivots[1], bodyPivots[0], 
									worldPivots[1], worldPivots[0], 
									leverageOnBodyB );

			pulley->setRopeLength(9.0f);

			hkpConstraintInstance* constraint = new hkpConstraintInstance(moveableBody1, moveableBody0, pulley);

			m_world->addConstraint( constraint); 	
			constraint->removeReference();

			pulley->removeReference();
		}
		//
		// Remove references to local rigidBodies, we do not need them here anymore
		//
		moveableBody0->removeReference(); 
		moveableBody1->removeReference();

		//
		// Helper bodies preventing the constrained bodies from getting too close to the pulley pivot points.
		//
		hkpRigidBodyCinfo info;
		info.m_motionType = hkpMotion::MOTION_FIXED;
		info.m_position = worldPivots[0];
		info.m_shape = new hkpSphereShape(0.3f);
		hkpRigidBody* body = new hkpRigidBody(info);
		m_world->addEntity(body);
		body->removeReference();

		info.m_position = worldPivots[1];
		body = new hkpRigidBody(info);
		m_world->addEntity(body);
		body->removeReference();

		info.m_shape->removeReference();
	}

	m_world->unlock();
}
예제 #21
0
RagdollDemo::RagdollDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
	//
	// Setup the camera
	//
	{
		hkVector4 from(5.0f, 2.0f, 5.0f);
		hkVector4 to(0.0f, 0.0f, 0.0f);
		hkVector4 up(0.0f, 1.0f, 0.0f);
		setupDefaultCameras( env, from, to, up );
	}


	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.m_enableDeactivation = false;
		m_world = new hkpWorld( info );
		m_world->lock();

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;
		
		setupGraphics();

		// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );
	}
		  
	hkVector4 pivot(0.0f, 0.0f, 0.0f);
	hkVector4 halfSize(1.0f, 0.25f, 0.5f);

	// Create Box Shapes
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(-halfSize(0) - 1.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		info.m_motionType = hkpMotion::MOTION_FIXED;
		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}


	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(halfSize(0) + 1.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;	
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}


	//
	//	Cleanup shape references
	//
	boxShape->removeReference();
	boxShape = HK_NULL;

	//
	// CREATE RAGDOLL CONSTRAINT
	// 
	{
		hkReal planeMin =  HK_REAL_PI * -0.2f;
		hkReal planeMax =  HK_REAL_PI * 0.1f;
		hkReal twistMin =  HK_REAL_PI * -0.1f;
		hkReal twistMax =  HK_REAL_PI *  0.4f;
		hkReal coneMin  =  HK_REAL_PI * 0.3f;

		hkpRagdollConstraintData* rdc = new hkpRagdollConstraintData();

		rdc->setConeAngularLimit(coneMin);
		rdc->setPlaneMinAngularLimit(planeMin);
		rdc->setPlaneMaxAngularLimit(planeMax);
		rdc->setTwistMinAngularLimit(twistMin);
		rdc->setTwistMaxAngularLimit(twistMax);

		hkVector4 twistAxis(1.0f, 0.0f, 0.0f);
		hkVector4 planeAxis(0.0f, 1.0f, 0.0f);
		pivot.set(0.0f, 0.0f, 0.0f);
		rdc->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivot, twistAxis, planeAxis);
		
		//
		//	Create and add the constraint
		//
		{
			hkpConstraintInstance* constraint = new hkpConstraintInstance(moveableBody, fixedBody, rdc );
			m_world->addConstraint(constraint);
			constraint->removeReference();
		}		

		rdc->removeReference();
	}

	m_world->unlock();
}
예제 #22
0
HingeDemo::HingeDemo(hkDemoEnvironment* env)
:	hkDefaultPhysicsDemo(env)
{

	//
	// Setup the camera
	//
	{
		hkVector4 from(0.0f, 0.0f, 10.0f);
		hkVector4 to(0.0f, 0.0f, 0.0f);
		hkVector4 up(0.0f, 1.0f, 0.0f);
		setupDefaultCameras( env, from, to, up );
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); 
		info.setBroadPhaseWorldSize( 100.0f );
		m_world = new hkpWorld( info );
		m_world->lock();

		// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;
		
		setupGraphics();
	}

	//
	// Create vectors to be used for setup
	//
	hkVector4 halfSize(0.5f, 0.5f, 0.5f);
	hkVector4 size;
	size.setMul4(2.0f, halfSize);
	hkVector4 position(size(0), -size(1) -0.1f, 0.0f);


	//
	// Create Box Shape
	//
	hkReal radius;
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
		radius = boxShape->getRadius();
	}

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(0.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		info.m_motionType = hkpMotion::MOTION_FIXED;
		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}

	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{

		hkpRigidBodyCinfo info;
		info.m_position = position;
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;	
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;

		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}

	// Remove reference from box shape since rigid bodies now have ownership
	boxShape->removeReference();
	
	//
	// CREATE HINGE CONSTRAINT
	// 
	hkpHingeConstraintData* hc = new hkpHingeConstraintData();
	{
			// Set the pivot
		hkVector4 pivot;		
		pivot.setAdd4(position, halfSize);

		// Move pivot to center of side on cube
		pivot(0) -= size(0);
		pivot(2) -= halfSize(2);

		hkVector4 axis(0.0f, 0.0f, 1.0f);

			// Create constraint
		hc->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivot, axis);		
		
		hkpConstraintInstance* constraint = new hkpConstraintInstance(moveableBody, fixedBody, hc);
		m_world->addConstraint( constraint); 
		constraint->removeReference();

		hc->removeReference();  
	}

	m_world->unlock();
}
예제 #23
0
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Vector2
Rectangle::centerPoint() const
{
    return position_ + halfSize();
}
예제 #24
0
PoweredRagdollDemo::PoweredRagdollDemo(hkDemoEnvironment* env)
: hkDefaultPhysicsDemo(env)
{
	m_time = 0.0f;

	//
	// Setup the camera
	//
	{
		hkVector4 from(5.0f, 2.0f, 5.0f);
		hkVector4 to(0.0f, 0.0f, 0.0f);
		hkVector4 up(0.0f, 1.0f, 0.0f);
		setupDefaultCameras( env, from, to, up );
	}


	//
	// Create the world
	//
	{
		hkpWorldCinfo info;
		info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_8ITERS_MEDIUM); 
		info.m_enableDeactivation = false;
		m_world = new hkpWorld( info );
		m_world->lock();

		//
		// Create constraint viewer
		//
		m_debugViewerNames.pushBack( hkpConstraintViewer::getName() );
		hkpConstraintViewer::m_scale = 1.0f;
		
		setupGraphics();

		// Register the single agent required (a hkpBoxBoxAgent)
		hkpAgentRegisterUtil::registerAllAgents( m_world->getCollisionDispatcher() );
	}
	
	//
	// Create vectors to be used for setup
	//
	hkVector4 pivot(0.0f, 0.0f, 0.0f);
	hkVector4 halfSize(1.0f, 0.25f, 0.5f);

	//
	// Create Box Shape
	//
	hkpBoxShape* boxShape;
	{
		boxShape = new hkpBoxShape( halfSize , 0 );
	}

	//
	// Create fixed rigid body
	//
	hkpRigidBody* fixedBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(-halfSize(0) - 1.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		info.m_motionType = hkpMotion::MOTION_FIXED;
		fixedBody = new hkpRigidBody(info);
		m_world->addEntity(fixedBody);
		fixedBody->removeReference();	
	}


	//
	// Create movable rigid body
	//
	hkpRigidBody* moveableBody;
	{
		hkpRigidBodyCinfo info;
		info.m_position.set(halfSize(0) + 1.0f, 0.0f, 0.0f);
		info.m_shape = boxShape;
		
			// Compute the box inertia tensor
		hkpMassProperties massProperties;
		info.m_mass = 10.0f;
		hkpInertiaTensorComputer::computeBoxVolumeMassProperties(halfSize, info.m_mass, massProperties);
		info.m_inertiaTensor = massProperties.m_inertiaTensor;
		info.m_centerOfMass = massProperties.m_centerOfMass;	
		info.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
		moveableBody = new hkpRigidBody(info);
		m_world->addEntity(moveableBody);
		moveableBody->removeReference();	
	}


	//
	//	Cleanup shape references
	//
	boxShape->removeReference();
	boxShape = HK_NULL;

	
	//
	// CREATE POWERED RAGDOLL CONSTRAINT
	// 
	{
		hkReal planeMin =  HK_REAL_PI * -0.2f;
		hkReal planeMax =  HK_REAL_PI * 0.1f;
		hkReal twistMin =  HK_REAL_PI * -0.1f;
		hkReal twistMax =  HK_REAL_PI *  0.4f;
		hkReal coneMin  =  HK_REAL_PI * 0.3f;

		hkpRagdollConstraintData* rdc = new hkpRagdollConstraintData();

		rdc->setConeAngularLimit(coneMin);
		rdc->setPlaneMinAngularLimit(planeMin);
		rdc->setPlaneMaxAngularLimit(planeMax);
		rdc->setTwistMinAngularLimit(twistMin);
		rdc->setTwistMaxAngularLimit(twistMax);

		hkVector4 twistAxis(1.0f, 0.0f, 0.0f);
		hkVector4 planeAxis(0.0f, 1.0f, 0.0f);
		pivot.set(0.0f, 0.0f, 0.0f);
		rdc->setInWorldSpace(moveableBody->getTransform(), fixedBody->getTransform(), pivot, twistAxis, planeAxis);


		//
		//	Create and add the constraint
		//
		hkpConstraintInstance* constraint = new hkpConstraintInstance(moveableBody, fixedBody, rdc );
		m_world->addConstraint(constraint);


		hkpPositionConstraintMotor* motor = new hkpPositionConstraintMotor( 0 );
		motor->m_tau = 0.6f;
		motor->m_maxForce = 1000.0f;
		motor->m_constantRecoveryVelocity = 0.1f;

		rdc->setTwistMotor( motor ); 
		rdc->setConeMotor( motor ); 
		rdc->setPlaneMotor( motor ); 
		rdc->setMotorsActive(constraint, true);

		motor->removeReference();

		hkRotation bRa;
		bRa.setTranspose( fixedBody->getTransform().getRotation() );
		bRa.mul( moveableBody->getTransform().getRotation() );
		
		rdc->setTargetRelativeOrientationOfBodies( bRa );

		m_constraintData = rdc;
		constraint->removeReference();
	}

	
	//
	//	So that we can actually see the motor in action, rotate the constrained body slightly.
	//  When simulation starts it will then by driven to the target position (frame).
	//
	{
		hkQuaternion rot;
		hkVector4 axis( 1.0f, 0.0f, 0.0f );
		axis.normalize3();
		rot.setAxisAngle( axis, 0.4f );
		moveableBody->setRotation( rot );
	}

	m_world->unlock();
}