Пример #1
0
    void Test::SendMsg(EntityPtr e1, EntityPtr e2, Message::Message message)
    {
      EntityPtr camera = ENGINE->GetSpace("Particle Demo")->GetCamera();
      switch (message)
      {
      case(Message::MV_Up) :
        camera->GET_COMPONENT(Transform)->position.y += 1000.f * ENGINE->Getdt();
        break;
      case(Message::MV_Down) :
        camera->GET_COMPONENT(Transform)->position.y -= 1000.f * ENGINE->Getdt();
        break;
      case(Message::MV_Left) :
        camera->GET_COMPONENT(Transform)->position.x -= 1000.f * ENGINE->Getdt();
        break;
      case(Message::MV_Right) :
        camera->GET_COMPONENT(Transform)->position.x += 1000.f * ENGINE->Getdt();
        break;

      case(Message::MV_BackButton) :
        ENGINE->PushGamestate(PauseMenuPtr(new PauseMenu()));
        break;

      case(Message::MV_PopGamestate) :
        ENGINE->PopGamestate();
        break;

      default:
        break;
      }
    }
Пример #2
0
 void Test::Update(float dt)
 {
   switch (DemoToUse)
   {
   case(Demo::Pretzel) :
     PretzelDemo(dt);
     break;
   case(Demo::FireBall) :
     FireBallDemo(dt);
     break;
   case Demo::Explosion:
     ExplosionDemo(200);
     break;
   default:
     break;
   }
   
   // This is wrapped in a try catch block because it's possible the entity acquired by name doesn't have the necessary components.
   // If that is the case, the try block will encounter and exception, that gets handled by just ignoring the operation and moving on.
   try
   {
     EntityPtr mouse = ENGINE->GetActiveSpace()->GetEntityByName("Mouse");
     mouse->GET_COMPONENT(Transform)->position = GETSYS(WindowSDL)->GetMousePosition();
     mouse->GET_COMPONENT(Transform)->scale = { 10.f, 10.f };
   }
   catch (...)
   {
     
   }
 }
Пример #3
0
    void WeaponController::FireWeapon(EntityPtr entity)
    {
      WeaponPtr weapon = entity->GET_COMPONENT(Weapon);
      TransformPtr transform = entity->GET_COMPONENT(Transform);

      if (weapon->shotCooldownRemaining > 0.f)
        return;

      // Reset the shot cooldown because the weapon should only shoot at its rate of fire.
      weapon->shotCooldownRemaining = weapon->rateOfFire;
      weapon->shots += 1;

      EntityPtr bullet = ENGINE->Factory().create("Bullet");
      bullet->GET_COMPONENT(Parent)->parent = entity;

      // Start the bullet at the shooter's location
      bullet->GET_COMPONENT(Transform)->position = transform->position;
      bullet->GET_COMPONENT(Transform)->rotation = transform->rotation;

      // Set up the physics info for the bullet
      float direction = transform->rotation * DEG2RAD;
      bullet->GET_COMPONENT(RigidBody)->direction = glm::normalize(glm::vec2(cos(direction), sin(direction)));
      bullet->GET_COMPONENT(RigidBody)->speed = weapon->projectileSpeed;

      // Set the duration of the bullet
      bullet->GET_COMPONENT(Lifetime)->lifetime = weapon->projectileLifetime;

      // Add the bullet to the world!
      ENGINE->GetActiveSpace()->AddEntity(bullet);
    }
Пример #4
0
    void Test::ExplosionSpawn(unsigned count)
    {
      // Get a reference to the "Game World" space so that we can add an object to it.
      SpacePtr gameworld = ENGINE->GetSpace("Game World");
      gameworld->GetCamera()->GET_COMPONENT(Transform)->scale = { 160.f, 90.f };
      // Clear out any existing objects
      //gameworld.Clear();

      for (unsigned i = 0; i < count; ++i)
      {
        EntityPtr entity;
        std::ostringstream name;

        // Create an entity from the "Box" archetype.
        entity = ENGINE->Factory().create("Box Particle");

        // reduce the scale of the particle so it's a bit smaller
        entity->GET_COMPONENT(Transform)->scale = glm::vec2(0.5f, 0.5f);

        // Set the particle properties
        ParticlePtr particle = entity->GET_COMPONENT(Particle);
        float xvel = static_cast<float>((rand() % 10000) - 5000) / 10000.f;
        float yvel = static_cast<float>((rand() % 10000) - 5000) / 10000.f;
        particle->velocity = glm::normalize(glm::vec2(xvel, yvel));

        float r = static_cast<float>(rand() % 1000) / 1000.f;
        float g = r - static_cast<float>(rand() % 1000) / 1000.f;
        entity->GET_COMPONENT(Sprite)->_color = glm::vec4(r, g, 0.f, 1.f);

        // Create a string stream to generate a name for the entity.
        name << "Fire Particle " << i / 2;
        // Set the generated name.
        entity->SetName(name.str());

        // Add the object to the game world.
        gameworld->AddEntity(entity);
      }
    }
Пример #5
0
    void Test::FireBallSpawn(unsigned count)
    {
      // Get a reference to the "Game World" space so that we can add an object to it.
      SpacePtr gameworld = ENGINE->GetSpace("Particle Demo");

      glm::vec2 mousepos = GETSYS(WindowSDL)->GetMousePosition();

      for (unsigned i = 0; i < count; ++i)
      {
        // get a degree anywhere in a circle (0 through 360)
        float angle = RandFloat() * 360.f;

        float scale = RandFloat() * 80.f;

        glm::vec2 startPos = { cosf(angle) * scale + mousepos.x, sinf(angle) * scale + mousepos.y };

        glm::vec2 velocity = { 0.f, RandFloat() * 8.f - 16.f };
        float lifetime = RandFloat() * 2.f;

        EntityPtr entity = ENGINE->Factory().create("Fire Particle");

        entity->GET_COMPONENT(Transform)->scale = glm::vec2(3.5f, 3.5f);
        entity->GET_COMPONENT(Transform)->position = startPos;
        entity->GET_COMPONENT(Transform)->rotation = 0.f;
        entity->GET_COMPONENT(Particle)->velocity = velocity;
        entity->GET_COMPONENT(Particle)->lifetime = lifetime;

        // Create a string stream to generate a name for the entity.
        std::ostringstream name;
        name << "Fire Particle " << i / 2;
        // Set the generated name.
        entity->SetName(name.str());

        // Add the object to the game world.
        gameworld->AddEntity(entity);
      }

    }
Пример #6
0
    /*!
    * @brief Draws everything that is in the entities list with a sprite component
    * @param Entity the entity that is going to be drawn
    * @param camera the camera used to draw the objects to
    */
    void GLGraphics::DrawEntity(const EntityPtr &Entity, const CameraPtr &camera)
    {
      ShaderPtr shader = _shaders.find(Entity->GET_COMPONENT(Sprite)->_shaderName)->second;

      TransformPtr transform = Entity->GET_COMPONENT(Transform);

      if (shader.get() != nullptr)
      {
        //constructing the matrix of the transform
        glm::mat4x4 object2world;
        object2world = glm::translate(object2world, 
                                      glm::vec3( Entity->GET_COMPONENT(Transform)->position.x,
                                                 Entity->GET_COMPONENT(Transform)->position.y,
                                                 0.0f )
                                     );

        object2world = glm::rotate( object2world, 
                                    transform->rotation * 3.141592f / 180.f, // degrees to radians conversion 
                                    glm::vec3(0.f, 0.f, 1.0f)
                                  );

        object2world = glm::scale(object2world, 
                                  glm::vec3(transform->scale.x,
                                            transform->scale.y,
                                            0.f)
                                 );

        //Updating the uniforms in the shader, has to happen every frame
        shader->UpdateUniforms("model", object2world);

        shader->UpdateUniforms("view", camera->_viewMatrix);
        
        //Switching the camera's projection matrix based on the flag
        switch (camera->viewtype)
        {
        case Camera::CV_ORTHOGRAPHIC:
          shader->UpdateUniforms("proj", camera->_ortho);
          break;
        case Camera::CV_PERSPECTIVE:
          shader->UpdateUniforms("proj", camera->_pespective);
          break;
        }

        shader->UpdateUniforms("color", Entity->GET_COMPONENT(Sprite)->_color);
        
        shader->Use();

        switch (Entity->GET_COMPONENT(Sprite)->mesh)
        {
        case Sprite::QUAD:
          glBindVertexArray(_quadInfo.vao);
          glDrawElements(
            GL_TRIANGLE_STRIP, //Draw Type
            6,                 //Number of points
            GL_UNSIGNED_SHORT, //Data that it is when being read
            nullptr);          
          break;
        case Sprite::CIRCLE:
          glBindVertexArray(_circleInfo.vao);
          glDrawElements(GL_TRIANGLE_FAN, 30000, GL_UNSIGNED_SHORT, nullptr);
          break;
        default:
          glBindVertexArray(_quadInfo.vao);
          glDrawElements(GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, nullptr);
          break;
        }
            
      }
    }