void ChildAlias::mouseDown (const MouseEvent& e)
{
 
//if (e.mods.isLeftButtonDown()){
((CabbageMainPanel*)(getTarget()->getParentComponent()))->setMouseState("down");
   toFront (true);
   if (e.eventComponent == resizer)
   {
   }
   else
   {
      //added a constrainer so that components can't be dragged off-screen
      constrainer->setMinimumOnscreenAmounts(getHeight(), getWidth(), getHeight(), getWidth());
      dragger.startDraggingComponent (this,e);
   }
   userAdjusting = true;
   startBounds = getBounds ();
   userStartedChangingBounds ();

   //get the bounds of each of the child components if we are dealing with a plant
   Component* c = (Component*) target.getComponent ();
   origBounds.clear();
   for(int i=0;i<c->getNumChildComponents();i++){
   origBounds.add(c->getChildComponent(i)->getBounds());
   }


   //update dimensions
   int offX = getProperties().getWithDefault(var::identifier("plantX"), 0);
   int offY = getProperties().getWithDefault(var::identifier("plantY"), 0);

   ((CabbageMainPanel*)(getTarget()->getParentComponent()))->setIndex(index);
   ((CabbageMainPanel*)(getTarget()->getParentComponent()))->currentBounds.setBounds(getPosition().getX()-offX,
																					 getPosition().getY()-offY,
																					 getWidth(),
																					 getHeight());

   ((CabbageMainPanel*)(getTarget()->getParentComponent()))->sendActionMessage("Message sent from CabbageMainPanel:Down");

#ifdef Cabbage_Build_Standalone
	if(e.mods.isRightButtonDown()){
		PopupMenu m;
		m.setLookAndFeel(&getParentComponent()->getLookAndFeel());
		m.addItem(2, "Delete");
		m.addItem(1, "Add to repository");
		int choice = m.show();
		if(choice==1){
			this->getTopLevelComponent()->setAlwaysOnTop(false);
			AlertWindow alert("Add to Repository", "Enter a name and hit 'escape'", AlertWindow::NoIcon, this->getTopLevelComponent()); 
			CabbageLookAndFeel basicLookAndFeel;
			alert.setLookAndFeel(&basicLookAndFeel);
			alert.setColour(TextEditor::textColourId, Colours::white);
			//alert.addTextBlock("Enter a name and hit 'escape'(The following symbols not premitted in names:"" $ % ^ & * ( ) - + )");
			alert.addTextEditor("textEditor", "name", "");
			alert.runModalLoop();
			this->getTopLevelComponent()->setAlwaysOnTop(true);
				bool clashingNames=false;
				int result; 
				
				String plantDir = appProperties->getUserSettings()->getValue("PlantFileDir", "");	
				Logger::writeToLog(plantDir);
				Array<File> tempfiles;
				StringArray plants;   
				addFileToPpopupMenu(m, tempfiles, plantDir, "*.plant");
				
				for(int i=0;i<tempfiles.size();i++){
				Logger::outputDebugString(tempfiles[i].getFullPathName());
				plants.add(tempfiles[i].getFileNameWithoutExtension());
				}
				
				for(int i=0;i<plants.size();i++)				
				if(plants[i]==alert.getTextEditorContents("textEditor"))
					clashingNames = true;

				if(clashingNames==true){
					result = CabbageUtils::showYesNoMessage("Do you wish to overwrite the existing plant?", &getLookAndFeel());	
					if(result == 0)
					((CabbageMainPanel*)(getTarget()->getParentComponent()))->sendActionMessage("Message sent from CabbageMainPanel:AddingPlant:"+alert.getTextEditorContents("textEditor"));
					else
						showMessage("Nothing written to repository", &getLookAndFeel());
				}
				else ((CabbageMainPanel*)(getTarget()->getParentComponent()))->sendActionMessage("Message sent from CabbageMainPanel:AddingPlant:"+alert.getTextEditorContents("textEditor"));

		}
		else if(choice==2){
			((CabbageMainPanel*)(getTarget()->getParentComponent()))->sendActionMessage("Message sent from CabbageMainPanel:delete:");
			}
		
		}
#endif

}
void GroupReference::targetObjectDestroyLink()
{
    // called from unlink()
    getTarget()->DelinkMember(this);
}
Exemple #3
0
//============================================================
// Tell our refTo (target) object that we have a link
void HostileReference::targetObjectBuildLink()
{
    getTarget()->AddHatedBy(this);
}
void FollowerReference::targetObjectBuildLink()
{
    getTarget()->addFollower(this);
}
Exemple #5
0
/* Returns Right Vector */
Vector Camera::getRight()
{
    Vector right = crossProduct(getTarget(), this->up);
    right.normalize();
    return right;
}
Exemple #6
0
    void ActionEquip::executeImp (const Ptr& actor)
    {
        MWWorld::Ptr object = getTarget();
        MWWorld::InventoryStore& invStore = actor.getClass().getInventoryStore(actor);

        std::pair <int, std::string> result = object.getClass().canBeEquipped (object, actor);

        // display error message if the player tried to equip something
        if (!result.second.empty() && actor == MWBase::Environment::get().getWorld()->getPlayerPtr())
            MWBase::Environment::get().getWindowManager()->messageBox(result.second);

        switch(result.first)
        {
            case 0:
                return;
            case 2:
                invStore.unequipSlot(MWWorld::InventoryStore::Slot_CarriedLeft, actor);
                break;
            case 3:
                invStore.unequipSlot(MWWorld::InventoryStore::Slot_CarriedRight, actor);
                break;
        }

        // slots that this item can be equipped in
        std::pair<std::vector<int>, bool> slots_ = getTarget().getClass().getEquipmentSlots(getTarget());

        // retrieve ContainerStoreIterator to the item
        MWWorld::ContainerStoreIterator it = invStore.begin();
        for (; it != invStore.end(); ++it)
        {
            if (*it == object)
            {
                break;
            }
        }

        assert(it != invStore.end());

        // equip the item in the first free slot
        for (std::vector<int>::const_iterator slot=slots_.first.begin();
            slot!=slots_.first.end(); ++slot)
        {
            // if the item is equipped already, nothing to do
            if (invStore.getSlot(*slot) == it)
                return;

            // if all slots are occupied, replace the last slot
            if (slot == --slots_.first.end())
            {
                invStore.equip(*slot, it, actor);
                break;
            }

            if (invStore.getSlot(*slot) == invStore.end())
            {
                // slot is not occupied
                invStore.equip(*slot, it, actor);
                break;
            }
        }
    }
Exemple #7
0
void RangedManager::executeMicro(const UnitVector & targets) 
{
	const UnitVector & rangedUnits = getUnits();

	// figure out targets
	UnitVector rangedUnitTargets;
	for (size_t i(0); i<targets.size(); i++) 
	{
		// conditions for targeting
		if (targets[i]->isVisible()) 
		{
			rangedUnitTargets.push_back(targets[i]);
		}
	}

	// for each zealot
	BOOST_FOREACH(BWAPI::Unit * rangedUnit, rangedUnits)
	{
		// train sub units such as scarabs or interceptors
		//trainSubUnits(rangedUnit);

		// if the order is to attack or defend
		if (order.type == order.Attack || order.type == order.Defend) {

			// if there are targets
			if (!rangedUnitTargets.empty())
			{
				

				// find the best target for this zealot
				BWAPI::Unit * target = getTarget(rangedUnit, rangedUnitTargets);

				/*
				if ( rangedUnit->getType().groundWeapon().maxRange() < target->getDistance(rangedUnit))
				{
					if(rangedUnit->getType() == BWAPI::UnitTypes::Zerg_Lurker)
					{
					//BWAPI::Broodwar->printf("############# Lurker in distance: %d ###############",  rangedUnit->getID());
					LurkerBurrow(rangedUnit);
					}
				}
				*/

				// attack it
				kiteTarget(rangedUnit, target);
			}
			// if there are no targets
			else
			{


				// if we're not near the order position
				if (rangedUnit->getDistance(order.position) > 100)
				{
					// move to it
					smartAttackMove(rangedUnit, order.position);
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG) 
		{
			BWAPI::Broodwar->drawLineMap(rangedUnit->getPosition().x(), rangedUnit->getPosition().y(), 
				rangedUnit->getTargetPosition().x(), rangedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}
}
bool    Properties::hasStaticProperty( QString propertyName ) const
{
    if ( getTarget() == nullptr )
        return false;
    return ( getTarget()->metaObject( )->indexOfProperty( propertyName.toLatin1( ) ) != -1 );
}
llvm_dsp_factory* FaustgenFactory::createFactoryFromSourceCode(FaustAudioPluginInstance* instance)
{
  defaultCompileOptions();

  // Prepare compile options
  std::string error;
  const char* argv[64];
  memset(argv, 0, 64 * sizeof(char*));
  
  jassert(fCompileOptions.size() < 64);
  
  for (auto opt = 0; opt < fCompileOptions.size(); opt++)
  {
    argv[opt] = (char*) fCompileOptions.getReference(opt).toRawUTF8();
  }
  
  argv[fCompileOptions.size()] = 0; // NULL terminated argv
  
  llvm_dsp_factory* factory = createDSPFactoryFromString(getTMPName().toStdString(), fSourceCode.toStdString(), fCompileOptions.size(), argv, getTarget(), error, LLVM_OPTIMIZATION);
    
  if (factory)
  {
    return factory;
  }
  else
  {
    if (fUpdateInstance == instance)
    {
      instance->highlightON(error);
    }
    LOG("Invalid Faust code or compile options:" + error);
    return 0;
  }
}
Exemple #10
0
IRCTargetType IRCRoom::getType() const
{
	return getTarget()->getType();
}
Exemple #11
0
shared_ptr<IRCSession> IRCRoom::getSession() const
{
	return getTarget()->getSession();
}
Exemple #12
0
std::string IRCRoom::getName() const
{
	return getTarget()->getName();
}
Exemple #13
0
bool Ammo::perform( Action a, const Target& t )
{

    switch ( a )
    {
        case aPolymorph:
            form = Random::randint( ammoStats::numAmmo );
            image.val.color = ammoStats::AmmoStats[form].color;
            return Item::perform(a, t);
        case aFire:
        {

            // We now just mark the bullet as fired, to ensure it disappears:
            fired = true;
            // This code should no longer be called, thus:
            /*
              Point3d me=getlocation(), target = t->getlocation();
              int acc = ammoStats::AmmoStats[form].accuracy;
              int scatter =  (acc * max( abs((me-target).getx()), abs((me-target).gety()) ) ) / 10;
              scatter = scatter / 2-scatter;

              // Multiple attacks:
              int numslugs = ammoStats::AmmoStats[form].numslugs;
              if (numslugs > 1)
              for (int slugs = 1; slugs < numslugs; slugs++) {
                  Target slug = clone();
                  target = t->getlocation() + Point3d( Random::randint(scatter),Random::randint(scatter), 0 );
              Target parent = getTarget(tg_parent);
              assert(!!parent);
                  parent->perform(aContain,slug);
              FlightPath::Option flight_opt;
              flight_opt.object = slug;
              flight_opt.start = me;
              flight_opt.delta = Point3d( target-me ).toPoint();
              FlightPath::create( flight_opt );
                  }

            // Make sure that at least this bullet hits the target:
              target = t->getlocation();// + Point( Random::randint(scatter),Random::randint(scatter) );
              Target tMe = Target(THIS);
            FlightPath::Option flight_opt;
            flight_opt.object = tMe;
            flight_opt.start = me;
            flight_opt.delta = Point3d( target-me ).toPoint();
              FlightPath::create( flight_opt );
            */
            return true;
        }
        case aRestack:

            if (fired)
            {
                Cloud::Option cloud_opt;
                Target my_parent = getTarget(tg_parent);

                // Sometimes this can fail.  No memory leak caused,
                // though I should find the cause when I can.
                //assert(!!my_parent);

                if (!my_parent)
                {

                    // May have negative effect on grenade use.

                    // In any case, fail gracefully & don't tell the player:
                    //Message::add("Ammo::perform(aRestack) failure.");

                    return false;
                }

                switch (ammoStats::AmmoStats[form].effect)
                {
                    case ae_smoke:

                        if (my_parent != NULL)
                        {
                            cloud_opt.material = m_smoke;
                            my_parent->perform( aContain, Cloud::create(cloud_opt) );
                        }

                        break;
                    case ae_gas:

                        if (my_parent != NULL)
                        {
                            cloud_opt.material = m_poison;
                            my_parent->perform( aContain, Cloud::create(cloud_opt) );
                        }

                        break;
                    case ae_explode:
                    {
                        // Grenades must soon be rewritten
                        // to acommodate for the new global positioning.

                        /*
                          Point loc = getlocation().toPoint(), cursor = Screen::cursorat();
                          // All grenade rounds have an explosion radius of 2
                          int radius = 2, gx = loc.getx(), gy = loc.gety(),
                              x, y;
                          bool **los;
                          los = new bool *[radius*2+1];
                          for (int i = 0; i < radius*2+1; ++i)
                            los[i] = new bool[radius*2+1];
                        //                xa = max(x-radius,0), xb = min(x+radius,(int)(map_width-1)),
                        //                ya = max(y-radius,0), yb = min(y+radius,(int)(map_height-1));
                          Level &lev = getlevel();
                          Rectangle lev_border = lev.getBorder();
                          Target deliverer = getTarget(tg_controller);
                          Attack dam( 6, DiceRoll(4,3), CombatValues(dam_burn,+10), deliverer, THIS, "grenaded" );
                          Screen::Buffer restore;
                          restore.setSize( Rectangle(max(gx-radius+1,lev_border.getxa()+1)+Screen::mapxoff,
                                                     max(gy-radius+1,lev_border.getya()+1)+Screen::mapyoff,
                                                     min(gx+radius+1,lev_border.getxb()+1)+Screen::mapxoff,
                                                     min(gy+radius+1,lev_border.getyb()+1)+Screen::mapyoff) );

                          for (y = -radius; y <= radius; ++y)
                            for (x = -radius; x <= radius; ++x) {
                              los[x+radius][y+radius] = false;
                              if ( lev_border.contains( Point(gx+x,gy+y) ) ) {
                                Path p;
                                      p.set( loc, loc+Point(x,y) );
                                      p.calculate();

                                      if ( p.hasLOS(lev) )
                                  los[x+radius][y+radius] = true;

                                }
                              }

                          Screen::hidecursor();
                          for (y = -radius; y <= radius; ++y)
                            for (x = -radius; x <= radius; ++x)
                              if (los[x+radius][y+radius] && lev.getTile( Point(gx+x,gy+y) )->getVal(attrib_visible))
                                LEVDRAW(gx+x,gy+y, Image(cRed,'*'));
                          Screen::locate(cursor);
                          Screen::showcursor();

                          Screen::nextFrame();
                          Screen::hidecursor();
                          for (y = -radius; y <= radius; ++y)
                            for (x = -radius; x <= radius; ++x)
                              if (los[x+radius][y+radius] && lev.getTile( Point(gx+x,gy+y) )->getVal(attrib_visible))
                                LEVDRAW(gx+x,gy+y, Image(cOrange,'*'));
                          Screen::locate(cursor);
                          Screen::showcursor();

                          Screen::nextFrame();
                          Screen::hidecursor();
                          for (y = -radius; y <= radius; ++y)
                            for (x = -radius; x <= radius; ++x)
                              if (los[x+radius][y+radius] && lev.getTile( Point(gx+x,gy+y) )->getVal(attrib_visible))
                                LEVDRAW(gx+x,gy+y, Image(cYellow,'*'));
                          Screen::locate(cursor);
                          Screen::showcursor();

                          Screen::nextFrame();
                          Screen::hidecursor();
                          restore.moveToScreen();
                          for (y = -radius; y <= radius; ++y)
                            for (x = -radius; x <= radius; ++x)
                              if (los[x+radius][y+radius])
                                lev.getTile( Point(gx+x,gy+y) )->takeDamage( dam );
                          Screen::locate(cursor);
                          Screen::showcursor();

                          for (int i = 0; i < radius*2+1; ++i)
                            delarr(los[i]);
                          delarr(los);
                          */
                        break;
                    }

                    default:
                        break;
                }

                detach();
            }
            else
            {
                return Item::perform(a, t);
            }

            return true;

        case aLand:

            if ( ammoStats::AmmoStats[form].type == bul_grenade )
            {
                fired = true;
            }

            return Item::perform(a, t);

        case aAttack:
        {

            // If this slug was fired, make sure to give 'shooty' messages:
            String subject, object,
                   hit_str = "hit~";
            Target shooter;

            // If the bullet was fired you want the, "You shoot the frog."
            // message; otherwise you want a "The bullet hits the frog." message.
            if (fired)
            {
                shooter = getTarget(tg_controller);
            }
            else
            {
                shooter = THIS;
            }

            subject = Grammar::Subject(shooter, Grammar::det_definite);
            object = Grammar::Object(t, Grammar::det_definite);

            if (fired)
            {
                hit_str = "shoot~";
            }


            bool t_was_alive = t->getVal(attrib_alive);


            t->takeDamage( getAttack() );

            // If we have killed the target:
            if ( t->getVal(attrib_alive) != t_was_alive )
                if (t->getVal(attrib_flesh_blood))
                {
                    hit_str = "kill~";
                }
                else
                {
                    hit_str = "destroy~";
                }

            if ( RawTarget::getVal(attrib_visible) || t->getVal(attrib_visible) )
            {
                Message::add( subject + " " + Grammar::plural(hit_str, 2 - shooter->getVal(attrib_plural), true, false) + " " + object + "." );
            }

            return true;
        }

        default:
            return Item::perform(a, t);
    }

}
Exemple #14
0
void RandomGen::exec( Array< Sample > &samples )
{
	for ( int i = 0 ; i < outputsCount() ; ++i )
		samples += ( Sample ){ getTarget( i ), qrand() / ( RAND_MAX / 2.0f ) - 1.0f };
}
Exemple #15
0
void VBO::unbind()
{
	if (!is_mapped)
		glBindBufferARB(getTarget(), 0);
}
dsp* FaustgenFactory::createDSPAux(FaustAudioPluginInstance* instance)
{
  dsp* dsp = nullptr;
  std::string error;
  String logStr;

  // Factory already allocated
  if (fDSPfactory)
  {
    dsp = fDSPfactory->createDSPInstance();
    logStr << "Factory already allocated, " <<  dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
    goto end;
  }
  
  // Tries to create from bitcode
  if (fBitCode.length() > 0)
  {
    fDSPfactory = createFactoryFromBitcode();
    if (fDSPfactory)
    {
      dsp = fDSPfactory->createDSPInstance();
      logStr << "Compilation from bitcode succeeded, " <<  dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
      goto end;
    }
  }
  
  // Otherwise tries to create from source code
  if (fSourceCode.length() > 0)
  {
    fDSPfactory = createFactoryFromSourceCode(instance);
    if (fDSPfactory)
    {
      dsp = fDSPfactory->createDSPInstance();
      logStr << "Compilation from source code succeeded, " <<  dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
      goto end;
    }
  }
  
  // Otherwise creates default DSP keeping the same input/output number
  fDSPfactory = createDSPFactoryFromString("default", DEFAULT_CODE, 0, 0, getTarget(), error, LLVM_OPTIMIZATION);

  jassert(fDSPfactory);

  if (fDSPfactory)
  {
    dsp = fDSPfactory->createDSPInstance();
    logStr << "Allocation of default DSP succeeded, " << dsp->getNumInputs() << " input(s), " << dsp->getNumOutputs() << " output(s)";
  }

end:
  LOG(logStr);
  jassert(dsp);

  // Prepare JSON
  JSONUI builder(dsp->getNumInputs(), dsp->getNumOutputs());
  dsp->metadata(&builder);
  dsp->buildUserInterface(&builder);
  fJSON = String(builder.JSON());
  
  //LOG(fJSON);
  return dsp;
}
Exemple #17
0
void RangedManager::executeMicro(const UnitVector & targets) 
{
	const UnitVector & rangedUnits = getUnits();

	// figure out targets
	UnitVector rangedUnitTargets;
	for (size_t i(0); i<targets.size(); i++) 
	{
		// conditions for targeting
		if (targets[i]->isVisible()) 
		{
			rangedUnitTargets.push_back(targets[i]);
		}
	}

	// for each zealot
	BOOST_FOREACH(BWAPI::Unit * rangedUnit, rangedUnits)
	{
		// train sub units such as scarabs or interceptors
		//trainSubUnits(rangedUnit);

		// if the order is to attack or defend
		if (order.type == order.Attack || order.type == order.Defend || order.type == order.Tanks || order.type == order.Vultures || order.type == order.Goliaths || order.type == order.Marines) {

			// if there are targets
			if (!rangedUnitTargets.empty())
			{
				// find the best target for this zealot
				BWAPI::Unit * target = getTarget(rangedUnit, rangedUnitTargets);

				// attack it
				if (!rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Tank_Mode) {
					kiteTarget(rangedUnit, target);
				}
				else {
					smartPositionAndDefend(rangedUnit,order.position);
				}
			}
			// if there are no targets
			else
			{
				// if we're not in range of the position
				if (rangedUnit->getDistance(order.position) > rangedUnit->getInitialType().groundWeapon().maxRange())
				{
					//unsiege tanks if they're sieged
					if (rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Siege_Mode) {
						rangedUnit->unsiege();
					}
					// move to it
					if (! (order.type == order.Defend)) {
						smartAttackMove(rangedUnit, order.position);
					}
					else {
						smartPositionAndDefend(rangedUnit,order.position);
					}
				}
				//else if we're in range and we're supposed to s
				else if (rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Tank_Mode) {
					rangedUnit->siege();
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG) 
		{
			BWAPI::Broodwar->drawLineMap(rangedUnit->getPosition().x(), rangedUnit->getPosition().y(), 
				rangedUnit->getTargetPosition().x(), rangedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}
}
Exemple #18
0
void RTSCamera::animate(u32 elapsed)
{
	bool movebymouse = false;
   f32 nRotX = rotX;
   f32 nRotY = rotY;
   f32 nZoom = currentZoom;

   vector3df translate(oldTarget);
   vector3df tvectX = Pos - Target;
   tvectX = tvectX.crossProduct(UpVector);
   tvectX.normalize();

//   if(oldTarget.X != 0)
//   {
//   }

   //Zoom
   if (isMouseButtonDown(MOUSE_BUTTON_RIGHT) && isMouseButtonDown(MOUSE_BUTTON_LEFT))
   {
      if (!zooming)
      {
         zoomStartX = MousePos.X;
         zoomStartY = MousePos.Y;
         zooming = true;
         nZoom = currentZoom;
      }
      else
      {
         f32 old = nZoom;
         nZoom += (zoomStartX - MousePos.X) * zoomSpeed * 100;

//         f32 targetMinDistance = 0.1f;
//         if (nZoom < targetMinDistance)
//            nZoom = targetMinDistance;

         if (nZoom < targetMinDistance)
            nZoom = targetMinDistance;
         else if (nZoom > targetMaxDistance)
            nZoom = targetMaxDistance;


         if (nZoom < 0)
            nZoom = old;
      }
   }
   else
   {
      if (zooming)
      {
         f32 old = currentZoom;
         currentZoom = currentZoom + (zoomStartX - MousePos.X ) * zoomSpeed;
         nZoom = currentZoom;

         if (nZoom < 0)
            nZoom = currentZoom = old;
      }
      zooming = false;
   }

   //We rotate in Editor with right mouse button
   if(isMouseButtonDown(MOUSE_BUTTON_RIGHT) && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
   {
	   movebymouse = true;
      if (!rotating)
      {
         rotateStartX = MousePos.X;
         rotateStartY = MousePos.Y;
         rotating = true;
         //nRotX = rotX;
         //nRotY = rotY;
      }
      else
      {
         nRotX -= (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
         nRotY -= (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
		 rotX = nRotX;//rotX - (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
         rotY = nRotY;//rotY - (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
		 if(rotY < -350)
		 {
			 rotY = -350;
			 nRotY = -350;
		 }
		 if(rotY > -280)
		 {
			 rotY = -280;
			 nRotY = -280;
		 }
		 printf("PERA CAMERA:%f\n", rotY);
      }
   }
   else
   {
      if (rotating)
      {
         rotX = rotX - (rotateStartX - MousePos.X) * rotateSpeed * (f32)elapsed/500;
         rotY = rotY - (rotateStartY - MousePos.Y) * rotateSpeed * (f32)elapsed/500;
         nRotX = rotX;
         nRotY = rotY;
      }

      rotating = false;
   }

   //Translate
   if(isMouseButtonDown(MOUSE_BUTTON_RIGHT) && (isKeyDown(KEY_SHIFT) || isKeyDown(KEY_LSHIFT) || isKeyDown(KEY_RSHIFT)))
   {
	    movebymouse = true;
      if (!translating)
      {
         translateStartX = MousePos.X;
         translateStartY = MousePos.Y;
         translating = true;
      }
      else
      {
         translate += tvectX * (translateStartX - MousePos.X) * translateSpeed * (f32)elapsed/100;
         translate.X += tvectX.Z * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
         translate.Z -= tvectX.X * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;

         oldTarget = translate;
      }
   }
   else if (isKeyDown(KEY_KEY_W) || isKeyDown(KEY_UP) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
   {
      if (!translating)
         translating = true;
      else
      {
         vector3df movevector = getPosition() - getTarget();
         movevector.Y = 0;
         movevector.normalize();

          translate =getTarget() - movevector * translateSpeed * (f32)elapsed/100;
         oldTarget = translate;
         //setPosition(getPosition() - movevector * translateSpeed * (f32)elapsed/100);
         //setTarget(getTarget() - movevector * translateSpeed * (f32)elapsed/100);
         //updateAbsolutePosition();
      }
   }
   else if (isKeyDown(KEY_KEY_S) || isKeyDown(KEY_DOWN) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
   {
      if (!translating)
         translating = true;
      else
      {
         vector3df movevector = getPosition() - getTarget();
         movevector.Y = 0;
         movevector.normalize();

          translate =getTarget() + movevector * translateSpeed * (f32)elapsed/100;
         oldTarget = translate;
//        setPosition(getPosition() + movevector * translateSpeed * (f32)elapsed/100);
  //       setTarget(getTarget() + movevector * translateSpeed * (f32)elapsed/100);
    //     updateAbsolutePosition();
      }
   }
   else if (isKeyDown(KEY_KEY_A) || isKeyDown(KEY_LEFT) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
   {
      if (!translating)
         translating = true;
      else
      {
         /*translate += tvectX * (translateStartX - MousePos.X) * translateSpeed * (f32)elapsed/100;
         translate.X += tvectX.Z * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
         translate.Z -= tvectX.X * (translateStartY - MousePos.Y) * translateSpeed * (f32)elapsed/100;
*/
          //= translate;


		 vector3df totargetvector = getPosition() - getTarget();
         totargetvector.normalize();
         vector3df crossvector = totargetvector.crossProduct(getUpVector());
         vector3df strafevector = crossvector.normalize();

         translate =getTarget() - strafevector * translateSpeed * (f32)elapsed/100;
         oldTarget = translate;
         //setPosition(getPosition() - strafevector * translateSpeed * (f32)elapsed/100);
         //setTarget(getTarget() - strafevector * translateSpeed * (f32)elapsed/100);
		 //oldTarget = getTarget();
         //updateAbsolutePosition();
      }
   }
   else if (isKeyDown(KEY_KEY_D) || isKeyDown(KEY_RIGHT) && !zooming && !isKeyDown(KEY_SHIFT) && !isKeyDown(KEY_LSHIFT) && !isKeyDown(KEY_RSHIFT))
   {
      if (!translating)
         translating = true;
      else
      {
         vector3df totargetvector = getPosition() - getTarget();
         totargetvector.normalize();
         vector3df crossvector = totargetvector.crossProduct(getUpVector());
         vector3df strafevector = crossvector.normalize();

         translate =getTarget() + strafevector * translateSpeed * (f32)elapsed/100;
         oldTarget = translate;
        //setPosition(getPosition() + strafevector * translateSpeed * (f32)elapsed/100);
         //setTarget(getTarget() + strafevector * translateSpeed * (f32)elapsed/100);
         //updateAbsolutePosition();
      }
   }
   else
   {
      translating = false;

	  /*moving camera when mouse on screen edges*/
      /*if (!translating && !zooming && !rotating)
      {
         //Mouse Coordinates go from 0 to 1 on both axes
         if (MousePos.X < 0.05)   //Up
         {
            vector3df totargetvector = getPosition() - getTarget();
            totargetvector.normalize();
            vector3df crossvector = totargetvector.crossProduct(getUpVector());
            vector3df strafevector = crossvector.normalize();

            setPosition(getPosition() - strafevector * translateSpeed);
            setTarget(getTarget() - strafevector * translateSpeed);
            updateAbsolutePosition();
         }
         else if (MousePos.X > 0.95) //Down
         {
            vector3df totargetvector = getPosition() - getTarget();
            totargetvector.normalize();
            vector3df crossvector = totargetvector.crossProduct(getUpVector());
            vector3df strafevector = crossvector.normalize();

            setPosition(getPosition() + strafevector * translateSpeed);
            setTarget(getTarget() + strafevector * translateSpeed);
            updateAbsolutePosition();
         }
         else if (MousePos.Y < 0.05)   //Up
         {
            vector3df movevector = getPosition() - getTarget();
            movevector.Y = 0;
            movevector.normalize();

            setPosition(getPosition() - movevector * translateSpeed);
            setTarget(getTarget() - movevector * translateSpeed);
            updateAbsolutePosition();
         }
         else if (MousePos.Y > 0.95) //Down
         {
            vector3df movevector = getPosition() - getTarget();
            movevector.Y = 0;
            movevector.normalize();

            setPosition(getPosition() + movevector * translateSpeed);
            setTarget(getTarget() + movevector * translateSpeed);
            updateAbsolutePosition();
         }
      }*/
   }

   //Set Position
   //if(movebymouse)
   //{
		Target = translate;

		Pos.X = nZoom + Target.X;
		Pos.Y = Target.Y;
		Pos.Z = Target.Z;

		Pos.rotateXYBy(nRotY, Target);
		Pos.rotateXZBy(-nRotX, Target);

		//Correct Rotation Error
		UpVector.set(0,1,0);
		UpVector.rotateXYBy(-nRotY, core::vector3df(0,0,0));
		UpVector.rotateXZBy(-nRotX+180.f, core::vector3df(0,0,0));
   //}
}
Exemple #19
0
int32 HtmlTabCtrl::getCurSel() const
{
	return hasID() ? conversions::from_wstring<int32>(getRequest()->getUrlParam(getTarget().to_wide())) : -1;
}
Exemple #20
0
void MapReference::targetObjectBuildLink()
{
    // called from link()
    getTarget()->m_mapRefManager.insertFirst(this);
    getTarget()->m_mapRefManager.incSize();
}
Exemple #21
0
void CC3ActionCCNodeSizeTo::update( float t )
{
	CCNode* tNode = (CCNode*)getTarget();
	tNode->setContentSize( CCSizeMake(startSize_.width + (sizeChange_.width * t),
								   startSize_.height + (sizeChange_.height * t)) );
}
Exemple #22
0
void MapReference::targetObjectDestroyLink()
{
    // called from unlink()
    if (isValid())
        getTarget()->m_mapRefManager.decSize();
}
void FollowerReference::targetObjectDestroyLink()
{
    getTarget()->removeFollower(this);
}
Exemple #24
0
void MapReference::sourceObjectDestroyLink()
{
    // called from invalidate()
    getTarget()->m_mapRefManager.decSize();
}
void GroupReference::targetObjectBuildLink()
{
    // called from link()
    getTarget()->LinkMember(this);
}
Exemple #26
0
image::GnashImage*
Video::getVideoFrame()
{
    // If this is a video from a NetStream_as object, retrieve a video
    // frame from there.
    if (_ns) {
        std::unique_ptr<image::GnashImage> tmp = _ns->get_video();
        if (tmp.get()) _lastDecodedVideoFrame = std::move(tmp);
    }

    // If this is a video from a VideoFrame tag, retrieve a video frame
    // from there.
    else if (_embeddedStream) {

        // Don't try to do anything if there is no decoder. If it was
        // never constructed (most likely), we'll return nothing,
        // otherwise the last decoded frame.
        if (!_decoder.get()) {
            LOG_ONCE(log_error(_("No Video info in video definition")));
            return _lastDecodedVideoFrame.get();
        }

        const std::uint16_t current_frame = get_ratio();

#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
        log_debug("Video instance %s need display video frame (ratio) %d",
                  getTarget(), current_frame);
#endif

        // If current frame is the same then last decoded
        // we don't need to decode more
        if (_lastDecodedVideoFrameNum >= 0 &&
                _lastDecodedVideoFrameNum == current_frame) {
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
            log_debug("  current frame == _lastDecodedVideoFrameNum (%d)",
                      current_frame);
#endif
            return _lastDecodedVideoFrame.get();
        }

        // TODO: find a better way than using -1 to show that no
        // frames have been decoded yet.
        assert(_lastDecodedVideoFrameNum >= -1);
        std::uint16_t from_frame = _lastDecodedVideoFrameNum + 1;

        // If current frame is smaller then last decoded frame
        // we restart decoding from scratch
        if (current_frame < static_cast<size_t>(_lastDecodedVideoFrameNum)) {
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
            log_debug("  current frame (%d) < _lastDecodedVideoFrameNum (%d)",
                      current_frame, _lastDecodedVideoFrameNum);
#endif
            from_frame = 0;
        }

        // Reset last decoded video frame number now, so it's correct
        // on early return (ie: nothing more to decode)
        _lastDecodedVideoFrameNum = current_frame;

#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
        log_debug("  decoding embedded frames from %d to %d "
                  "for Video object %s", from_frame,
                  current_frame, getTarget());
#endif

        const size_t frames = m_def->visitSlice(
                                  std::bind(std::mem_fn(&media::VideoDecoder::push),
                                            _decoder.get(), std::placeholders::_1),
                                  from_frame, current_frame);

        if (!frames) return _lastDecodedVideoFrame.get();

        _lastDecodedVideoFrame = _decoder->pop();
    }

    return _lastDecodedVideoFrame.get();
}
void GroupReference::sourceObjectDestroyLink()
{
    // called from invalidate()
    getTarget()->DelinkMember(this);
}
Exemple #28
0
void VBO::bind()
{
	if (!is_mapped)
		glBindBufferARB(getTarget(), vbo);
}
Exemple #29
0
//============================================================
// Tell our refTo (taget) object, that the link is cut
void HostileReference::targetObjectDestroyLink()
{
    getTarget()->RemoveHatedBy(this);
}
    void DirectXShader::compileShader(const std::shared_ptr<class DirectXRenderer>& renderer, DataChunk data, ID3DInclude* includes, const std::string& entryPoint, ShaderType type)
    {
        ComPtr<ID3D10Blob> errors;
        HRESULT hr = D3DCompile(data.data(), data.size(), "", NULL, includes, entryPoint.c_str(), getTarget(type), D3DCOMPILE_DEBUG | D3DCOMPILE_PREFER_FLOW_CONTROL | D3DCOMPILE_SKIP_OPTIMIZATION, 0, mBlob.getInitRef(), errors.getInitRef());
        if (hr != S_OK)
        {
            log("%s", errors->GetBufferPointer());
            runtimeCheck(false);
        }

        switch (type)
        {
        case ShaderType::Vertex:
            hr = renderer->getDevice()->CreateVertexShader(mBlob->GetBufferPointer(), mBlob->GetBufferSize(), nullptr, mVertexShader.getInitRef());
            TB::runtimeCheck(hr == S_OK);
            break;
        case ShaderType::Pixel:
            hr = renderer->getDevice()->CreatePixelShader(mBlob->GetBufferPointer(), mBlob->GetBufferSize(), nullptr, mPixelShader.getInitRef());
            TB::runtimeCheck(hr == S_OK);
            break;
        }

    }