C++ RuntimeScene类代码示例

float GD_API GetCameraY(RuntimeScene & scene, const gd::String & layer, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return 0.f;
    const sf::View & view = scene.GetRuntimeLayer(layer).GetCamera(camera).GetSFMLView();
    return view.getCenter().y;
}

/**
 * Delete a camera of a layer
 */
void GD_API ActDeleteCamera(RuntimeScene & scene, const gd::String & layerName, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layerName).GetCameraCount())
        return;

    scene.GetRuntimeLayer(layerName).DeleteCamera(camera);
}

void GD_API SetCameraAngle(RuntimeScene & scene, float newValue, const gd::String & layer, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    return scene.GetRuntimeLayer(layer).GetCamera(camera).SetRotation(newValue);
}

bool RuntimeObject::CursorOnObject(RuntimeScene &scene, bool) {
  RuntimeLayer &theLayer = scene.GetRuntimeLayer(layer);
  auto insideObject = [this](const sf::Vector2f &pos) {
    return GetDrawableX() <= pos.x && GetDrawableX() + GetWidth() >= pos.x &&
           GetDrawableY() <= pos.y && GetDrawableY() + GetHeight() >= pos.y;
  };

  for (std::size_t cameraIndex = 0; cameraIndex < theLayer.GetCameraCount();
       ++cameraIndex) {
    const auto &view = theLayer.GetCamera(cameraIndex).GetSFMLView();

    sf::Vector2f mousePos = scene.renderWindow->mapPixelToCoords(
        scene.GetInputManager().GetMousePosition(), view);

    if (insideObject(mousePos)) return true;

    auto &touches = scene.GetInputManager().GetAllTouches();
    for (auto &it : touches) {
      sf::Vector2f touchPos =
          scene.renderWindow->mapPixelToCoords(it.second, view);
      if (insideObject(touchPos)) return true;
    }
  }

  return false;
}

void GD_API SetCameraZoom(RuntimeScene & scene, float newZoom, const gd::String & layer, std::size_t cameraNb)
{
    if(cameraNb >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    scene.GetRuntimeLayer(layer).GetCamera(cameraNb).SetZoom(newZoom);
}

void GD_EXTENSION_API CreateSFMLTexture( RuntimeScene & scene, const gd::String & imageName, unsigned int width, unsigned int height, const gd::String & colorStr )
{
    //Get or create the texture in memory
    std::shared_ptr<SFMLTextureWrapper> newTexture;
    if ( !scene.GetImageManager()->HasLoadedSFMLTexture(imageName) )
        newTexture = std::shared_ptr<SFMLTextureWrapper>(new SFMLTextureWrapper);
    else
        newTexture = scene.GetImageManager()->GetSFMLTexture(imageName);

    //Get the color
    sf::Color color;
    bool colorIsOk = false;
    std::vector < gd::String > colors = colorStr.Split(U';');
    if ( colors.size() == 3 )
    {
        colorIsOk = true;
        color = sf::Color(colors[0].To<int>(), colors[1].To<int>(), colors[2].To<int>());
    }

    //Create the SFML image and the SFML texture
    if ( width != 0 && height != 0 && colorIsOk )
        newTexture->image.create(width, height, color);

    newTexture->texture.loadFromImage(newTexture->image); //Do not forget to update the associated texture

    scene.GetImageManager()->SetSFMLTextureAsPermanentlyLoaded(imageName, newTexture); //Otherwise
}

double GD_API GetCameraHeight(RuntimeScene & scene, const gd::String & layer, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return 0.f;

    return scene.GetRuntimeLayer(layer).GetCamera(camera).GetHeight();
}

double GD_API GetCameraViewportTop(RuntimeScene & scene, const gd::String & layer, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return 0.f;

    return scene.GetRuntimeLayer(layer).GetCamera(camera).GetSFMLView().getViewport().top;
}

void GD_API SetWindowSize( RuntimeScene & scene, int windowWidth, int windowHeight, bool useTheNewSizeForCameraDefaultSize)
{
    #if !defined(GD_IDE_ONLY)
    if ( useTheNewSizeForCameraDefaultSize ) //Change future cameras default size if wanted.
    {
        scene.game->SetDefaultWidth( windowWidth );
        scene.game->SetDefaultHeight( windowHeight );
    }

    //Avoid recreating every tick a new window if the size has not changed!
    if ( windowWidth == scene.renderWindow->getSize().x && windowHeight == scene.renderWindow->getSize().y )
        return;

    if ( scene.RenderWindowIsFullScreen() )
    {
        scene.renderWindow->create( sf::VideoMode( windowWidth, windowHeight, 32 ), scene.GetWindowDefaultTitle(), sf::Style::Close | sf::Style::Fullscreen );
        scene.ChangeRenderWindow(scene.renderWindow);
    }
    else
    {
        scene.renderWindow->create( sf::VideoMode( windowWidth, windowHeight, 32 ), scene.GetWindowDefaultTitle(), sf::Style::Close );
        scene.ChangeRenderWindow(scene.renderWindow);
    }
    #endif
}

void GD_API CenterCameraOnObjectWithLimits(RuntimeScene & scene, RuntimeObject * object, float left, float top, float right, float bottom, bool anticipateObjectMove, const gd::String & layer, std::size_t camera)
{
    if ( object == NULL ) return;

    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    float xOffset = 0;
    float yOffset = 0;
    double elapsedTime = static_cast<double>(object->GetElapsedTime(scene)) / 1000000.0;
    if (anticipateObjectMove)
    {
        xOffset = object->TotalForceX() * elapsedTime;
        yOffset = object->TotalForceY() * elapsedTime;
    }

    RuntimeCamera & cam = scene.GetRuntimeLayer(layer).GetCamera(camera);

    double newX = std::min(std::max(object->GetDrawableX() + object->GetCenterX() + xOffset, left+cam.GetWidth()/2), right-cam.GetWidth()/2);
    double newY = std::min(std::max(object->GetDrawableY() + object->GetCenterY() + yOffset, top+cam.GetHeight()/2), bottom-cam.GetHeight()/2);

    cam.SetViewCenter(sf::Vector2f(newX, newY));

    return;
}

/**
 * Change the size of a camera and reset the zoom factor.
 */
void GD_API SetCameraSize( RuntimeScene & scene, const gd::String & layer, std::size_t cameraNb, float width, float height)
{
    if(cameraNb >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    scene.GetRuntimeLayer(layer).GetCamera(cameraNb).SetZoom(1);
    scene.GetRuntimeLayer(layer).GetCamera(cameraNb).SetSize(width, height);
}

void GD_API SetCameraY(RuntimeScene & scene, float y, const gd::String & layer, std::size_t cameraId)
{
    if(cameraId >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    RuntimeCamera & camera = scene.GetRuntimeLayer(layer).GetCamera(cameraId);
    camera.SetViewCenter(sf::Vector2f(camera.GetViewCenter().x, y));
}

void GD_API SetCameraViewport( RuntimeScene & scene,  const gd::String & layer, std::size_t cameraNb, float viewportLeft, float viewportTop, float viewportRight, float viewportBottom )
{
    if(cameraNb >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return;

    RuntimeCamera & camera = scene.GetRuntimeLayer(layer).GetCamera(cameraNb);
    camera.SetViewport(viewportLeft, viewportTop, viewportRight, viewportBottom);
}

double GD_API GetCameraViewportBottom(RuntimeScene & scene, const gd::String & layer, std::size_t camera)
{
    if(camera >= scene.GetRuntimeLayer(layer).GetCameraCount())
        return 0.f;

    const sf::FloatRect & sfmlViewport = scene.GetRuntimeLayer(layer).GetCamera(camera).GetSFMLView().getViewport();

    return sfmlViewport.top+sfmlViewport.height;
}

double GD_API GetCursorYPosition(RuntimeScene &scene,
                                 const gd::String &layer,
                                 std::size_t camera) {
  if (scene.GetRuntimeLayer(layer).GetCameraCount() == 0) return 0;
  if (camera >= scene.GetRuntimeLayer(layer).GetCameraCount()) camera = 0;

  // Get view, and compute mouse position
  const sf::View &view =
      scene.GetRuntimeLayer(layer).GetCamera(camera).GetSFMLView();
  return scene.renderWindow
      ->mapPixelToCoords(scene.GetInputManager().GetMousePosition(), view)
      .y;
}