void SlideJoint::onEnter()
{
    BaseDemo::onEnter();
    
    auto box1 = createBox(Point(400, 200), Size(100, 100));
    auto box2 = createBox(Point(600, 400), Size(100, 100));
    this->addChild(box1);
    this->addChild(box2);
    
    PhysicsJointLimit * box_joint = PhysicsJointLimit::construct(box1->getPhysicsBody(), box2->getPhysicsBody(), Point(0, 0), Point(0, 0), 120, 200);
    _world->addJoint(box_joint);
    
    Sprite* box = nullptr;
    PhysicsJointLimit* chainJoint_limit = nullptr;
    int chainLen = 10;
    Vector<Sprite*> boxes;
    for (int i = 0; i < chainLen; i++) {
        box = createBox(Point(500 + 40 * i, 600), Size(20, 10));
        this->addChild(box);
        boxes.pushBack(box);
        if (i == 0)
        {
            box->getPhysicsBody()->setDynamic(false);
        }
        if(i > 0)
        {
            chainJoint_limit = PhysicsJointLimit::construct(boxes.at(i-1)->getPhysicsBody(), boxes.at(i)->getPhysicsBody(), Point(10, 0), Point(-10, 0), 10, 20);
            _world->addJoint(chainJoint_limit);
        }
    }
}
    void btWorldFactory::createPoolOfBalls(QVariantList &shapesList, double areaX, double areaZ, btVector3 pos, int nbBalls) {

        // walls
        btScalar wallsHeight = 10.0;
        btScalar wallsWidth = 4.0;
        createBox(shapesList, btVector3(areaX,wallsHeight,wallsWidth), pos + btVector3(0,wallsHeight*.5,areaZ*0.5-wallsWidth*0.5), btVector3(0,0,0), 0);
        createBox(shapesList, btVector3(areaX,wallsHeight,wallsWidth), pos + btVector3(0,wallsHeight*.5,-(areaZ*0.5-wallsWidth*0.5)), btVector3(0,0,0), 0);


        btScalar cubeSize = 20;
        btScalar cubeZRot = M_PI * 0.08 ;

        createBox(shapesList, btVector3(cubeSize,cubeSize,areaZ), pos + btVector3(areaX*0.5,-7,0), btVector3(0,0,cubeZRot), 0);
        createBox(shapesList, btVector3(cubeSize,cubeSize,areaZ), pos + btVector3(-areaX*0.5,-7,0), btVector3(0,0,-cubeZRot), 0);


        // balls
//        btScalar ballRadius = 1.0;

//        int nbx = 8;
//        int nby = 4;
//        int nbz = 14;

//        for(int x=0;x<nbx;x++) {
//            for(int y=0;y<nby;y++) {
//                for(int z=0;z<nbz;z++) {
//                    createSphere(shapesList,
//                                 ballRadius,pos - btVector3(nbx*ballRadius,0,nbz*ballRadius) + btVector3(x* ballRadius*2,y* ballRadius*2+ ballRadius,z* ballRadius*2),
//                                 btVector3(0,0,0),20.0);
//                }
//            }
//        }
    }
void PivotJointScene::onEnter()
{
    BaseDemo::onEnter();
    auto visibleSize = VisibleRect::getVisibleRect().size;
    
    float pierPosY = 100.0f;
    Sprite* bridgePierL = createBox(Point(visibleSize.width/2 - 400, pierPosY), Size(40, 40));
    Sprite* bridgePierR = createBox(Point(visibleSize.width/2 + 400, pierPosY), Size(40, 40));
    bridgePierL->setRotation(0);
    bridgePierR->setRotation(0);
    bridgePierL->getPhysicsBody()->setDynamic(false);
    bridgePierR->getPhysicsBody()->setDynamic(false);
    bridgePierL->getPhysicsBody()->setTag(0);
    bridgePierR->getPhysicsBody()->setTag(0);
    this->addChild(bridgePierL);
    this->addChild(bridgePierR);
    
    float ballRadius = 40.0f;
    Sprite* fallingBall = createBall(Point(visibleSize.width/2, visibleSize.height-ballRadius), ballRadius);
    this->addChild(fallingBall);
    
    Vector<Sprite*> bamboos;
    for (int i = 0; i < BAMBOO_SEGMENTS_NUM; i++)
    {
        auto box = createBox(Point(bridgePierL->getPositionX() + BAMBOO_SEGMENT_SIZE.width * i, pierPosY), BAMBOO_SEGMENT_SIZE);
        box->setRotation(0);
        this->addChild(box);
        
        bamboos.pushBack(box);
    }
    
    PhysicsJointPin* pinJointL = PhysicsJointPin::construct(bridgePierL->getPhysicsBody(), bamboos.front()->getPhysicsBody(),bridgePierL->getPosition());
    PhysicsJointPin* pinJointR = PhysicsJointPin::construct(bridgePierR->getPhysicsBody(), bamboos.back()->getPhysicsBody(),bridgePierR->getPosition());
    pinJointL->setCollisionEnable(false);
    pinJointR->setCollisionEnable(false);
    _world->addJoint(pinJointL);
    _world->addJoint(pinJointR);

    
    for (int i = 0; i < BAMBOO_SEGMENTS_NUM - 1; i++)
    {
        auto body1 = bamboos.at(i)->getPhysicsBody();
        auto body2 = bamboos.at(i+1)->getPhysicsBody();
        
        PhysicsJointPin* pivotJointUp = PhysicsJointPin::construct(body1, body2, bamboos.at(i+1)->getPosition() + Point(-BAMBOO_SEGMENT_SIZE.width/2, BAMBOO_SEGMENT_SIZE.height/2));
        
        PhysicsJointPin* pivotJointDown = PhysicsJointPin::construct(body1, body2, bamboos.at(i+1)->getPosition() + Point(-BAMBOO_SEGMENT_SIZE.width/2, -BAMBOO_SEGMENT_SIZE.height/2));
        
        PhysicsJointRotarySpring* springJoint = PhysicsJointRotarySpring::construct(body1, body2, 2000, 0.8f);
        
        pivotJointUp->setCollisionEnable(false);
        pivotJointDown->setCollisionEnable(false);
        springJoint->setCollisionEnable(false);
        _world->addJoint(pivotJointUp);
        _world->addJoint(pivotJointDown);
        _world->addJoint(springJoint);
    }
}
ClientUnit::ClientUnit(
    Rendering* const rendering, Wrapper* const wrapper,
    GameStaticData* const gameStaticData, GameDynData* const gameDynData,
    ClientSquad* const squad, const IntCode id, const Coord& coord, Input* const input
) :
    mRendering(rendering), mWrapper(wrapper),
    mGameStaticData(gameStaticData), mGameDynData(gameDynData),
    mSquad(squad), mId(id), mCoord(coord),
    mInput(input), mMode(MODE_PLAYER), mCtrl(MODE_PLAYER),
    mSpeed(100.0f, 100.0f, Math::PI/360.0f, Math::PI/360.0f), mScale(0, 0, 0, 0), mDiff(0, 0.55, 0.46, 0.45), 
    mTarget(0), mAgressor(0), mTargetTime(TIME_TO_PEACE), mAgressorTime(TIME_TO_PEACE), mFireTime(TIME_TO_CHANGE), mMoveTime(TIME_TO_CHANGE),
    mInterfaceInput( squad ? new ClientInputGame(rendering, input) : 0 ),
    mSaladin( squad ? new Saladin(rendering, wrapper) : 0 ),
    mSquadData( squad ? squad->mSquadData : 0 ),
    mLeader( squad ? squad->mLeader : 0 ), maUnit( squad ? squad->maUnit : 0 ),
    maPlayerDynData( squad ? gameDynData->aPlayerDynData : 0 ),
    Actor(wrapper->scene)
{
    if (squad) {
        for (IntVal index = 0 ; index < 5 ; ++index) {
            maState[index] = 0;
        }
        for (IntVal index = 0 ; index < MAX_AMMO ; ++index) {
            maBullet[index] = 0;
        }
        mSpeed.x *= (0.60 + (bool)mLeader*0.60);

        NxOgre::RigidBodyDescription    description;
        description.mName               = "Unit";
        description.mMass               = 24500;
        description.mWakeUpCounter      = 1E12;
        description.mMassLocalPose      = Vec3(0.00f, -2.18f, 0.0f);

        mName                           = description.mName;
        mNameHash                       = NxOgre::Strings::hash(mName);
        NxOgre::ShapeDescriptions       vShapes;
        vShapes.push_back(createBox  ( 0.00f,  0.00f,  0.00f,  4.40f,  2.50f,  7.00f));
        vShapes.push_back(createBox  ( 0.10f,  0.70f,  0.70f,  4.40f,  1.50f,  4.40f));
        vShapes.push_back(createBox  (-0.10f,  0.40f,  4.10f,  0.50f,  0.50f,  4.00f));
        vShapes.push_back(createWheel(-2.30f, -2.18f,  3.54f));
        vShapes.push_back(createWheel(-2.29f, -2.18f,  0.50f));
        vShapes.push_back(createWheel(-2.31f, -2.18f, -3.00f));
        vShapes.push_back(createWheel( 2.30f, -2.18f,  3.54f));
        vShapes.push_back(createWheel( 2.29f, -2.18f,  0.50f));
        vShapes.push_back(createWheel( 2.31f, -2.18f, -3.00f));

        this                            ->createDynamic(coord, description, vShapes);
        mSaladin                        ->init(this);

        for (IntVal index = 0 ; index < vShapes.size() ; ++index) {
            delete vShapes[index];
        }
    }
}
void ComputeAABBOnBoneVisitor::computeBoundingBoxOnBones() {
    //Perform Updates
    updateBones();
    updateRigGeometries();

    //We have our T pose, we can compute an AABB for each bone
    for (BoneList::iterator bone = _bones.begin(); bone != _bones.end(); ++ bone) {
        osg::BoundingBox bb;
        //For each geometry
        for (RigGeometryList::iterator iterator = _rigGeometries.begin(); iterator != _rigGeometries.end(); ++ iterator) {
            osgAnimation::RigGeometry* rigGeometry = *iterator;
            if(!rigGeometry) continue;

            osg::Matrix mtxLocalToSkl = rigGeometry->getWorldMatrices(_root).at(0);

            //For each Vertex influence
            osgAnimation::VertexInfluenceMap * infMap = rigGeometry->getInfluenceMap();
            osgAnimation::VertexInfluenceMap::iterator itMap = infMap->find((*bone)->getName());
            if(itMap == infMap->end()) continue;

            osg::Vec3Array *vertices = dynamic_cast<osg::Vec3Array*>(rigGeometry->getVertexArray());
            if(!vertices) continue;

            osgAnimation::VertexInfluence vxtInf = (*itMap).second;

            //Expand the boundingBox with each vertex
            for(unsigned int j = 0; j < vxtInf.size(); j++) {
                if(vxtInf.at(j).second < 10e-2) continue; //Skip vertex if low weight
                osg::Vec3 vx = vertices->at(vxtInf.at(j).first);
                vx = vx * mtxLocalToSkl;
                bb.expandBy(vx);
            }

            // Compare initial and actual boundingBox if (no change) => no box on bone
            if(bb == osg::BoundingBox() || (bb._min.x() == bb._max.x() && bb._min.y() == bb._max.y() && bb._min.z() == bb._max.z())) {
                continue;
            }

            osg::Matrix worldToBone = osg::Matrix::inverse((*bone)->getWorldMatrices(_root).at(0));

            if(_createGeometry) {
                osg::Geode *g = new osg::Geode;
                g->setName("AABB_for_bone_" + (*bone)->getName());
                g->addDrawable(createBox(bb, worldToBone));
                (*bone)->addChild(g);
            }

            serializeBoundingBox(bb, worldToBone, *(*bone));
        }
    }

    //Clear geometries
    for (RigGeometryList::iterator iterator = _rigGeometries.begin(); iterator != _rigGeometries.end(); ++ iterator) {
        osgAnimation::RigGeometry* rigGeometry = *iterator;
        if(rigGeometry) {
            rigGeometry->copyFrom(*rigGeometry->getSourceGeometry());
            rigGeometry->setRigTransformImplementation(0);
        }
    }
}
void initialise()
{
	glClearColor(0.0f, 1.0f, 1.0f, 1.0f);
	projection = glm::perspective(glm::degrees(glm::quarter_pi<float>()),
											800.0f/600.0f,
											0.1f,
											10000.0f);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_VERTEX_ARRAY);
	shaders[0] = loadShader("ambient.vert", GL_VERTEX_SHADER);
	shaders[1] = loadShader("ambient.frag", GL_FRAGMENT_SHADER);
	if (shaders[0] && shaders[1])
	{
		program = createProgram(shaders, 2);
		if (!program)
			exit(EXIT_FAILURE);
	}
	else
		exit(EXIT_FAILURE);//TODO 36 is crashing on this line, seems like it cant load shaders into program

	MVPuniform = glGetUniformLocation(program, "modelViewProjection");
	ambientMaterialUniform = glGetUniformLocation(program, "ambientMaterial");
	ambientLightUniform = glGetUniformLocation(program, "ambientLight");

	object.geometry = createBox();		
}
Beispiel #7
0
void QgsColorBox::paintEvent( QPaintEvent *event )
{
  Q_UNUSED( event );
  QPainter painter( this );

  QStyleOptionFrameV3 option;
  option.initFrom( this );
  option.state = hasFocus() ? QStyle::State_Active :  QStyle::State_None;
  style()->drawPrimitive( QStyle::PE_Frame, &option, &painter );

  if ( mDirty )
  {
    createBox();
  }

  //draw background image
  painter.drawImage( QPoint( mMargin, mMargin ), *mBoxImage );

  //draw cross lines
  double xPos = mMargin + ( width() - 2 * mMargin - 1 ) * ( double )xComponentValue() / ( double )valueRangeX();
  double yPos = mMargin + ( height() - 2 * mMargin - 1 ) - ( height() - 2 * mMargin - 1 ) * ( double )yComponentValue() / ( double )valueRangeY();

  painter.setBrush( Qt::white );
  painter.setPen( Qt::NoPen );

  painter.drawRect( xPos - 1, mMargin, 3, height() - 2 * mMargin - 1 );
  painter.drawRect( mMargin, yPos - 1, width() - 2 * mMargin - 1, 3 );
  painter.setPen( Qt::black );
  painter.drawLine( xPos, mMargin, xPos, height() - mMargin - 1 );
  painter.drawLine( mMargin, yPos, width() - mMargin - 1, yPos );

  painter.end();
}
Beispiel #8
0
void PointCloudSelectionHandler::onSelect(const Picked& obj)
{
  S_uint64::iterator it = obj.extra_handles.begin();
  S_uint64::iterator end = obj.extra_handles.end();
  for (; it != end; ++it)
  {
    int global_index = (*it & 0xffffffff) - 1;

    int index = 0;
    PointCloudBase::CloudInfoPtr cloud;

    getCloudAndLocalIndexByGlobalIndex(global_index, cloud, index);

    if (!cloud)
    {
      continue;
    }

    sensor_msgs::PointCloud2ConstPtr message = cloud->message_;

    Ogre::Vector3 pos = cloud->transform_ * pointFromCloud(message, index);

    float size = 0.002;
    if (display_->style_ != PointCloudBase::Points)
    {
      size = display_->billboard_size_ / 2.0;
    }

    Ogre::AxisAlignedBox aabb(pos - size, pos + size);

    createBox(std::make_pair(obj.handle, global_index), aabb, "RVIZ/Cyan");
  }
}
Beispiel #9
0
    void processEvent(SDL_Event *e) override
    {
        Sample::processEvent(e);
        if (e->type == SDL_KEYDOWN)
        {
            if (e->key.keysym.sym == SDLK_c)
            {
                if (mCubes.size() > 500)
                {
                    // delete oldest boxc
                    mCubes.pop_front();
                }

                String cubeName("Cube");
                cubeName.append(std::to_string(mBoxCounter++));

                BaseBody::Ptr box = createBox(cubeName);
                mCubes.push_back(box);

                kmVec3 pos = {
                    static_cast<float>(rand() % 1000),
                    static_cast<float>(rand() % 1000),
                    static_cast<float>((rand() % 1000) + 1000)
                };

                kmQuaternion rot = { 1.0f, 1.0f, 1.0f, (rand() % 1000)/1000.0f };
                box->setPosition(pos);
                box->setRotation(rot);
            }
        }
    }
    void btWorldFactory::createBoxesStairs(QVariantList &shapesList, double areaX, double areaZ, btVector3 pos, double stepWidth, double yMinStep, double yMaxStep) {

        // Boxes Floor
        double sizeX = stepWidth;
        double sizeZ = stepWidth;

        int nbBoxesX = areaX / sizeX;
        int nbBoxesZ = areaZ / sizeZ;

        double maxY = (nbBoxesX+nbBoxesZ)*Tools::random(yMinStep, yMaxStep);


        for(int i=0;i<nbBoxesX;++i){
            for(int j=0;j<nbBoxesZ;++j){

                //double sizeY = 2*maxY - sin((double)i/nbBoxesX*M_PI)*maxY - sin((double)j/nbBoxesX*M_PI)*maxY;
                double sizeY = qAbs(nbBoxesX/2. - i)/nbBoxesX*maxY + qAbs(nbBoxesZ/2. - j)/nbBoxesZ*maxY;

                createBox(shapesList,
                          btVector3(sizeX,sizeY,sizeZ),
                          btVector3(i*sizeX - areaX*0.5 + pos.x(),sizeY/2.0 + pos.y(),j*sizeZ - areaZ*0.5 +  pos.z()),
                          btVector3(0,0,0),0);
            }
        }
    }
Beispiel #11
0
void renderInCSGMode(void){
	glLoadIdentity(); //Just to be sure
	glTranslatef(0.0f,0.0f,init_zoom);//Fix Zoom
	if(menu_open)glTranslatef(boxMatrix[0]/2.0f,0.0f,0.0f);
	if(rotating){
		float tempc = cosf(rot_speed*2.0f*PI / 360.0f);
		float temps = sinf(rot_speed*2.0f*PI / 360.0f);
		float tempMatrix[16] = {
			tempc,	0.0f,	-temps,	0.0f,
			0.0f,	1.0f,	0.0f,	0.0f,
			temps,	0.0f,	tempc,	0.0f,
			0.0f,	0.0f,	0.0f,	1.0f
		};
		multMatrixBA4f(ThisRotMatrix, tempMatrix);
	}
	glMultMatrixf(ThisRotMatrix);
	glTranslatef(-(boxMatrix[0]+boxMatrix[1]+boxMatrix[2])/2.0f,
				 -(boxMatrix[4]+boxMatrix[5])/2.0f,
				 -boxMatrix[8]/2.0f); //Center Box
	
	if(box_display)createBox(boxMatrix);
	
	CSGrender();
    glDepthFunc(GL_EQUAL);
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,CrystalColors[0]);
	renderPrimitives();
    glDepthFunc(GL_LEQUAL);
	
	if(menu_open)screenFade();
}
Beispiel #12
0
OpenGLWidget::OpenGLWidget(MainWindow* mainWindow)
    : QOpenGLWidget{mainWindow}
    , m_axisLegendScene{mainWindow->app()}
    , m_width{0}
    , m_height{0}
    , m_currentLocation{}
    , m_previousLocation{}
{
    this->setFocusPolicy(Qt::StrongFocus);

    m_contextMenu = new QMenu(this);

    QMenu* createMenu = m_contextMenu->addMenu("Create");
    createMenu->addAction(tr("Box"), this, SLOT(createBox()));
    createMenu->addAction(tr("Cylinder"), this, SLOT(createCylinder()));
    createMenu->addAction(tr("Cone"), this, SLOT(createCone()));
    createMenu->addAction(tr("Sphere"), this, SLOT(createSphere()));

    m_contextMenu->addAction(tr("Import Mesh"), this, SLOT(importMesh()));

    QSurfaceFormat format = this->format();
    format.setVersion(kOpenGLMajorVersion, kOpenGLMinorVersion);
    format.setProfile(QSurfaceFormat::CoreProfile);
    format.setDepthBufferSize(32);
    format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);

    LOG(INFO) << fmt::format("Setting format with OpenGL version {}.{}", kOpenGLMajorVersion, kOpenGLMinorVersion);
    this->setFormat(format);
}
Beispiel #13
0
void SelectionHandler::updateTrackedBoxes()
{
  M_HandleToBox::iterator it = boxes_.begin();
  M_HandleToBox::iterator end = boxes_.end();
  for (; it != end; ++it)
  {
    V_AABB aabbs;
    Picked p(it->first.first);
    p.extra_handles.insert(it->first.second);
    getAABBs(Picked(it->first.first), aabbs);

    if (!aabbs.empty())
    {
      Ogre::AxisAlignedBox combined;
      V_AABB::iterator aabb_it = aabbs.begin();
      V_AABB::iterator aabb_end = aabbs.end();
      for (; aabb_it != aabb_end; ++aabb_it)
      {
        combined.merge(*aabb_it);
      }

      createBox(std::make_pair(p.handle, it->first.second), combined, "RVIZ/Cyan");
    }
  }
}
Beispiel #14
0
BlokItem::BlokItem(float w, float h,KGLEngine * parent)
        :KGLPhysicsItem(parent,KGLPhysicsItem::PolygonShape)
{
    createBox(w,h);
    setZIndex(LAYER_MIDDLE);
    m_willRemove=false;
    m_exploseSound=new KALSound(KGlobal::dirs()->findResourceDir("appdata", "data/sounds/") + "data/sounds/explosion.wav");
}
Beispiel #15
0
PropertyGroup::PropertyGroup(float min, float max, float t, QString name)
{
	createBox(name);

	properties.emplace_back(new Property(min, max, t, box));

	config();
}
Beispiel #16
0
osg::ref_ptr<osg::Camera> setupWidgets(osgViewer::Viewer* viewer)
{   
    osg::ref_ptr<osgWidget::WindowManager> wm = new osgWidget::WindowManager(
        viewer,
        1280.0f,
        1024.0f,
        MASK_2D,
        osgWidget::WindowManager::WM_PICK_DEBUG
    );
    
    wm->setPointerFocusMode(osgWidget::WindowManager::PFM_SLOPPY);

    osgWidget::Window* box1 = createBox("HBOX", osgWidget::Box::HORIZONTAL);
    osgWidget::Window* box2 = createBox("VBOX", osgWidget::Box::VERTICAL);
    osgWidget::Window* box3 = createBox("HBOX2", osgWidget::Box::HORIZONTAL);
    osgWidget::Window* box4 = createBox("VBOX2", osgWidget::Box::VERTICAL);

    box1->getBackground()->setColor(1.0f, 0.0f, 0.0f, 0.8f);
    box1->attachMoveCallback();

    box2->getBackground()->setColor(0.0f, 1.0f, 0.0f, 0.8f);
    box2->attachMoveCallback();

    box3->getBackground()->setColor(0.0f, 0.0f, 1.0f, 0.8f);
    box3->attachMoveCallback();

    wm->addChild(box1);
    wm->addChild(box2);
    wm->addChild(box3);
    wm->addChild(box4);

    box4->hide();

    osg::Camera* camera = wm->createParentOrthoCamera();

    viewer->addEventHandler(new osgWidget::MouseHandler(wm));
    viewer->addEventHandler(new osgWidget::KeyboardHandler(wm));
    viewer->addEventHandler(new osgWidget::ResizeHandler(wm, camera));
    viewer->addEventHandler(new osgWidget::CameraSwitchHandler(wm, camera));
    viewer->addEventHandler(new osgViewer::StatsHandler());
    viewer->addEventHandler(new osgViewer::WindowSizeHandler());

    wm->resizeAllWindows();

	return camera;
}
Beispiel #17
0
//--------------------------------------------------------------------------------------------------
/// Create a 3D solid box at the specified position and with the given total extents
/// 
/// \param centerPos  Position of center of box
/// \param extentX    Total extent of box along x-axis
/// \param extentY    Total extent of box along y-axis
/// \param extentZ    Total extent of box along z-axis
/// \param builder    Geometry builder to use when creating geometry
//--------------------------------------------------------------------------------------------------
void GeometryUtils::createBox(const Vec3f& centerPos, float extentX, float extentY, float extentZ, GeometryBuilder* builder)
{
    Vec3f halfExtent(extentX/2, extentY/2, extentZ/2);
    Vec3f min(centerPos - halfExtent);
    Vec3f max(centerPos + halfExtent);

    createBox(min, max, builder);
}
void Physics::testPhysics(){
	int box3 = createBox(895,95,395);

	int box4 = createBox(195,195,195);
	createJoint(box3, box4,0, 50, 50, 2, 50, 50,50, 30,30,30);

	/*
	int box = createBox(85,385,185);
	createJoint(box3, box, 0,50, 50, 3, 50, 50, 3, 0,0,0);

	int box5 = createBox(95,95,395);
	createJoint(box, box5, 0,50, 50,5, 50, 50, 0, 0,0,0);
	*/

	//	createSensor(box2, pressure);

	//NN test
	std::vector<NeuralNode*> inputs;

	for(int i=0;i< (int) sensors.size();i++){
		inputs.push_back(new NeuralNode(&sensors.at(i)));
	}

	inputs.push_back(new NeuralNode(1)); //index 3
	inputs.push_back(new NeuralNode(-2)); //index 4
	float* testPoint = new float;
	*testPoint = 5;
	inputs.push_back(new NeuralNode(testPoint)); //index 5
	theNet = new NeuralNetwork(inputs);
	theNet->insertNode(SUM,5,3,3,1);
	theNet->insertNode(SIN,1,1);
	theNet->changeLayer();
	theNet->insertNode(PRODUCT,0,1,2,2);
	theNet->stopBuilding();

	NeuralNetwork* aNet = new NeuralNetwork(theNet->getLastLayer());
	aNet->insertNode(PRODUCT,0,0,10000,10000);
	aNet->stopBuilding();
	subnets.push_back(aNet);

	effectorNNindex.push_back(0);
	effectorNNindex.push_back(1);
	effectorNNindex.push_back(2);

	solveGroundConflicts();
}
Beispiel #19
0
int main(){
    const int X=1;
    const int Y=2;
    const unsigned int R=3;
    circle myCircle=createCircle(X,Y,R);
    box myBox=createBox(myCircle);
    printBound(myBox);
    return 0;
}
Beispiel #20
0
PropertyGroup::PropertyGroup(vec2 min, vec2 max, vec2 t, QString name)
{
	createBox(name);

	properties.emplace_back(new Property(min.x, max.x, t.x, box));
	properties.emplace_back(new Property(min.y, max.y, t.y, box));

	config();
}
Beispiel #21
0
PropertyGroup::PropertyGroup(QVector2D min, QVector2D max, QVector2D t, QString name)
{
	createBox(name);

	properties.emplace_back(new Property(min.x(), max.x(), t.x(), box));
	properties.emplace_back(new Property(min.y(), max.y(), t.y(), box));

	config();
}
Beispiel #22
0
void readGeometry(scene_data* scene, const boost::property_tree::ptree& pt)
{
	boost::property_tree::ptree::const_iterator iter = pt.begin();
	for (; iter != pt.end(); ++iter)
	{
		std::string name = iter->first;
		geometry* geom;
		if (name == "cube")
			geom = createBox();
		else if (name == "tetrahedron")
			geom = createTetrahedron();
		else if (name == "pyramid")
			geom = createPyramid();
		else if (name == "disk")
		{
			int slices = iter->second.get_child("slices").get_value<int>();
			geom = createDisk(slices);
		}
		else if (name == "cylinder")
		{
			int slices = iter->second.get_child("slices").get_value<int>();
			int stacks = iter->second.get_child("stacks").get_value<int>();
			geom = createCylinder(stacks, slices);
		}
		else if (name == "sphere")
		{
			int slices = iter->second.get_child("slices").get_value<int>();
			int stacks = iter->second.get_child("stacks").get_value<int>();
			geom = createSphere(stacks, slices);
		}
		else if (name == "torus")
		{
			float radius = iter->second.get_child("radius").get_value<float>();
			int slices = iter->second.get_child("slices").get_value<int>();
			int stacks = iter->second.get_child("stacks").get_value<int>();
			geom = createTorus(radius, stacks, slices);
		}
		else if (name == "plane")
		{
			int width = iter->second.get_child("width").get_value<int>();
			int depth = iter->second.get_child("depth").get_value<int>();
			geom = createPlane(width, depth);
		}
		else if (name == "sierpinski")
		{
			int divisions = iter->second.get_child("divisions").get_value<int>();
			geom = createSierpinski(divisions);
		}
		else
		{
			std::cerr << "Error - Geometry type not recognised: " << name << std::endl;
			exit(EXIT_FAILURE);
		}
		scene->geometry[name] = geom;
	}
}
    void btWorldFactory::createSlope(QVariantList &shapesList, double areaX, double areaZ, btVector3 pos, btVector3 axis, double minAngle, double maxAngle) {



        createBox(shapesList,
                  btVector3(areaX,1.0,areaZ),
                  pos,
                  axis*Tools::random(minAngle, maxAngle),0);

    }
Beispiel #24
0
/*
 * copy the contents of one mailbox to another
 * either truncates or removes the source box if it succeeds.
 */
int
copyBox(char *from, char *to, int doremove)
{
	MbLock *ml;
	char *fimp, *timp;
	int ffd, tfd, ok;

	if(cistrcmp(from, "inbox") == 0)
		from = "mbox";

	ml = mbLock();
	if(ml == nil)
		return 0;
	ffd = openLocked(mboxDir, from, OREAD);
	if(ffd < 0){
		mbUnlock(ml);
		return 0;
	}
	tfd = createBox(to, 0);
	if(tfd < 0){
		mbUnlock(ml);
		close(ffd);
		return 0;
	}

	ok = copyData(ffd, tfd, ml);
	close(ffd);
	close(tfd);
	if(!ok){
		mbUnlock(ml);
		return 0;
	}

	fimp = impName(from);
	timp = impName(to);
	if(fimp != nil && timp != nil){
		ffd = cdOpen(mboxDir, fimp, OREAD);
		if(ffd >= 0){
			tfd = cdCreate(mboxDir, timp, OWRITE, 0664);
			if(tfd >= 0){
				copyData(ffd, tfd, ml);
				close(tfd);
			}
			close(ffd);
		}
	}
	cdRemove(mboxDir, fimp);
	if(doremove)
		cdRemove(mboxDir, from);
	else
		close(cdOpen(mboxDir, from, OWRITE|OTRUNC));
	mbUnlock(ml);
	return 1;
}
Beispiel #25
0
PropertyGroup::PropertyGroup(int min, int max, int t, QString name)
{
	createBox(name);

	properties.emplace_back(new Property(min, max, t, box));

	properties.at(0)->spinbox->setDecimals(0);
	properties.at(0)->spinbox->setSingleStep(1);

	config();
}
Beispiel #26
0
int main(int argc, char** argv) {
    osgViewer::Viewer viewer;

    osgWidget::WindowManager* wm = new osgWidget::WindowManager(
        &viewer,
        1280.0f,
        1024.0f,
        MASK_2D,
        osgWidget::WindowManager::WM_PICK_DEBUG
    );
    
    wm->setPointerFocusMode(osgWidget::WindowManager::PFM_SLOPPY);

    osgWidget::Window* box1 = createBox("HBOX", osgWidget::Box::HORIZONTAL);
    osgWidget::Window* box2 = createBox("VBOX", osgWidget::Box::VERTICAL);
    osgWidget::Window* box3 = createBox("HBOX2", osgWidget::Box::HORIZONTAL);
    osgWidget::Window* box4 = createBox("VBOX2", osgWidget::Box::VERTICAL);

    box1->getBackground()->setColor(1.0f, 0.0f, 0.0f, 0.8f);
    box1->attachMoveCallback();

    box2->getBackground()->setColor(0.0f, 1.0f, 0.0f, 0.8f);
    box2->attachMoveCallback();

    box3->getBackground()->setColor(0.0f, 0.0f, 1.0f, 0.8f);
    box3->attachMoveCallback();

    wm->addChild(box1);
    wm->addChild(box2);
    wm->addChild(box3);
    wm->addChild(box4);

    box4->hide();

    osg::Node* model = osgDB::readNodeFile("spaceship.osgt");

    model->setNodeMask(MASK_3D);

    return osgWidget::createExample(viewer, wm, model);
}
Beispiel #27
0
bool SimpleShear::generate(std::string& message)
{
	scene = shared_ptr<Scene>(new Scene);
	createActors(scene);


// Box walls
	shared_ptr<Body> w1;	// The left one :
	createBox(w1,Vector3r(-thickness/2.0,(height)/2.0,0),Vector3r(thickness/2.0,5*(height/2.0+thickness),width/2.0));
	scene->bodies->insert(w1);


	shared_ptr<Body> w2;	// The lower one :
	createBox(w2,Vector3r(length/2.0,-thickness/2.0,0),Vector3r(length/2.0,thickness/2.0,width/2.0));
	YADE_PTR_CAST<FrictMat> (w2->material)->frictionAngle = sphereFrictionDeg * Mathr::PI/180.0; // so that we have phi(spheres-inferior wall)=phi(sphere-sphere)
	scene->bodies->insert(w2);

	shared_ptr<Body> w3;	// The right one
	createBox(w3,Vector3r(length+thickness/2.0,height/2.0,0),Vector3r(thickness/2.0,5*(height/2.0+thickness),width/2.0));
	scene->bodies->insert(w3);

	shared_ptr<Body> w4; // The upper one
	createBox(w4,Vector3r(length/2.0,height+thickness/2.0,0),Vector3r(length/2.0,thickness/2.0,width/2.0));
	YADE_PTR_CAST<FrictMat> (w4->material)->frictionAngle = sphereFrictionDeg * Mathr::PI/180.0; // so that we have phi(spheres-superior wall)=phi(sphere-sphere)
	scene->bodies->insert(w4);

// To close the front and the back of the box 
	shared_ptr<Body> w5;	// behind
	createBox(w5,Vector3r(length/2.0,height/2.0,-width/2.0-thickness/2.0),	Vector3r(2.5*length/2.0,height/2.0+thickness,thickness/2.0));
	scene->bodies->insert(w5);

	shared_ptr<Body> w6;	// the front
	createBox(w6,Vector3r(length/2.0,height/2.0,width/2.0+thickness/2.0),
	Vector3r(2.5*length/2.0,height/2.0+thickness,thickness/2.0));
	scene->bodies->insert(w6);


// the list which will contain the positions of centers and the radii of the created spheres
	vector<BasicSphere> sphere_list;

// to use the TriaxialTest method :
	string out=GenerateCloud(sphere_list,Vector3r(0,0,-width/2.0),Vector3r(length,height,width/2.0),1000,0.3,0.7);// tries to generate a sample of 1000 spheres, with a required porosity of 0.7
	cout << out << endl;

// to use a text file :
// 	std::pair<string,bool> res=ImportCloud(sphere_list,filename);
	
	vector<BasicSphere>::iterator it = sphere_list.begin();
	vector<BasicSphere>::iterator it_end = sphere_list.end();
	
	shared_ptr<Body> body;
	for (;it!=it_end; ++it)
	{
		createSphere(body,it->first,it->second);
		scene->bodies->insert(body);
	}
	
	return true;
}
Beispiel #28
0
bool SkyBox::init()
{
	if(!initShader())
		return false;

	if(!createBox())
		return false;

	texture = new TextureClass();
	texture->init(device, "..\\Shaders\\skybox.dds");

	return true;
}
Beispiel #29
0
void PlatformDemoState::addItems()
{
    std::function<void(const sf::Vector2f&)> createBox = 
        [this](const sf::Vector2f& position)
    {
        auto body = xy::Component::create<xy::Physics::RigidBody>(m_messageBus, xy::Physics::BodyType::Dynamic);
        xy::Physics::CollisionRectangleShape cs({ 100.f, 100.f }, { -50.f, -50.f });
        cs.setDensity(11.f);
        cs.setFriction(0.7f);
        body->addCollisionShape(cs);

        auto model = m_meshRenderer.createModel(MeshID::Cube, m_messageBus);
        model->setBaseMaterial(m_meshRenderer.getMaterial(MatId::Demo));

        auto ent = xy::Entity::create(m_messageBus);
        ent->setPosition(position);
        ent->addComponent(body);
        ent->addComponent(model);

        m_scene.addEntity(ent, xy::Scene::BackFront);
    };


    std::function<void(const sf::Vector2f&)> createBall = 
        [this](const sf::Vector2f& position)
    {
        auto body = xy::Component::create<xy::Physics::RigidBody>(m_messageBus, xy::Physics::BodyType::Dynamic);
        xy::Physics::CollisionCircleShape cs(34.f);
        cs.setDensity(4.f);
        cs.setFriction(0.2f);
        cs.setRestitution(0.8f);
        body->addCollisionShape(cs);

        auto model = m_meshRenderer.createModel(MeshID::Sphere, m_messageBus);
        model->setBaseMaterial(m_meshRenderer.getMaterial(MatId::SphereTest));

        auto ent = xy::Entity::create(m_messageBus);
        ent->setPosition(position);
        ent->addComponent(body);
        ent->addComponent(model);

        m_scene.addEntity(ent, xy::Scene::BackFront);
    };

    for (auto i = 0u; i < 5u; ++i)
    {
        createBox({ xy::Util::Random::value(20.f, 2500.f), 20.f });
        createBall({ xy::Util::Random::value(20.f, 2500.f), 20.f });
    }

}
Beispiel #30
0
void renderShape(void){
	glLoadIdentity(); //Just to be sure
	glTranslatef(0.0f,0.0f,init_zoom);//Fix Zoom
	if(menu_open)glTranslatef(boxMatrix[0]/2.0f,0.0f,0.0f);
	if(rotating){
		float tempc = cosf(rot_speed*2.0f*PI / 360.0f);
		float temps = sinf(rot_speed*2.0f*PI / 360.0f);
		float tempMatrix[16] = {
			tempc,	0.0f,	-temps,	0.0f,
			0.0f,	1.0f,	0.0f,	0.0f,
			temps,	0.0f,	tempc,	0.0f,
			0.0f,	0.0f,	0.0f,	1.0f
		};
		multMatrixBA4f(ThisRotMatrix, tempMatrix);
	}
	glMultMatrixf(ThisRotMatrix);
	glTranslatef(-(boxMatrix[0]+boxMatrix[1]+boxMatrix[2])/2.0f,
				 -(boxMatrix[4]+boxMatrix[5])/2.0f,
				 -boxMatrix[8]/2.0f); //Center Box
	
	if(box_display)createBox(boxMatrix);
	
	for(uint i=0;i<nPart;i++){
		glPushMatrix();
		glTranslatef(particle[i].coords[0],particle[i].coords[1],particle[i].coords[2]);
		if(render_points){
			glDisable(GL_LIGHTING);
			glBegin(GL_POINTS);
				glVertex3f(0.0f,0.0f,0.0f);
			glEnd();
			glEnable(GL_LIGHTING);
		}
		else if(!particle[i].hidden){
			glScalef(scale,scale,scale);
			glRotatef(particle[i].rotation[0],particle[i].rotation[1],particle[i].rotation[2],particle[i].rotation[3]);
			if(particle[i].selected){
				glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emissive);
				glCallList(sphereDL);
				glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,black);//Reset Material
			}
			else{
				glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,CrystalColors[particle[i].solid]);
				glCallList(sphereDL);
			}
		}
		glPopMatrix();
	}
	if(menu_open)screenFade();
}