void WeaponSystem::Process(float _deltaTime, SystemRequierements& _provided) { //loading times and energy given are proportional float energyRatio = m_energyIn / m_energyDemand; //load weapons with the given energy for (auto& weapon : m_weapons) weapon.cooldown -= ei::min(weapon.cooldown, _deltaTime / weapon.cooldownBase * energyRatio); //fire when commanded if (!m_firing) return; for (auto& weapon : m_weapons) { if (weapon.cooldown <= 0.f) { weapon.cooldown = weapon.cooldownBase; Ray ray(weapon.position, m_ship.GetRotationMatrix() * Vec3(0.f, 0.f, 1.f)/*zaxis(m_ship.GetRotation())*/); ray.origin = m_ship.GetRotationMatrix() * ray.origin; //when the player ship is not in the way // if (!m_ship.GetVoxelTree().RayCast(ray, 1, hit, distance)) { Vec3 basePos(m_ship.GetPosition() - m_particles.GetPosition()); basePos += ray.origin; Math::WorldRay wRay; wRay.origin = m_ship.GetPosition(); wRay.origin.x += Math::Fix(ray.origin.x); wRay.origin.y += Math::Fix(ray.origin.y); wRay.origin.z += Math::Fix(ray.origin.z); wRay.direction = ray.direction; float d = g_fireManager->FireRay(FireRayInfo(wRay, weapon.damage)); for (int i = 0; i < 10; ++i) m_particles.AddParticle(basePos, //position ray.direction * c_projVel * i / 10.f,// velocity d / c_projVel, //life time Utils::Color8U(0.4f, 0.1f, 0.8f).RGBA(), 1.f); //temporary, hit feedback should be done by the model? if (d != 100.f) { static Generators::Random rng(351298); Vec3 hitPos(basePos + ray.direction * d); for (int i = 0; i < 50; ++i) m_particles.AddParticle(hitPos, //position Vec3(rng.Uniform(0.1f, 3.0f), rng.Uniform(0.1f,3.0f), rng.Uniform(0.1f, 3.0f)),// velocity rng.Uniform(0.2f, 1.f), //life time Utils::Color8U(0.15f, 0.2f, 0.2f).RGBA(), 0.5f); } } } } }
CompoundBodiesDemo::CompoundBodiesDemo(hkDemoEnvironment* env) : hkDefaultPhysicsDemo(env) { // // Setup the camera // { hkVector4 from(0.0f, 10.0f, 30.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.setBroadPhaseWorldSize( 100.0f ); info.setupSolverInfo(hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM); m_world = new hkpWorld( info ); m_world->lock(); // Register ALL agents (though some may not be necessary) hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher()); setupGraphics(); } // Create the base { hkVector4 baseSize( 20.0f, 1.0f, 20.0f); hkVector4 basePos( 0.0f,-0.5f, 0.0f); hkpRigidBody* baseRigidBody = GameUtils::createBox(baseSize, 0.0f, basePos); m_world->addEntity( baseRigidBody ); baseRigidBody->removeReference(); } hkPseudoRandomGenerator generator(747); // Create 10 wibblies for(int i = 0; i < 10; i++) { hkVector4 pos( generator.getRandRange(-3.0f,3.0f) , i * 3.0f + 1.5f, generator.getRandRange(-3.0f,3.0f)); hkpRigidBody* wibbly = createWibbly(pos, &generator); m_world->addEntity( wibbly ); wibbly->removeReference(); hkVector4 vel(generator.getRandRange(-2.0f,2.0f), generator.getRandRange(-2.0f,2.0f), generator.getRandRange(-2.0f,2.0f)); wibbly->setAngularVelocity(vel); } m_world->unlock(); }
void CGrassDrawer::CreateGrassDispList(int listNum) { CVertexArray* va = GetVertexArray(); va->Initialize(); for (int a = 0; a < strawPerTurf; ++a) { const float maxAng = mapInfo->grass.bladeAngle * rng.RandFloat(); const float length = mapInfo->grass.bladeHeight + mapInfo->grass.bladeHeight * rng.RandFloat(); float3 sideVect(rng.RandFloat() - 0.5f, 0.0f, rng.RandFloat() - 0.5f); sideVect.ANormalize(); float3 forwardVect = sideVect.cross(UpVector); sideVect *= mapInfo->grass.bladeWidth; float3 basePos(30.0f, 0.0f, 30.0f); while (basePos.SqLength2D() > (turfSize * turfSize / 4)) { basePos = float3(rng.RandFloat() - 0.5f, 0.f, rng.RandFloat() - 0.5f) * turfSize; } const float xtexCoord = int(14.9999f * rng.RandFloat()) / 16.0f; const int numSections = 1 + int(maxAng * 5.0f); // draw single blade for (float h = 0; h <= 1.0f; h += (1.0f / numSections)) { const float ang = maxAng * h; const float3 edgePos = (UpVector * std::cos(ang) + forwardVect * std::sin(ang)) * length * h; const float3 edgePosL = edgePos - sideVect * (1.0f - h); const float3 edgePosR = edgePos + sideVect * (1.0f - h); if (h == 0.0f) { // start with a degenerated triangle va->AddVertexT(basePos + edgePosR - float3(0.0f, 0.1f, 0.0f), xtexCoord, h); va->AddVertexT(basePos + edgePosR - float3(0.0f, 0.1f, 0.0f), xtexCoord, h); } else { va->AddVertexT(basePos + edgePosR, xtexCoord, h); } va->AddVertexT(basePos + edgePosL, xtexCoord + (1.0f / 16), h); } // end with a degenerated triangle // -> this way we can render multiple blades in a single GL_TRIANGLE_STRIP const float3 edgePos = (UpVector * std::cos(maxAng) + forwardVect * std::sin(maxAng)) * length; va->AddVertexT(basePos + edgePos, xtexCoord + (1.0f / 32), 1.0f); va->AddVertexT(basePos + edgePos, xtexCoord + (1.0f / 32), 1.0f); } glNewList(listNum, GL_COMPILE); va->DrawArrayT(GL_TRIANGLE_STRIP); glEndList(); }
// ============================================================================ // Constructor AntiAirBattery::AntiAirBattery ( World* pWorld, double location, double angle ) : Machine ( pWorld ) { setLayers( PhysLayerBuildings ); setRenderLayer( LayerBuildings ); setName("Flak"); double locationY = world()->ground()->height( location ); b2Vec2 basePos( location, locationY ); b2Vec2 bodyPos( location, locationY + 1.5 ); // create damage manager _dmMain = new DamageManager(); addDamageManager( _dmMain ); _bodyMain = BodyProvider::loadBody( "installations/flak1-body.body" ); _bodyMain->setPosition( bodyPos ); _bodyMain->create( pWorld ); addBody( _bodyMain, BodyRendered1 ); _bodyBase = BodyProvider::loadBody( "installations/flak1-base.body" ); _bodyBase->setPosition( basePos ); _bodyBase->create( pWorld ); addBody( _bodyBase, BodyRendered1 ); setMainBody( _bodyBase ); _bodyMain->setDamageManager( _dmMain ); // create gun _sysGun = Gun::berezin( this, "Gun" ); _sysGun->setBody( _bodyMain ); _sysGun->setMuzzle( QPointF( 0.0, 0.0 ) ); _sysGun->setMuzzleShift( 4.0 ); _sysGun->setNormal( QPointF( cos( angle), sin(angle) ) ); addSystem( _sysGun, SystemSimulated ); // create operator _sysOperator = new AntiAirGunOperator( this, "operator" ); _sysOperator->setGun( _sysGun ); _sysOperator->setMinAngle( 0.5 ); _sysOperator->setMaxAngle( M_PI/2 ); _sysOperator->setDamageCapacity( 100E3 ); addSystem( _sysOperator, SystemSimulated ); _lastDisplayedAngle = 0.5; // min angle from zenith; // add systems to damage manager _dmMain->addSystem( _sysGun, 1 ); _dmMain->addSystem( _sysOperator, 1 ); _dmMain->addSystem( NULL, 2 ); }
void Line::computeVertices() { Matrix<double> eff_pos_a = effectivePosA(); Matrix<double> eff_pos_b = effectivePosB(); Matrix<double> base_pos = basePos(); p_vertices[0] = eff_pos_a[0]; p_vertices[1] = eff_pos_a[1]; p_vertices[2] = eff_pos_a[2]; p_vertices[3] = eff_pos_b[0]; p_vertices[4] = eff_pos_b[1]; p_vertices[5] = eff_pos_b[2]; p_vertices[6] = base_pos[0]; p_vertices[7] = base_pos[1]; p_vertices[8] = base_pos[2]; p_vertices[9] = base_pos[0] + p_a[0]; p_vertices[10] = base_pos[1] + p_a[1]; p_vertices[11] = base_pos[2] + p_a[2]; p_vertices[12] = base_pos[0] + p_b[0]; p_vertices[13] = base_pos[1] + p_b[1]; p_vertices[14] = base_pos[2] + p_b[2]; p_vertices[15] = base_pos[0] + p_c[0]; p_vertices[16] = base_pos[1] + p_c[1]; p_vertices[17] = base_pos[2] + p_c[2]; p_vertices[18] = base_pos[0] + p_a[0] + p_b[0]; p_vertices[19] = base_pos[1] + p_a[1] + p_b[1]; p_vertices[20] = base_pos[2] + p_a[2] + p_b[2]; p_vertices[21] = base_pos[0] + p_b[0] + p_c[0]; p_vertices[22] = base_pos[1] + p_b[1] + p_c[1]; p_vertices[23] = base_pos[2] + p_b[2] + p_c[2]; p_vertices[24] = base_pos[0] + p_c[0] + p_a[0]; p_vertices[25] = base_pos[1] + p_c[1] + p_a[1]; p_vertices[26] = base_pos[2] + p_c[2] + p_a[2]; p_vertices[27] = base_pos[0] + p_a[0] + p_b[0] + p_c[0]; p_vertices[28] = base_pos[1] + p_a[1] + p_b[1] + p_c[1]; p_vertices[29] = base_pos[2] + p_a[2] + p_b[2] + p_c[2]; p_verts_computed = true; }
//----------------------------------------------------------------------------// void ScrollablePane::updateContainerPosition(void) { // basePos is the position represented by the scrollbars // (these are negated so pane is scrolled in the correct directions) UVector2 basePos(cegui_absdim(-getHorzScrollbar()->getScrollPosition()), cegui_absdim(-getVertScrollbar()->getScrollPosition())); // this bias is the absolute position that 0 on the scrollbars represent. // Allows the pane to function correctly with negatively positioned content. UVector2 bias(cegui_absdim(d_contentRect.d_min.d_x), cegui_absdim(d_contentRect.d_min.d_y)); // set the new container pane position to be what the scrollbars request // minus any bias generated by the location of the content. getScrolledContainer()->setPosition(basePos - bias); }
void ScrollablePane::updateContainerPosition(void) { assert(d_container != 0); assert(d_horzScrollbar != 0); assert(d_vertScrollbar != 0); // basePos is the position represented by the scrollbars // (these are negated so pane is scrolled in the correct directions) Point basePos(-d_horzScrollbar->getScrollPosition(), -d_vertScrollbar->getScrollPosition()); // this bias is the absolute position that 0 on the scrollbars represent. // effectively removes un-used empty space from the pane. Point bias(d_contentRect.d_left, d_contentRect.d_top); // set the new container pane position to be what the scrollbars request // minus any bias generated by the location of the content. d_container->setPosition(Absolute, basePos - bias); }
/*! @brief Determines the IDs of mobile objects that should be visible for a given field position. @param x x position of observer. @param y y position of observer. @param heading Heading of observer. @param headYaw Additional yaw caused by head position relative to body. @param headPitch Additional pitch caused by head position relative to body. @param FoV_x Horizontal field of view of the observer. @param FoV_y Vertical field of view of the observer. @return A vector of IDs representing the stationary field objects expected to be visible. */ std::vector<FieldObjects::MobileFieldObjectID> FieldObjects::GetPossibleMobileObservationIds(float x, float y, float heading, float headYaw, float headPitch, float FoV_x, float FoV_y) { // Calculate limits. // Note: These limits assume that the camera is flat horizontally. float maxAngle = heading + headYaw + FoV_x / 2.0f; // Radians float minAngle = heading + headYaw - FoV_x / 2.0f; // Radians float minDistance = 0; // cm float maxDistance = 200; // cm // Create temporary variables for use inside loop. std::vector<MobileFieldObjectID> visibleIds; Vector2<float> basePos(x,y), targetPosition; float distance, angle; bool expectedVisible; visibleIds.clear(); // Make sure list is empty. std::vector<MobileObject>::iterator stat_obj_iterator; // Check all objects. for(stat_obj_iterator = mobileFieldObjects.begin(); stat_obj_iterator != mobileFieldObjects.end(); stat_obj_iterator++) { // Get position of current field object. targetPosition = stat_obj_iterator->getEstimatedFieldLocation(); // Calculate expected measurments. distance = DistanceBetweenPoints(basePos,targetPosition); angle = AngleBetweenPoints(basePos,targetPosition); // Check if within limits. expectedVisible = (angle > minAngle) and (angle < maxAngle) and (distance > minDistance) and (distance < maxDistance); // If expected to be visible put on list. if(expectedVisible) visibleIds.push_back(MobileFieldObjectID(stat_obj_iterator->getID())); } return visibleIds; }
void SimpleEnemyShoot::operator() (BulletStage* stage, vec2f position) { float jumpRate = 360/30.0; vec2f basePos(0, 20); vec2f baseDir(0, 1); float baseSpeed = 240; float speed1 = baseSpeed; float speed2 = baseSpeed / 5 * 4; float speed3 = baseSpeed * 1.5; float speed4 = speed2 * 2.5; //float speed5 = speed3 / 2; sf::Color blue(0, 170, 255); sf::Color green(170, 255, 0); for(int i=0; i<30; i++) { float blueAngle = bluePos + (i*jumpRate); vec2f actualBluePos = rotate(basePos, blueAngle); vec2f actualBlueDir = rotate(baseDir, blueAngle); float greenAngle = greenPos + (i*jumpRate); vec2f actualGreenPos = rotate(basePos, greenAngle); vec2f actualGreenDir = rotate(baseDir, greenAngle); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed2, blue)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, green)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed4, green)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green)); } }
bool CStar97PrizeLayer::init() { if (!CCLayer::init()) return false; CCLayerColor * pBgLayer = CCLayerColor::create(ccc4(0,0,0,128), WINDOW_WIDTH, CONTENTS_HEIGHT); this->addChild(pBgLayer); if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Base, Star97_Bg_BigPrize_Bg, m_pPrize)) { m_pPrize->setAnchorPoint(CCPointZero); #ifndef ANDROID_GAME m_pPrize->setPosition(ccp(35, 78)); #else m_pPrize->setPosition(ccp(220, 20)); #endif this->addChild(m_pPrize); } //添加中奖个数 CCPoint basePos(383.0f, 150.0f); if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontAnyBar)) { m_pFontAnyBar->setAnchorPoint(ccp(0, 0.5f)); m_pFontAnyBar->setPosition(basePos); m_pFontAnyBar->setString("0"); m_pPrize->addChild(m_pFontAnyBar); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontOrange)) { m_pFontOrange->setAnchorPoint(ccp(0, 0.5f)); m_pFontOrange->setPosition(ccp(basePos.x, basePos.y + 48 * 1)); m_pFontOrange->setString("0"); m_pPrize->addChild(m_pFontOrange); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontPawpaw)) { m_pFontPawpaw->setAnchorPoint(ccp(0, 0.5f)); m_pFontPawpaw->setPosition(ccp(basePos.x, basePos.y + 48 * 2)); m_pFontPawpaw->setString("0"); m_pPrize->addChild(m_pFontPawpaw); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBell)) { m_pFontBell->setAnchorPoint(ccp(0, 0.5f)); m_pFontBell->setPosition(ccp(basePos.x, basePos.y + 48 * 3)); m_pFontBell->setString("0"); m_pPrize->addChild(m_pFontBell); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontTsama)) { m_pFontTsama->setAnchorPoint(ccp(0, 0.5f)); m_pFontTsama->setPosition(ccp(basePos.x, basePos.y + 48 * 4)); m_pFontTsama->setString("0"); m_pPrize->addChild(m_pFontTsama); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarY)) { m_pFontBarY->setAnchorPoint(ccp(0, 0.5f)); m_pFontBarY->setPosition(ccp(basePos.x, basePos.y + 48 * 5)); m_pFontBarY->setString("0"); m_pPrize->addChild(m_pFontBarY); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontLeech)) { m_pFontLeech->setAnchorPoint(ccp(0, 0.5f)); m_pFontLeech->setPosition(ccp(basePos.x, basePos.y + 48 * 6)); m_pFontLeech->setString("0"); m_pPrize->addChild(m_pFontLeech); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarR)) { m_pFontBarR->setAnchorPoint(ccp(0, 0.5f)); m_pFontBarR->setPosition(ccp(basePos.x, basePos.y + 48 * 7)); m_pFontBarR->setString("0"); m_pPrize->addChild(m_pFontBarR); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFontBarB)) { m_pFontBarB->setAnchorPoint(ccp(0, 0.5f)); m_pFontBarB->setPosition(ccp(basePos.x, basePos.y + 48 * 8)); m_pFontBarB->setString("0"); m_pPrize->addChild(m_pFontBarB); } basePos.setPoint(730.0f, 438.0f); if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont7Num7)) { m_pFont7Num7->setAnchorPoint(ccp(0, 0.5f)); m_pFont7Num7->setPosition(basePos); m_pFont7Num7->setString("0"); m_pPrize->addChild(m_pFont7Num7); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont8Num7)) { m_pFont8Num7->setAnchorPoint(ccp(0, 0.5f)); m_pFont8Num7->setPosition(ccp(basePos.x, basePos.y + 48 * 1)); m_pFont8Num7->setString("0"); m_pPrize->addChild(m_pFont8Num7); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Record, m_pFont9Num7)) { m_pFont9Num7->setAnchorPoint(ccp(0, 0.5f)); m_pFont9Num7->setPosition(ccp(basePos.x, basePos.y + 48 * 2)); m_pFont9Num7->setString("0"); m_pPrize->addChild(m_pFont9Num7); } //添加额外奖励分数 basePos.setPoint(693.0f, 355.0f); if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAllHalf)) { m_pFontExtraAllHalf->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtraAllHalf->setPosition(basePos); m_pFontExtraAllHalf->setString("0"); m_pPrize->addChild(m_pFontExtraAllHalf); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAllWhole)) { m_pFontExtraAllWhole->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtraAllWhole->setPosition(ccp(basePos.x, basePos.y - 31 * 1)); m_pFontExtraAllWhole->setString("0"); m_pPrize->addChild(m_pFontExtraAllWhole); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra9Num7)) { m_pFontExtra9Num7->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtra9Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 2)); m_pFontExtra9Num7->setString("0"); m_pPrize->addChild(m_pFontExtra9Num7); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra8Num7)) { m_pFontExtra8Num7->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtra8Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 3)); m_pFontExtra8Num7->setString("0"); m_pPrize->addChild(m_pFontExtra8Num7); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtra7Num7)) { m_pFontExtra7Num7->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtra7Num7->setPosition(ccp(basePos.x, basePos.y - 31 * 4)); m_pFontExtra7Num7->setString("0"); m_pPrize->addChild(m_pFontExtra7Num7); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Extra_Info, m_pFontExtraAnyBar)) { m_pFontExtraAnyBar->setAnchorPoint(ccp(0.5f, 0.5f)); m_pFontExtraAnyBar->setPosition(ccp(basePos.x, basePos.y - 31 * 5)); m_pFontExtraAnyBar->setString("0"); m_pPrize->addChild(m_pFontExtraAnyBar); } //总下注、总赢分 if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Table_Winlose, m_pFontAllJetton)) { m_pFontAllJetton->setAnchorPoint(ccp(0, 0.5f)); m_pFontAllJetton->setPosition(ccp(192, 77)); m_pFontAllJetton->setString("0"); m_pPrize->addChild(m_pFontAllJetton); } if (m_pResManager->GenerateNodeByCfgID(eSpriteType_Cfg, Star97_Font_Table_Winlose, m_pFontAllWin)) { m_pFontAllWin->setAnchorPoint(ccp(0, 0.5f)); m_pFontAllWin->setPosition(ccp(544, 77)); m_pFontAllWin->setString("0"); m_pPrize->addChild(m_pFontAllWin); } //使用触摸 setTouchEnabled(true); setTouchMode(kCCTouchesOneByOne); return true; }
void PlayPen_testProjectSphere::setupContent() { mSceneMgr->setAmbientLight(ColourValue::White); Plane plane; plane.normal = Vector3::UNIT_Y; plane.d = 0; MeshManager::getSingleton().createPlane("Myplane", TRANSIENT_RESOURCE_GROUP, plane, 4500,4500,10,10,true,1,5,5,Vector3::UNIT_Z); Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" ); pPlaneEnt->setMaterialName("Examples/GrassFloor"); pPlaneEnt->setCastShadows(false); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); mProjectionSphere = new Sphere(Vector3(0, 2000, 0), 1500.0); ManualObject* debugSphere = mSceneMgr->createManualObject("debugSphere"); debugSphere->begin("BaseWhiteNoLighting", RenderOperation::OT_LINE_STRIP); for (int i = 0; i <= 20; ++i) { Vector3 basePos(mProjectionSphere->getRadius(), 0, 0); Quaternion quat; quat.FromAngleAxis(Radian(((float)i/(float)20)*Math::TWO_PI), Vector3::UNIT_Y); basePos = quat * basePos; debugSphere->position(basePos); } for (int i = 0; i <= 20; ++i) { Vector3 basePos(mProjectionSphere->getRadius(), 0, 0); Quaternion quat; quat.FromAngleAxis(Radian(((float)i/(float)20)*Math::TWO_PI), Vector3::UNIT_Z); basePos = quat * basePos; debugSphere->position(basePos); } debugSphere->end(); mSceneMgr->getRootSceneNode()->createChildSceneNode(Vector3(0,2000,0))->attachObject(debugSphere); MaterialPtr mat = MaterialManager::getSingleton().create("scissormat", TRANSIENT_RESOURCE_GROUP); Pass* p = mat->getTechnique(0)->getPass(0); p->setDepthWriteEnabled(false); p->setSceneBlending(SBT_TRANSPARENT_ALPHA); TextureUnitState* t = p->createTextureUnitState(); t->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, ColourValue::Red); t->setAlphaOperation(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT, 0.5f); mScissorRect = mSceneMgr->createManualObject("mScissorRect"); mScissorRect->setUseIdentityProjection(true); mScissorRect->setUseIdentityView(true); AxisAlignedBox aabb; aabb.setInfinite(); mScissorRect->setBoundingBox(aabb); mScissorRect->begin(mat->getName()); mScissorRect->position(Vector3::ZERO); mScissorRect->position(Vector3::ZERO); mScissorRect->position(Vector3::ZERO); mScissorRect->quad(0, 1, 2, 3); mScissorRect->end(); mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(mScissorRect); mCamera->setPosition(0,3000,5000); mCamera->lookAt(mProjectionSphere->getCenter()); }
class btMultiBody* MultiBodyVehicleSetup::createMultiBodyVehicle() { class btMultiBodyDynamicsWorld* world = m_dynamicsWorld; int numWheels = 4; int totalLinks = numWheels;//number of body parts (links) (in)directly attached to the base, NOT including the base/root itself btCollisionShape* chassis = new btBoxShape(gVehicleBaseHalfExtents);//CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS)); m_collisionShapes.push_back(chassis); btCollisionShape* wheel = new btCylinderShapeX(gVehicleWheelHalfExtents);//CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS,CUBE_HALF_EXTENTS)); m_collisionShapes.push_back(wheel); btVector3 baseLocalInertia(0, 0, 0); chassis->calculateLocalInertia(gVehicleBaseMass, baseLocalInertia); bool multiDof = false; bool isFixedBase = false; bool canSleep = false; btMultiBody * bod = new btMultiBody(totalLinks, gVehicleBaseMass, baseLocalInertia, isFixedBase, canSleep);// , multiDof); bod->setHasSelfCollision(false); btQuaternion baseOrn(0, 0, 0, 1); btVector3 basePos(0, 0, 0); bod->setBasePos(basePos); bod->setWorldToBaseRot(baseOrn); btVector3 vel(0, 0, 0); bod->setBaseVel(vel); { int linkNum = 0; btVector3 wheelJointAxisWorld(1, 0, 0); btQuaternion parent_to_child = baseOrn.inverse();//?? for (int j = 0; j < numWheels; j++, linkNum++) { int parent_link_num = -1; float initial_joint_angle = 0.0; btVector3 localWheelInertia(0, 0, 0); wheel->calculateLocalInertia(gVehicleWheelMass, localWheelInertia); bool disableParentCollision = true; btVector3 pivotToChildCOM(0, 0, 0.25); btVector3 pivotToWheelCOM(0, 0, 0); { bod->setupRevolute(linkNum, gVehicleWheelMass, localWheelInertia, parent_link_num, parent_to_child, wheelJointAxisWorld, wheelAttachmentPosInWorld[j], pivotToWheelCOM, disableParentCollision); } bod->setJointPos(linkNum, initial_joint_angle); if (j<2) { btMultiBodyJointMotor* con = new btMultiBodyJointMotor(bod, linkNum, 1., 50); world->addMultiBodyConstraint(con); } } } //add a collider for the base { btAlignedObjectArray<btQuaternion> world_to_local; world_to_local.resize(totalLinks + 1); btAlignedObjectArray<btVector3> local_origin; local_origin.resize(totalLinks + 1); world_to_local[0] = bod->getWorldToBaseRot(); local_origin[0] = bod->getBasePos(); { float pos[4] = { local_origin[0].x(), local_origin[0].y(), local_origin[0].z(), 1 }; float quat[4] = { -world_to_local[0].x(), -world_to_local[0].y(), -world_to_local[0].z(), world_to_local[0].w() }; if (1) { btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(bod, -1); col->setCollisionShape(chassis); btTransform tr; tr.setIdentity(); tr.setOrigin(local_origin[0]); tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3])); col->setWorldTransform(tr); world->addCollisionObject(col, btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::AllFilter);// 2, 1 + 2); col->setFriction(friction); bod->setBaseCollider(col); } } //initialize local coordinate frames, relative to parent for (int i = 0; i<bod->getNumLinks(); i++) { const int parent = bod->getParent(i); world_to_local[i + 1] = bod->getParentToLocalRot(i) * world_to_local[parent + 1]; local_origin[i + 1] = local_origin[parent + 1] + (quatRotate(world_to_local[i + 1].inverse(), bod->getRVector(i))); } int linkIndex = 0; for (int j = 0; j<numWheels; j++, linkIndex++) { btVector3 posr = local_origin[linkIndex + 1]; float pos[4] = { posr.x(), posr.y(), posr.z(), 1 }; float quat[4] = { -world_to_local[linkIndex + 1].x(), -world_to_local[linkIndex + 1].y(), -world_to_local[linkIndex + 1].z(), world_to_local[linkIndex + 1].w() }; btMultiBodyLinkCollider* col = new btMultiBodyLinkCollider(bod, linkIndex); col->setCollisionShape(wheel); btTransform tr; tr.setIdentity(); tr.setOrigin(posr); tr.setRotation(btQuaternion(quat[0], quat[1], quat[2], quat[3])); col->setWorldTransform(tr); col->setFriction(friction); world->addCollisionObject(col, btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::AllFilter);// 2, 1 + 2); bod->getLink(linkIndex).m_collider = col; } } world->addMultiBody(bod); // world->setGravity(btVector3(0,0,0)); return bod; }
//////////////////////////////////////////////////////////// ///Entrypoint of application //////////////////////////////////////////////////////////// int main() { const int size=4; const int noOfElements=5; int popBallon[5]={0,0,0,0,0}; int i=0; float moveSpeed = 3.f, roateAngleRight=5.f, roateAngleLeft=-5.f; float rotation[4]={0.f,0.f,0.f,0.f}; float ballonRad=20.f; // Create the main window sf::RenderWindow window(sf::VideoMode(800, 600, 32), "SFML First Program"); window.setFramerateLimit(60); //load a font sf::Font font; font.loadFromFile("C:\\Windows\\Fonts\\GARA.TTF"); //get Textures sf::Texture bcg; if (!bcg.loadFromFile("background.png")){} sf::Texture body; if (!body.loadFromFile("body.png")){} sf::Texture mainArm; if (!mainArm.loadFromFile("mainArm.png")){} sf::Texture secondArm; if (!secondArm.loadFromFile("secondArm.png")){} sf::Texture clause; if (!clause.loadFromFile("clause.png")){} //Create sprite for background sf::Sprite bcgImg; bcgImg.setTexture(bcg); //Create objects //Base sf::VertexArray baseLines(sf::Quads, size); sf::Vector2f quad[size]; quad[0] = sf::Vector2f(0 , 0); quad[1] = sf::Vector2f(160, 0); quad[2] = sf::Vector2f(160, 228); quad[3] = sf::Vector2f(0 , 228); baseLines[0].texCoords = sf::Vector2f(0 , 0); baseLines[1].texCoords = sf::Vector2f(160, 0); baseLines[2].texCoords = sf::Vector2f(160, 228); baseLines[3].texCoords = sf::Vector2f(0 , 228); sf::Vector2f basePos(150.f, 330.f); //Main (Bottom) Arm sf::VertexArray mainArmLines(sf::Quads, size); sf::Vector2f points2[size]; points2[0]=sf::Vector2f(-21,-132); points2[1]=sf::Vector2f(100,-132); points2[2]=sf::Vector2f(100,20); points2[3]=sf::Vector2f(-21,20); mainArmLines[0].texCoords = sf::Vector2f(0,0); mainArmLines[1].texCoords = sf::Vector2f(121,0); mainArmLines[2].texCoords = sf::Vector2f(121,152); mainArmLines[3].texCoords = sf::Vector2f(0,152); sf::Vector2f mArmPos(70.f, 15.f); //Second (Top) Arm sf::VertexArray secondArmLines(sf::Quads, size); sf::Vector2f points3[size]; points3[0]=sf::Vector2f(0,0); points3[1]=sf::Vector2f(113,0); points3[2]=sf::Vector2f(113,150); points3[3]=sf::Vector2f(0,150); secondArmLines[0].texCoords = sf::Vector2f(0, 0); secondArmLines[1].texCoords = sf::Vector2f(113, 0); secondArmLines[2].texCoords = sf::Vector2f(113, 150); secondArmLines[3].texCoords = sf::Vector2f(0, 150); sf::Vector2f sArmPos(83.f, -117.f); //Right Clause sf::VertexArray rightFinLines(sf::Quads, size); sf::Vector2f points4[size]; points4[0]=sf::Vector2f(0,0); points4[1]=sf::Vector2f(13,0); points4[2]=sf::Vector2f(13,38); points4[3]=sf::Vector2f(0,38); rightFinLines[0].texCoords = sf::Vector2f(0, 0); rightFinLines[1].texCoords = sf::Vector2f(13, 0); rightFinLines[2].texCoords = sf::Vector2f(13, 38); rightFinLines[3].texCoords = sf::Vector2f(0, 38); sf::Vector2f rfArmPos(101.f,150.f); //Left Clause sf::VertexArray leftFinLines(sf::Quads, size); sf::Vector2f points5[size]; points5[0]=sf::Vector2f(0,0); points5[1]=sf::Vector2f(-13,0); points5[2]=sf::Vector2f(-13,38); points5[3]=sf::Vector2f(0,38); leftFinLines[0].texCoords = sf::Vector2f(0, 0); leftFinLines[1].texCoords = sf::Vector2f(13, 0); leftFinLines[2].texCoords = sf::Vector2f(13, 38); leftFinLines[3].texCoords = sf::Vector2f(0, 38); sf::Vector2f lfArmPos(101.f,150.f); //Initialize ballons sf::CircleShape ballon[5]; sf::Vector2f ballonPos[5]; ballonPos[0].x=650.f; ballonPos[0].y=450.f; ballonPos[1].x=125.f; ballonPos[1].y=90.f; ballonPos[2].x=340.f; ballonPos[2].y=150.f; ballonPos[3].x=600.f; ballonPos[3].y=250.f; ballonPos[4].x=540.f; ballonPos[4].y=50.f; ballon[0].setFillColor(sf::Color::Red); ballon[1].setFillColor(sf::Color::Green); ballon[2].setFillColor(sf::Color::Blue); ballon[3].setFillColor(sf::Color::Magenta); ballon[4].setFillColor(sf::Color::Yellow); //Set properties for ballons for (i=0; i<noOfElements; i++){ ballon[i].setRadius(ballonRad); ballon[i].setOrigin(ballonRad,ballonRad); ballon[i].setPosition(ballonPos[i]); } // Create a text for Timer and Start it sf::Text text("", font); text.setCharacterSize(30); text.setColor(sf::Color::White); std::clock_t start; start = std::clock(); int minutes=0,hours=0; double seconds; // Start game loop while (window.isOpen()){ int poppedBaloons=popBallon[0]+popBallon[1]+popBallon[2]+popBallon[3]+popBallon[4]; if (poppedBaloons != 5){ //calculate, time and convert it to string seconds = ( std::clock() - start ) / (double) CLOCKS_PER_SEC; hours=(int)seconds/(24*60); seconds=(int)seconds%(24*60); minutes=(int)seconds/60; seconds=(int)seconds%60; std::string hrs = std::to_string(hours); std::string mins = std::to_string(minutes); std::string secs = std::to_string((int)seconds); if (seconds<10) secs="0"+secs; if (minutes<10) mins="0"+mins; if (hours<10) hrs="0"+hrs; std::string s = hrs+":"+mins+":"+secs; text.setString(s); } // Process events sf::Event Event; while (window.pollEvent(Event)){ // Close window : exit if (Event.type == sf::Event::Closed) window.close(); // Escape key : exit if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Escape)) window.close(); if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Right)){ if (basePos.x<500)//stop base from moving over 500 (so it will look good with background image) basePos.x+=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Left)){ basePos.x-=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Up)){ if (rotation[0] > -139) rotation[0]-=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::Down)){ if (rotation[0] < 81) rotation[0]+=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::A)){ if (rotation[1] > -246) rotation[1]-=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::D)){ if (rotation[1] < 30) rotation[1]+=moveSpeed; } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::W)){ if (rotation[2] > -50){ rotation[2]-=moveSpeed; rotation[3]+=moveSpeed; } } if ((Event.type == sf::Event::KeyPressed) && (Event.key.code == sf::Keyboard::S)){ if (rotation[2] < 0){ rotation[2]+=moveSpeed; rotation[3]-=moveSpeed; } } } //Body transformation sf::Transform T; T.translate(basePos); //main Arm transformation & rotation sf::Transform T2; T2.translate(mArmPos); sf::Transform R2; R2.rotate(rotation[0]); sf::Transform M2=T*T2*R2; //second Arm transformation & rotation sf::Transform T3; T3.translate(sArmPos); sf::Transform R3; R3.rotate(rotation[1]); sf::Transform M3=M2*T3*R3; //right finger transformation & rotation sf::Transform T4; T4.translate(rfArmPos); sf::Transform R4; R4.rotate(rotation[2]); sf::Transform M4=M3*T4*R4; //left finger transformation & rotation sf::Transform T5; T5.translate(lfArmPos); sf::Transform R5; R5.rotate(rotation[3]); sf::Transform M5=M3*T5*R5; //update baseLines & check for collisions for(i=0;i<size;i++) { baseLines[i].position=T.transformPoint(quad[i]); mainArmLines[i].position=M2.transformPoint(points2[i]); secondArmLines[i].position=M3.transformPoint(points3[i]); rightFinLines[i].position=M4.transformPoint(points4[i]); leftFinLines[i].position=M5.transformPoint(points5[i]); //check does any of four points of each clause is in the circle, I do that by calculating distance from clause points to ballon origin for (int c=0; c<noOfElements; c++) { //right finger popping ballons float dist = sqrt(pow((ballonPos[c].x-rightFinLines[i].position.x), 2) + pow((ballonPos[c].y-rightFinLines[i].position.y), 2)); //now check if distance is smaller than ballon radius, and if it is less than radius then set ballon as popped if (dist < ballonRad) popBallon[c]=1; //left finger popping ballons (as above) dist = sqrt(pow((ballonPos[c].x-leftFinLines[i].position.x), 2) + pow((ballonPos[c].y-leftFinLines[i].position.y), 2)); if (dist < ballonRad) popBallon[c]=1; } } window.clear(); //draw frame items window.draw(bcgImg); window.draw(baseLines, &body); window.draw(rightFinLines, &clause); window.draw(leftFinLines, &clause); window.draw(secondArmLines, &secondArm); window.draw(mainArmLines, &mainArm); //if ballon is not popped draw it for (i=0; i<noOfElements; i++) { if (popBallon[i]==0) window.draw(ballon[i]); } window.draw(text); // Finally, display rendered frame on screen window.display(); } //loop back for next frame return EXIT_SUCCESS; }
void CloudsHUDController::drawLayer3D(CloudsHUDLayerSet layer, ofCamera* cam, ofVec2f& offset){ ofPushMatrix(); // Hook up to the camera to keep the layer steady. ofMatrix4x4 baseRotation; ofTranslate(cam->getPosition()); baseRotation.makeRotationMatrix(cam->getOrientationQuat()); ofMultMatrix(baseRotation); ofVec3f camPos = ofVec3f(); //cam->getPosition(); // Calculate the base position. static ofVec3f yAxis = ofVec3f(0.0, 1.0, 0.0); static ofVec3f xAxis = ofVec3f(1.0, 0.0, 0.0); // ofVec3f basePos = camPos + (cam->getLookAtDir().getScaled(layerDistance[layer])); // ofVec3f basePos(0, 0, -layerDistance[layer]); ofVec3f basePos(offset.x, offset.y, -layerDistance[layer]); basePos.rotate(layerRotationH[layer], camPos, yAxis); basePos.rotate(layerRotationV[layer], camPos, xAxis); // Get the total layer bounds. ofRectangle layerBounds; for(int i = 0; i < layerSets[layer].size(); i++){ if (i == 0) layerBounds = layerSets[layer][i]->svg.getBounds(); else layerBounds.growToInclude(layerSets[layer][i]->svg.getBounds()); } // Translate to the layer center pos. ofVec3f layerPos = basePos + (getCenter(false) - layerBounds.getCenter()); ofTranslate(layerPos); if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_OCULUS) { // Billboard rotation using the Oculus orientation. float angle; ofVec3f axis; CloudsVisualSystem::getOculusRift().getOrientationQuat().getRotate(angle, axis); ofRotate(angle, axis.x, axis.y, axis.z); ofScale(-1, 1, 1); } else if (layerBillboard[layer] == CLOUDS_HUD_BILLBOARD_CAMERA) { // Billboard rotation using the camera. ofNode node; node.setPosition(layerPos); node.lookAt(camPos); ofVec3f axis; float angle; node.getOrientationQuat().getRotate(angle, axis); ofRotate(angle, axis.x, axis.y, axis.z); } else { // ofRotateY(layerRotationH[layer]); // ofRotateX(layerRotationV[layer]); ofScale(-1, 1, 1); } // Debug circle. // ofSetColor(255); // ofCircle(0, 0, 25); // Transform for rendering the layer. ofScale(-scaleAmt, -scaleAmt, 1); ofTranslate(-layerBounds.getCenter()); // Draw the video player if we're on the right layer. if (layer == CLOUDS_HUD_PROJECT_EXAMPLE && videoPlayer.isPlaying()) { ofSetColor(255, 255, 255, 255*0.7); if( !bSkipAVideoFrame ){ // videoPlayer.draw( videoBounds.x, videoBounds.y, videoBounds.width, videoBounds.height ); } } // Draw the layer. ofSetColor(255); drawLayer(layer); // Draw the home button if we're on the right layer. if (layer == CLOUDS_HUD_LOWER_THIRD && bDrawHome && hudOpenMap[CLOUDS_HUD_LOWER_THIRD]) { home.draw(); } // Draw the associated text labels. for( map<string, CloudsHUDLabel*>::iterator it=hudLabelMap.begin(); it!= hudLabelMap.end(); ++it ){ bool bFound = false; for(int i = 0; i < layerSets[layer].size(); i++){ if (layerSets[layer][i]->svg.getMeshByID(it->first) != NULL) { bFound = true; break; } } if (bFound) { (it->second)->draw(); } } ofPopMatrix(); }
void connectSpriteActions( Triggers::TriggerGroup* editorTriggers, Input::InputManager& inputManager, Graphics::LevelSprite*& hoveredSprite, Graphics::LevelSprite*& selectedSprite, Graphics::LevelSpriteHandlePoint*& selectedHandlePoint, Scene::Scene& world, System::Cursor &cursor, Editor::EditorGrid& editorGrid, int& selectedSpriteOffsetX, int& selectedSpriteOffsetY, Editor::Tooltip& tooltip, Transform::Units& editorUnit) { inputManager.getAction("MoveHandlePoint").connect([editorTriggers, &selectedHandlePoint, &cursor, &world](const Input::InputActionEvent& event) { Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>(); if (selectedHandlePoint != nullptr) { selectedHandlePoint->moveTo(cursor.getPosition(), pixelCamera); editorTriggers->pushParameter("SpriteHandlePointMoved", "handlePoint", selectedHandlePoint); editorTriggers->trigger("SpriteHandlePointMoved"); } }); inputManager.getAction("ReleaseHandlePoint").connect([editorTriggers, &selectedHandlePoint](const Input::InputActionEvent& event) { if (selectedHandlePoint != nullptr) { editorTriggers->pushParameter("SpriteHandlePointReleased", "handlePoint", selectedHandlePoint); editorTriggers->trigger("SpriteHandlePointReleased"); selectedHandlePoint = nullptr; } }); inputManager.getAction("SpritePick").connect( [editorTriggers, &selectedSprite, &selectedSpriteOffsetX, &selectedSpriteOffsetY, &cursor, &selectedHandlePoint, &hoveredSprite, &tooltip, &world] (const Input::InputActionEvent& event) { Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>(); if (selectedSprite != nullptr && selectedHandlePoint == nullptr) { selectedHandlePoint = selectedSprite->getHandlePoint(pixelCamera, cursor.getX(), cursor.getY()); if (selectedHandlePoint != nullptr) { editorTriggers->pushParameter("SpriteHandlePointPicked", "handlePoint", selectedHandlePoint); editorTriggers->pushParameter("SpriteHandlePointPicked", "pos", pixelCamera + cursor.getPosition()); editorTriggers->trigger("SpriteHandlePointPicked"); hoveredSprite = nullptr; } else if (hoveredSprite != selectedSprite) { editorTriggers->pushParameter("SpriteUnselect", "sprite", selectedSprite); editorTriggers->trigger("SpriteUnselect"); selectedSprite->setColor(sf::Color::White); selectedSprite->unselect(); tooltip.clear(); selectedSprite = nullptr; selectedSpriteOffsetX = 0; selectedSpriteOffsetY = 0; } } if (hoveredSprite != nullptr && selectedHandlePoint == nullptr) { selectedSprite = hoveredSprite; Transform::UnitVector selectedSpriteOffset = selectedSprite->getPositionTransformer()( cursor.getPosition() - selectedSprite->getPosition(), -pixelCamera, selectedSprite->getLayer()).to<Transform::Units::ScenePixels>(); selectedSpriteOffsetX = selectedSpriteOffset.x; selectedSpriteOffsetY = selectedSpriteOffset.y; editorTriggers->pushParameter("SpriteSelect", "sprite", selectedSprite); editorTriggers->pushParameter("SpriteSelect", "offset", Transform::UnitVector(selectedSpriteOffsetX, selectedSpriteOffsetY, Transform::Units::ScenePixels)); editorTriggers->pushParameter("SpriteSelect", "pos", pixelCamera + Transform::UnitVector(cursor.getX(), cursor.getY(), Transform::Units::ScenePixels)); editorTriggers->trigger("SpriteSelect"); selectedSprite->select(); selectedSprite->setColor(sf::Color(100, 255, 100)); } }); inputManager.getAction("SpriteMove").connect( [editorTriggers, &selectedSprite, &cursor, &selectedSpriteOffsetX, &selectedSpriteOffsetY, &selectedHandlePoint, &tooltip, &world, &editorUnit] (const Input::InputActionEvent& event) { if (selectedSprite != nullptr && selectedHandlePoint == nullptr) { editorTriggers->pushParameter("SpriteMoved", "sprite", selectedSprite); editorTriggers->pushParameter("SpriteMoved", "oldPos", selectedSprite->getPosition()); Transform::UnitVector pixelCamera = world.getCamera()->getPosition().to<Transform::Units::ScenePixels>(); Transform::UnitVector basePos(cursor.getConstrainedX() - selectedSpriteOffsetX, cursor.getConstrainedY() - selectedSpriteOffsetY, Transform::Units::ScenePixels); Transform::UnitVector newPosition = selectedSprite->getPositionTransformer()(basePos, -pixelCamera, selectedSprite->getLayer()); selectedSprite->setPosition(newPosition); editorTriggers->pushParameter("SpriteMoved", "pos", selectedSprite->getPosition()); editorTriggers->pushParameter("SpriteMoved", "offset", Transform::UnitVector(selectedSpriteOffsetX, selectedSpriteOffsetY, Transform::Units::ScenePixels)); editorTriggers->trigger("SpriteMoved"); tooltip.setText("Selected Sprite : \n" " Id : {}\n" " Name : {}\n" " Pos : {}, {}\n" " Size : {}, {}\n" " Rot : {}\n" " Layer / Z : {}, {}\n", selectedSprite->getId(), selectedSprite->getPath(), selectedSprite->getPosition().to(editorUnit).x, selectedSprite->getPosition().to(editorUnit).y, selectedSprite->getSize().to(editorUnit).x, selectedSprite->getSize().to(editorUnit).y, selectedSprite->getRotation(), selectedSprite->getLayer(), selectedSprite->getZDepth()); // <REVISION> Duplicated code (See MapEditor.cpp) tooltip.setPosition(cursor.getX() + 40, cursor.getY()); } }); inputManager.getAction("SpriteRemove").connect( [editorTriggers, &selectedSprite, &world, &tooltip, &hoveredSprite, &selectedSpriteOffsetX, &selectedSpriteOffsetY] (const Input::InputActionEvent& event) { if (selectedSprite != nullptr) { editorTriggers->pushParameter("SpriteRemoved", "id", selectedSprite->getId()); editorTriggers->trigger("SpriteRemoved"); world.removeLevelSprite(selectedSprite->getId()); selectedSprite = nullptr; tooltip.clear(); hoveredSprite = nullptr; selectedSpriteOffsetX = 0; selectedSpriteOffsetY = 0; } }); inputManager.getAction("SpriteCancelOffset").connect( [&selectedSprite, &cursor, &editorGrid, &selectedSpriteOffsetX, &selectedSpriteOffsetY, &selectedHandlePoint](const Input::InputActionEvent& event) { if (selectedSprite != nullptr && selectedHandlePoint == nullptr) { selectedSpriteOffsetX = 0; selectedSpriteOffsetY = 0; } }); }
void EnemyShoot::operator() (BulletStage* stage, vec2f position) { vec2f basePos(0, 20); vec2f baseDir(0, 1); float baseSpeed = 240; //float speed5 = speed3 / 2; sf::Color blue(0, 170, 255); sf::Color green(170, 255, 0); if(stage-> timer <30) { float jumpRate = 360/8.0; float rotateRate = 360/15.0 + 5; float speed1 = baseSpeed; float speed2 = baseSpeed / 5 * 4; float speed3 = baseSpeed / 3 * 2; float speed4 = speed2 / 4 * 3; greenPos -= rotateRate * dt; if(greenPos<0) greenPos += 360; bluePos += rotateRate * dt; if(bluePos>360) bluePos -= 360; for(int i=0; i<8; i++) { float blueAngle = bluePos + (i*jumpRate); vec2f actualBluePos = rotate(basePos, blueAngle); vec2f actualBlueDir = rotate(baseDir, blueAngle); float greenAngle = greenPos + (i*jumpRate); vec2f actualGreenPos = rotate(basePos, greenAngle); vec2f actualGreenDir = rotate(baseDir, greenAngle); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue)); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green)); } } else { float jumpRate = 360/90.0; float speed1 = baseSpeed / 6 * 5; float speed2 = baseSpeed / 5 * 4; float speed3 = baseSpeed / 3 * 2; float speed4 = speed2 / 4 * 3; for(int i=0; i<90; i++) { float blueAngle = bluePos + (i*jumpRate); vec2f actualBluePos = rotate(basePos, blueAngle); vec2f actualBlueDir = rotate(baseDir, blueAngle); float greenAngle = greenPos + (i*jumpRate); vec2f actualGreenPos = rotate(basePos, greenAngle); vec2f actualGreenDir = rotate(baseDir, greenAngle); stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed1, blue)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed2, green)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualBluePos, actualBlueDir, speed3, blue)); //stage->addEnemyBullet(new BasicEnemyBullet(stage, position+actualGreenPos, actualGreenDir, speed4, green)); } } }
void Light::OnUpdate(sf::Time interval) { std::lock_guard<std::recursive_mutex> lg(m_mutex); if (!m_active || !m_render || !GetParent()->IsRender()) return; sf::Vector2f pos = GetGlobalPosition(); const auto& view = m_scene->GetGame()->GetWindow()->getView(); auto vr = sf::FloatRect(view.getCenter().x - view.getSize().x / 2, view.getCenter().y - view.getSize().y / 2, view.getSize().x, view.getSize().y); if (!vr.intersects(sf::Rect<float>(pos.x - m_radius, pos.y - m_radius, 2 * m_radius, 2 * m_radius))) { m_blocked = true; return; } b2AABB center; center.lowerBound.x = pos.x / m_scene->GetPixelMeterRatio(); center.lowerBound.y = pos.y / m_scene->GetPixelMeterRatio(); float onep = (1.f / m_scene->GetPixelMeterRatio()); center.upperBound.x = center.lowerBound.x + onep; center.upperBound.y = center.lowerBound.y + onep; CenterQuery cq(center.lowerBound.x, center.lowerBound.y); GetScene()->GetWorld()->QueryAABB(&cq, center); if (cq.hit) { cq.node->OnLightRay.Fire(this); m_blocked = true; return; } m_blocked = false; float rayDistance = (2 - cosf(m_openingAngle / (m_rayCount - 1))) * m_radius / m_scene->GetPixelMeterRatio(); b2Vec2 basePos(pos.x / m_scene->GetPixelMeterRatio(), pos.y / m_scene->GetPixelMeterRatio()); struct edgeData { b2Vec2 pos; b2Fixture* fixture; int vertex; }; std::map<int, edgeData> edges; auto EdgeFromPos = [&, this](const b2Vec2& p) -> edgeData* { float angle = atan2f(basePos.y - p.y, basePos.x - p.x) + fPI; if (angle > m_angle + m_openingAngle || angle < m_angle) { return nullptr; } int i = static_cast<int>(angle / fPI * 180) % 360; auto it = edges.find(i); if (it == edges.end()) { float r = m_radius / m_scene->GetPixelMeterRatio(); edgeData def{basePos + b2Vec2(r, r), nullptr, 0}; edges.insert(std::make_pair(i, def)); return &edges.find(i)->second; } return &it->second; }; auto aabbCallback = engine::MakeAABBQueryCallback([&, this](b2Fixture* fixture) -> bool { if (!fixture->GetBody()->GetUserData() || static_cast<Node*>(fixture->GetBody()->GetUserData())->IsOpaque()) return true; if (fixture->GetShape()->GetType() == b2Shape::e_polygon) { b2PolygonShape* shape = static_cast<b2PolygonShape*>(fixture->GetShape()); for (size_t i = 0; i < shape->GetVertexCount(); i++) { const b2Vec2& vertex = shape->GetVertex(i); b2Vec2 vertexPos = b2Mul(fixture->GetBody()->GetTransform(), vertex); auto vLen = (vertexPos - basePos).Length(); if (vLen < m_radius / m_scene->GetPixelMeterRatio()) { auto edge = EdgeFromPos(vertexPos); if (!edge) continue; // Is the vertex we found better b2Vec2 dif = edge->pos - basePos; if (vLen < dif.Length()) { edge->pos = vertexPos; } edge->fixture = fixture; edge->vertex = i; } } } return true; }); b2AABB aabb; aabb.lowerBound = b2Vec2((pos.x - m_radius) / m_scene->GetPixelMeterRatio(), (pos.y - m_radius) / m_scene->GetPixelMeterRatio()); aabb.upperBound = b2Vec2((pos.x + m_radius) / m_scene->GetPixelMeterRatio(), (pos.y + m_radius) / m_scene->GetPixelMeterRatio()); m_scene->GetWorld()->QueryAABB(&aabbCallback, aabb); float step = m_openingAngle / static_cast<float> (m_rayCount - 1); float angle = m_angle; auto it = edges.begin(); m_vertices.resize(1); // keep the center vertex float f = 1.0; Node* hitNode = nullptr; auto rayCastCallback = MakeRayCastCallback([&](b2Fixture* fixture, const b2Vec2& point, const b2Vec2& normal, float32 fraction) { Node* n = static_cast<Node*> (fixture->GetBody()->GetUserData()); if (n && !n->IsOpaque() && fraction < f) { f = fraction; hitNode = n; } return f; }); sf::Vertex v; float edgeAngle = 0; v.position.x = cosf(angle) * m_radius; v.position.y = sinf(angle) * m_radius; f = 1.0; m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, basePos + b2Vec2(v.position.x / m_scene->GetPixelMeterRatio(), v.position.y / m_scene->GetPixelMeterRatio())); if (hitNode) hitNode->OnLightRay.Fire(this); v.position.x *= f; v.position.y *= f; AssignLightColor(v, f, m_lightColor); m_vertices.push_back(v); angle += step; for (size_t i = 2; i < m_rayCount + 1; i++, angle += step) { bool had = false; while (it != edges.end()) { edgeAngle = b2Angle(basePos, it->second.pos); if (edgeAngle < 0) edgeAngle += fPI * 2; if (angle < edgeAngle || edgeAngle >= angle + step) { break; } if (it->second.fixture == nullptr) { ++it; continue; } f = 1.0; m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, it->second.pos); // Check if this edge is blocked, skip if it is if (f < 1.0 - 10.0f / m_radius) { ++it; continue; } if (hitNode) hitNode->OnLightRay.Fire(this); had = true; float edgeLengthPct = m_scene->MeterToPixel((basePos - it->second.pos).Length()) / m_radius + (10.0f / m_radius); auto addPoint = [&, this](b2Vec2 point) { v.position.x = m_scene->MeterToPixel(point.x) - pos.x; v.position.y = m_scene->MeterToPixel(point.y) - pos.y; f = sqrtf(v.position.x * v.position.x + v.position.y * v.position.y) / m_radius; AssignLightColor(v, f, m_lightColor); m_vertices.push_back(v); }; // Check surrounding edges by using half a degree differences float checkAngle = edgeAngle - (fPI / 840.f); if (checkAngle > 0) { f = 1.0; b2Vec2 edge = b2Vec2(cosf(edgeAngle - (fPI / 840.f)), sinf(edgeAngle - (fPI / 840.f))); edge *= (m_radius / m_scene->GetPixelMeterRatio()); edge += basePos; m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, edge); if (f > edgeLengthPct) { b2Vec2 p = (basePos - edge); p *= -f; addPoint(basePos + p); } } addPoint(it->second.pos); f = 1.0; checkAngle = edgeAngle + (fPI / 840.f); if (checkAngle < fPI * 2) { b2Vec2 edge = b2Vec2(cosf(checkAngle), sinf(checkAngle)); edge *= (m_radius / m_scene->GetPixelMeterRatio()); edge += basePos; m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, edge); if (f > edgeLengthPct) { b2Vec2 p = (basePos - edge); p *= -f; addPoint(basePos + p); } } ++it; } // Prevent overlapping rays if (!had || had && !floatEqual(edgeAngle, angle, fPI / 180.0f) || i == 1 || i == m_rayCount) { v.position.x = cosf(angle) * m_radius; v.position.y = sinf(angle) * m_radius; f = 1.0; m_scene->GetWorld()->RayCast(&rayCastCallback, basePos, basePos + b2Vec2(v.position.x / m_scene->GetPixelMeterRatio(), v.position.y / m_scene->GetPixelMeterRatio())); if (hitNode) hitNode->OnLightRay.Fire(this); v.position.x *= f; v.position.y *= f; AssignLightColor(v, f, m_lightColor); m_vertices.push_back(v); } } }